Basis for compiled expressions

src/main/scala/leon/codegen/CodeGenPhase.scala

@@ -15,45 +15,13 @@ object CodeGenPhase extends LeonPhase[Program,CompilationResult] {
   def run(ctx : LeonContext)(p : Program) : CompilationResult = {
     import CodeGeneration._
 
-    // This sets up an environment where all classes and all functions have names.
-    implicit val env = CompilationEnvironment.fromProgram(p)
-
-    for((parent,children) <- p.algebraicDataTypes) {
-      val acf = compileAbstractClassDef(p, parent)
-      val ccfs = children.map(c => compileCaseClassDef(p, c))
-    } 
-
-    val mainClassName = defToJVMName(p, p.mainObject)
-    val cf = new ClassFile(mainClassName, None)
-    cf.addDefaultConstructor
-
-    cf.setFlags((
-      CLASS_ACC_SUPER |
-      CLASS_ACC_PUBLIC |
-      CLASS_ACC_FINAL
-    ).asInstanceOf[U2])
-
-    // This assumes that all functions of a given program get compiled
-    // as methods of a single class file.
-    for(funDef <- p.definedFunctions;
-        (_,mn,_) <- env.funDefToMethod(funDef)) {
-
-      val m = cf.addMethod(
-        typeToJVM(funDef.returnType),
-        mn,
-        funDef.args.map(a => typeToJVM(a.tpe)) : _*
-      )
-      m.setFlags((
-        METHOD_ACC_PUBLIC |
-        METHOD_ACC_FINAL |
-        METHOD_ACC_STATIC
-      ).asInstanceOf[U2])
- 
-      CodeGeneration.compileFunDef(funDef, m.codeHandler)
+    CompilationUnit.compileProgram(p) match {
+      case Some(unit) => 
+        unit.writeClassFiles()
+        CompilationResult(successful = true)
+      case None =>
+        CompilationResult(successful = false)
     }
 
-    cf.writeToFile(mainClassName + ".class")
-
-    CompilationResult(successful = true)
   } 
 }

src/main/scala/leon/codegen/CodeGeneration.scala

@@ -46,7 +46,7 @@ object CodeGeneration {
     ch.freeze
   }
 
-  private def mkExpr(e : Expr, ch : CodeHandler)(implicit env : CompilationEnvironment) {
+  private[codegen] def mkExpr(e : Expr, ch : CodeHandler)(implicit env : CompilationEnvironment) {
     e match {
       case Variable(id) =>
         val slot = slotFor(id)
@@ -151,7 +151,7 @@ object CodeGeneration {
     }
   }
 
-  private def mkBranch(cond : Expr, then : String, elze : String, ch : CodeHandler)(implicit env : CompilationEnvironment) {
+  private[codegen] def mkBranch(cond : Expr, then : String, elze : String, ch : CodeHandler)(implicit env : CompilationEnvironment) {
     cond match {
       case BooleanLiteral(true) =>
         ch << Goto(then)
@@ -189,22 +189,22 @@ object CodeGeneration {
         mkExpr(l, ch)
         mkExpr(r, ch)
         ch << If_ICmpLt(then) << Goto(elze) 
-      
+
       case GreaterThan(l,r) =>
         mkExpr(l, ch)
         mkExpr(r, ch)
         ch << If_ICmpGt(then) << Goto(elze) 
-      
+
       case LessEquals(l,r) =>
         mkExpr(l, ch)
         mkExpr(r, ch)
         ch << If_ICmpLe(then) << Goto(elze) 
-      
+
       case GreaterEquals(l,r) =>
         mkExpr(l, ch)
         mkExpr(r, ch)
         ch << If_ICmpGe(then) << Goto(elze) 
-      
+
       // WARNING !!! mkBranch delegates to mkExpr, and mkExpr delegates to mkBranch !
       // That means, between the two of them, they'd better know what to generate !
       case other =>
@@ -213,7 +213,7 @@ object CodeGeneration {
     }
   }
 
-  private def slotFor(id : Identifier)(implicit env : CompilationEnvironment) : Int = {
+  private[codegen] def slotFor(id : Identifier)(implicit env : CompilationEnvironment) : Int = {
     env.varToLocal(id).getOrElse {
       throw CompilationException("Unknown variable : " + id)
     }

src/main/scala/leon/codegen/CompilationUnit.scala

+package leon
+package codegen
+
+import purescala.Common._
+import purescala.Definitions._
+import purescala.Trees._
+import purescala.TypeTrees._
+
+import cafebabe._
+import cafebabe.AbstractByteCodes._
+import cafebabe.ByteCodes._
+import cafebabe.ClassFileTypes._
+import cafebabe.Flags._
+
+import CodeGeneration._
+
+class CompilationUnit(val p: Program, val mainClass: ClassFile, implicit val env: CompilationEnvironment) {
+  val mainClassName = defToJVMName(p, p.mainObject)
+
+  val loader = new CafebabeClassLoader
+
+  def writeClassFiles() {
+    mainClass.writeToFile(mainClassName + ".class")
+  }
+
+  private var _nextExprId = 0
+  def nextExprId = {
+    _nextExprId += 1
+    _nextExprId
+  }
+
+  def groundExprToJava(e: Expr): AnyRef = {
+    null
+  }
+
+  def javaToGroundExpr(e: AnyRef): Expr = {
+    null
+  }
+
+  def compileExpression(e: Expr, args: Seq[Identifier]): CompiledExpression = {
+
+    val id = nextExprId
+
+    val cName = "Leon$CodeGen$Expr$"+id
+
+    val cf = new ClassFile(cName, None)
+    cf.setFlags((
+      CLASS_ACC_PUBLIC |
+      CLASS_ACC_FINAL
+    ).asInstanceOf[U2])
+
+    cf.addDefaultConstructor
+
+    val m = cf.addMethod(
+      typeToJVM(e.getType),
+      "eval",
+      args.map(a => typeToJVM(a.getType)) : _*
+    )
+
+    m.setFlags((
+      METHOD_ACC_PUBLIC |
+      METHOD_ACC_FINAL |
+      METHOD_ACC_STATIC
+    ).asInstanceOf[U2])
+
+    val ch = m.codeHandler
+
+    val newMapping    = args.zipWithIndex.toMap
+
+    val exprToCompile = purescala.TreeOps.matchToIfThenElse(e)
+
+    mkExpr(e, ch)(env.withVars(newMapping))
+
+    e.getType match {
+      case Int32Type | BooleanType =>
+        ch << IRETURN
+
+      case UnitType | TupleType(_)  | SetType(_) | MapType(_, _) => 
+        ch << ARETURN
+
+      case other =>
+        throw CompilationException("Unsupported return type : " + other)
+    }
+
+    ch.freeze
+
+    loader.register(cf)
+
+    new CompiledExpression(this, cf, args)
+  }
+}
+
+object CompilationUnit {
+  def compileProgram(p: Program): Option[CompilationUnit] = {
+    implicit val env = CompilationEnvironment.fromProgram(p)
+
+    for((parent,children) <- p.algebraicDataTypes) {
+      val acf = compileAbstractClassDef(p, parent)
+      val ccfs = children.map(c => compileCaseClassDef(p, c))
+    } 
+
+    val mainClassName = defToJVMName(p, p.mainObject)
+    val cf = new ClassFile(mainClassName, None)
+    cf.addDefaultConstructor
+
+    cf.setFlags((
+      CLASS_ACC_SUPER |
+      CLASS_ACC_PUBLIC |
+      CLASS_ACC_FINAL
+    ).asInstanceOf[U2])
+
+    // This assumes that all functions of a given program get compiled
+    // as methods of a single class file.
+    for(funDef <- p.definedFunctions;
+        (_,mn,_) <- env.funDefToMethod(funDef)) {
+
+      val m = cf.addMethod(
+        typeToJVM(funDef.returnType),
+        mn,
+        funDef.args.map(a => typeToJVM(a.tpe)) : _*
+      )
+      m.setFlags((
+        METHOD_ACC_PUBLIC |
+        METHOD_ACC_FINAL |
+        METHOD_ACC_STATIC
+      ).asInstanceOf[U2])
+ 
+      compileFunDef(funDef, m.codeHandler)
+    }
+
+    Some(new CompilationUnit(p, cf, env))
+  }
+}

src/main/scala/leon/codegen/CompiledExpression.scala

+package leon
+package codegen
+
+import purescala.Common._
+import purescala.Definitions._
+import purescala.Trees._
+import purescala.TypeTrees._
+
+import cafebabe._
+import cafebabe.AbstractByteCodes._
+import cafebabe.ByteCodes._
+import cafebabe.ClassFileTypes._
+import cafebabe.Flags._
+
+class CompiledExpression(unit: CompilationUnit, cf: ClassFile, argsDecl: Seq[Identifier]) {
+
+  def eval(args: Seq[Expr]): Expr = {
+    val cl = unit.loader.loadClass(cf.className)
+    val obj = cl.newInstance()
+    val meth = cl.getMethods()(0)
+
+    val res = meth.invoke(obj, args.map(unit.groundExprToJava))
+
+    unit.javaToGroundExpr(res)
+  }
+
+}