Moved conversion output classes to CodeConversionResults trait

Author: ochafik

src/main/scala/scalacl/impl/CodeConversion.scala

@@ -31,33 +31,26 @@
 package scalacl.impl
 import scalaxy.components.FlatCode
 import scalaxy.components.FlatCodes._
+import scalaxy.components.StreamTransformers
 
 import scalacl.CLArray
 import scalacl.CLFilteredArray
 
 import scala.reflect.api.Universe
 import scala.util.matching.Regex
 
-trait CodeConversion extends OpenCLConverter with UniverseCasts {
-  val global: Universe
-  def fresh(s: String): String
+trait CodeConversion
+    extends OpenCLConverter
+    with StreamTransformers
+    with CodeConversionResults
+    with UniverseCasts {
 
+  val global: Universe
   import global._
   import definitions._
 
-  case class ParamDesc(
-      symbol: Symbol,
-      tpe: Type,
-      mode: ParamKind,
-      usage: UsageKind,
-      implicitIndexDimension: Option[Int] = None,
-      rangeOffset: Option[Symbol] = None,
-      rangeStep: Option[Symbol] = None) {
-    assert((mode == ParamKind.ImplicitArrayElement || mode == ParamKind.RangeIndex) == (implicitIndexDimension != None))
-    def isArray =
-      mode == ParamKind.ImplicitArrayElement || mode == ParamKind.Normal && tpe <:< typeOf[CLArray[_]]
-  }
-
+  def fresh(s: String): String
+  def cleanTypeCheck(tree: Tree): Tree
   /*
   ParamDesc(i, ParamKindRangeIndex, Some(0))
     -> get_global_id(0)
@@ -68,13 +61,45 @@ trait CodeConversion extends OpenCLConverter with UniverseCasts {
   ParamDesc(x, ParamKindRead, Some(0))
     -> x[get_global_id(0)]
   */
-  case class CodeConversionResult(
-    code: String,
-    capturedInputs: Seq[ParamDesc],
-    capturedOutputs: Seq[ParamDesc],
-    capturedConstants: Seq[ParamDesc])
+  def transformStreams(tree: Tree, paramDescs: Seq[ParamDesc]): (Tree, Seq[ParamDesc]) = {
+    val typableBlock =
+      Block(
+        for (param <- paramDescs.toList) yield {
+          ValDef(
+            if (param.output)
+              Modifiers(Flag.MUTABLE)
+            else
+              NoMods,
+            param.name,
+            TypeTree(param.tpe),
+            Literal(Constant(defaultValue(param.tpe)))
+          )
+        },
+        tree.duplicate)
+
+    println(s"""
+      Generating CL function for:
+        tree = $tree
+        paramDescs = $paramDescs
+        typableBlock = $typableBlock
+    """)
+
+    val Block(valdefs, transformedBody) =
+      newStreamTransformer(false).transform(cleanTypeCheck(typableBlock))
+
+    println(s"""
+        transformedBody = $transformedBody
+    """)
+
+    (
+      transformedBody,
+      for ((paramDesc, vd) <- paramDescs.zip(valdefs)) yield paramDesc.copy(symbol = vd.symbol)
+    )
+  }
+
+  def convertCode(tree: Tree, initialParamDescs: Seq[ParamDesc]): CodeConversionResult = {
+    val (code, explicitParamDescs) = transformStreams(tree, initialParamDescs)
 
-  def convertCode(code: Tree, explicitParamDescs: Seq[ParamDesc]): CodeConversionResult = {
     val externalSymbols =
       getExternalSymbols(
         code,
@@ -88,6 +113,7 @@ trait CodeConversion extends OpenCLConverter with UniverseCasts {
         ParamDesc(
           sym.asInstanceOf[Symbol],
           tpe.asInstanceOf[Type],
+          output = false,
           mode = ParamKind.Normal,
           usage = usage)
       }
@@ -102,11 +128,13 @@ trait CodeConversion extends OpenCLConverter with UniverseCasts {
             ParamDesc(
               symbol = d.rangeOffset.get,
               tpe = IntTpe,
+              output = false,
               mode = ParamKind.Normal,
               usage = UsageKind.Input),
             ParamDesc(
               symbol = d.rangeStep.get,
               tpe = IntTpe,
+              output = false,
               mode = ParamKind.Normal,
               usage = UsageKind.Input)
           )
@@ -137,10 +165,10 @@ trait CodeConversion extends OpenCLConverter with UniverseCasts {
       val r = ("\\b(" + Regex.quoteReplacement(paramDesc.symbol.name.toString) + ")\\b").r
       // TODO handle composite types, with replacements of all possible fibers (x._1, x._2._1, x._2._2)
       paramDesc match {
-        case ParamDesc(_, _, ParamKind.ImplicitArrayElement, _, Some(i), None, None) =>
+        case ParamDesc(_, _, _, ParamKind.ImplicitArrayElement, _, Some(i), None, None) =>
           (s: String) =>
             r.replaceAllIn(s, "$1" + Regex.quoteReplacement("[" + globalIDValNames(i) + "]"))
-        case ParamDesc(_, _, ParamKind.RangeIndex, _, Some(i), Some(from), Some(by)) =>
+        case ParamDesc(_, _, _, ParamKind.RangeIndex, _, Some(i), Some(from), Some(by)) =>
           (s: String) =>
             r.replaceAllIn(s, Regex.quoteReplacement("(" + from.name + " + " + globalIDValNames(i) + " * " + by.name + ")"))
         case _ =>

src/main/scala/scalacl/impl/CodeConversionResults.scala

@@ -0,0 +1,95 @@
+/*
+ * ScalaCL - putting Scala on the GPU with JavaCL / OpenCL
+ * http://scalacl.googlecode.com/
+ *
+ * Copyright (c) 2009-2013, Olivier Chafik (http://ochafik.com/)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Olivier Chafik nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY OLIVIER CHAFIK AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package scalacl.impl
+import scalaxy.components.FlatCode
+import scalaxy.components.FlatCodes._
+
+import scalacl.CLArray
+import scalacl.CLFilteredArray
+
+import scala.reflect.api.Universe
+import scala.util.matching.Regex
+
+trait CodeConversionResults {
+  val global: Universe
+  def fresh(s: String): String
+
+  import global._
+  import definitions._
+
+  sealed trait ParamKind
+  object ParamKind {
+    case object ImplicitArrayElement extends ParamKind
+    case object RangeIndex extends ParamKind
+    case object Normal extends ParamKind
+  }
+
+  sealed abstract class UsageKind(val isInput: Boolean, val isOutput: Boolean) {
+    def merge(usage: UsageKind): UsageKind
+  }
+  object UsageKind {
+    case object Input extends UsageKind(true, false) {
+      override def merge(usage: UsageKind) =
+        if (usage == Input) Input
+        else InputOutput
+    }
+    case object Output extends UsageKind(false, true) {
+      override def merge(usage: UsageKind) =
+        if (usage == Output) Output
+        else InputOutput
+    }
+    case object InputOutput extends UsageKind(true, true) {
+      override def merge(usage: UsageKind) = this
+    }
+  }
+
+  case class ParamDesc(
+      symbol: Symbol,
+      tpe: Type,
+      output: Boolean,
+      mode: ParamKind,
+      usage: UsageKind,
+      implicitIndexDimension: Option[Int] = None,
+      rangeOffset: Option[Symbol] = None,
+      rangeStep: Option[Symbol] = None) {
+    assert((mode == ParamKind.ImplicitArrayElement || mode == ParamKind.RangeIndex) == (implicitIndexDimension != None))
+    def isArray =
+      mode == ParamKind.ImplicitArrayElement || mode == ParamKind.Normal && tpe <:< typeOf[CLArray[_]]
+
+    def name = symbol.name.asInstanceOf[TermName]
+  }
+
+  case class CodeConversionResult(
+    code: String,
+    capturedInputs: Seq[ParamDesc],
+    capturedOutputs: Seq[ParamDesc],
+    capturedConstants: Seq[ParamDesc])
+}