Stuff works

project/Build.scala

@@ -22,7 +22,7 @@ object Build extends sbt.Build{
       ),
       libraryDependencies ++= Seq(
         "org.ow2.asm" % "asm-debug-all" % "4.1",
-        "org.scalatest" % "scalatest_2.10" % "2.0.M5b" % "test",
+        "org.scalatest" % "scalatest_2.10" % "2.0" % "test",
         "org.mozilla" % "rhino" % "1.7R4",
         "com.nativelibs4java" % "scalaxy-loops_2.10" % "0.3-SNAPSHOT" % "provided"
       )

src/main/scala/metascala/Main.scala

@@ -0,0 +1,10 @@
+package metascala
+
+/**
+ * Created by haoyi on 12/1/13.
+ */
+object Main {
+  def main(args: Array[String]): Unit = {
+
+  }
+}

src/main/scala/metascala/VM.scala

@@ -19,6 +19,7 @@ import org.objectweb.asm.tree.ClassNode
  * its bytecode operations
  */
 class VM(val natives: Bindings = Bindings.default,
+         val insnLimit: Long = Long.MaxValue,
          val log: ((=>String) => Unit) = s => (),
          val memorySize: Int = 1 * 1024 * 1024) {
 

src/main/scala/metascala/natives/Default.scala

@@ -38,11 +38,15 @@ trait Default extends Bindings{
                 val nameString = name.toRealObj[String]
                 val tpe = imm.Type.readJava(nameString)
                 try{
-                  vm.ClsTable(tpe.cast[imm.Type.Cls])
-                  vt.vm.typeObjCache(tpe)()
+                  if (!nameString.contains("["))vm.ClsTable(tpe.cast[imm.Type.Cls])
+                  val x = vt.vm.typeObjCache(tpe)()
+                  println("Success! " + x + " " + nameString)
+                  println("view " + vm.heap.memory.drop(x).take(20).toList)
+                  println("Name! " + x.obj.apply("name").toRealObj[String])
+                  x
                 } catch{case e: Exception =>
-                  vt.throwExWithTrace("java/lang/ClassNotFoundException", nameString)
-                  0
+                  println("Error! " + nameString)
+                  throw new java.lang.ClassNotFoundException(nameString)
                 }
 
             },
@@ -58,6 +62,7 @@ trait Default extends Bindings{
             "getDeclaredFields0(Z)[Ljava/lang/reflect/Field;".func(I, I, I){ (vt, o, public) =>
               import vt.vm
 
+
               val obj = o.obj
 
               val name = obj("name").toRealObj[String]
@@ -80,13 +85,18 @@ trait Default extends Bindings{
               // if (f.static) cls.staticList else cls.fieldList).indexOf(f)
               // f.static(cls.staticList, cls.fieldList).indexOf(f)
             },
-            "getDeclaredConstructors0(Z)[Ljava/lang/reflect/Constructor;".func(I, I, I){ (vt, bool, o) =>
+            "getDeclaredConstructors0(Z)[Ljava/lang/reflect/Constructor;".func(I, I, I){ (vt, o, bool) =>
               import vt.vm
-
+              println("A " + o)
+              println("view " + vm.heap.memory.drop(o).take(20).toList)
               val clsObj = o.obj
-              val clsName = clsObj("name").toRealObj[String]
+              println("B " + clsObj.view)
+              val clsName = clsObj("name").toRealObj[String].toSlash
+              println("C")
               val cls = vm.ClsTable(clsName)
+              println("D")
               val realMethods = cls.methods.filter(_.sig.name == "<init>")
+              println("E")
               val vrtArr = vm.alloc(implicit r =>
                 "java/lang/reflect/Constructor".allocArr(
                   realMethods.zipWithIndex.map{ case (f, i) =>
@@ -131,6 +141,12 @@ trait Default extends Bindings{
                 )
               )()
             },
+            "getModifiers()I".func(I, I){ (vt, o) =>
+              import vt.vm
+              val topClsName = o.obj.apply("name").toRealObj[String].toSlash
+
+              vm.ClsTable(topClsName).accessFlags
+            },
             "getPrimitiveClass(Ljava/lang/String;)Ljava/lang/Class;".func(I, I){ (vt, o) =>
               import vt.vm
               vt.vm.typeObjCache(imm.Type.readJava(o.toRealObj[String]))()
@@ -306,6 +322,16 @@ trait Default extends Bindings{
                   Seq(arr, index, obj)
                 )
               }
+            ),
+            "NativeConstructorAccessorImpl"/(
+              "newInstance0(Ljava/lang/reflect/Constructor;[Ljava/lang/Object;)Ljava/lang/Object;".func(I, I, I){
+                (vt, cons, args) =>
+                  import vt.vm
+                  val name = cons.obj.apply("clazz").obj.apply("name").toRealObj[String].toSlash
+                  vm.alloc(implicit r =>
+                    rt.Obj.allocate(name)
+                  ).address()
+              }
             )
           )
         ),
@@ -449,6 +475,10 @@ trait Default extends Bindings{
               import vt.vm
               o.obj.members(offset.toInt)
             },
+            "getIntVolatile(Ljava/lang/Object;J)I".func(I, I, J, I){ (vt, unsafe, o, offset) =>
+              import vt.vm
+              o.obj.members(offset.toInt)
+            },
             "putInt(Ljava/lang/Object;JI)V".func(I, I, J, I, V){ (vt, unsafe, o, offset, int) =>
               import vt.vm
               I.write(int, o.obj.members(offset.toInt) = _)
@@ -536,6 +566,15 @@ trait Default extends Bindings{
                 vt.vm.typeObjCache(imm.Type.readJava(name))()
               }
             },
+            "getCallerClass()Ljava/lang/Class;".func(I){ (vt) =>
+              import vt.vm
+              val n = 1
+              if (n >= vt.threadStack.length) 0
+              else {
+                val name = vt.threadStack(n).runningClass.name
+                vt.vm.typeObjCache(imm.Type.readJava(name))()
+              }
+            },
             "getClassAccessFlags(Ljava/lang/Class;)I".func(I, I){ (vt, o) =>
               import vt.vm
               val addr = o.obj.apply("name")

src/main/scala/metascala/opcodes/Conversion.scala

@@ -295,16 +295,15 @@ object Conversion {
       BasicBlock(buffer, phis, types, lines)
     }
 
-    if (false && method.name == "ensureObj") {
+    if (false) {
+
       for ((block, i) <- basicBlocks.zipWithIndex){
         println("")
         println(i + "\t" + block.phi.toList)
-        //println(i + "\t" + block.locals.toList)
-        println (""+blockBuffers(i)._3)
+        println ("" + blockBuffers(i)._3)
         for(i <- 0 until block.insns.length){
           println(block.lines(i) + "\t" + block.insns(i))
         }
-
       }
       println("")
       println("")

src/main/scala/metascala/rt/Thread.scala

@@ -62,16 +62,16 @@ class Thread(val threadStack: mutable.ArrayStack[Frame] = mutable.ArrayStack())(
 
     val r = reader(frame.locals, 0)
 
-//    if (!threadStack.exists(_.method.sig.name == "<clinit>")) {
-//      lazy val localSnapshot =
-//        block.locals
-//             .flatMap(x => Seq(x.prettyRead(r)).padTo(x.size, "~"))
-//             .toList
-//
-////      println(indent + "::\t" + frame.runningClass.shortName + "/" + frame.method.sig.shortName + ":" + block.lines(frame.pc._2) + "\t"  + localSnapshot)
-////      println(indent + "::\t" + frame.pc + "\t" + node )
-//      //println(indent + "::\t" + vm.heap.dump().replace("\n", "\n" + indent + "::\t"))
-//    }
+    if (!threadStack.exists(x => x.method.sig.name == "<clinit>" && x.runningClass.name.contains("java/"))) {
+      lazy val localSnapshot =
+        block.locals
+             .flatMap(x => Seq(x.prettyRead(r)).padTo(x.size, "~"))
+             .toList
+
+//      println(indent + "::\t" + frame.runningClass.shortName + "/" + frame.method.sig.shortName + ":" + block.lines(frame.pc._2) + "\t"  + localSnapshot)
+//      println(indent + "::\t" + frame.pc + "\t" + node )
+//      println(indent + "::\t" + vm.heap.dump().replace("\n", "\n" + indent + "::\t"))
+    }
 
 
     val currentFrame = frame
@@ -293,6 +293,9 @@ class Thread(val threadStack: mutable.ArrayStack[Frame] = mutable.ArrayStack())(
 
 
     opCount += 1
+    if (opCount > vm.insnLimit){
+      throw new Exception("Ran out of instructions! Limit: " + vm.insnLimit)
+    }
 
   }catch{case e: Throwable if !e.isInstanceOf[WrappedVmException] =>
     val newEx = new InternalVmException(e)
@@ -333,7 +336,7 @@ class Thread(val threadStack: mutable.ArrayStack[Frame] = mutable.ArrayStack())(
 
   @tailrec final def throwException(ex: Obj, print: Boolean = true): Unit = {
     import math.Ordering.Implicits._
-
+    println("Throwing!")
     threadStack.headOption match{
       case Some(frame)=>
         val handler =
@@ -367,7 +370,10 @@ class Thread(val threadStack: mutable.ArrayStack[Frame] = mutable.ArrayStack())(
 
     mRef match{
       case rt.Method.Native(clsName, imm.Sig(name, desc), op) =>
-        op(this, reader(args, 0), returnTo)
+        try op(this, reader(args, 0), returnTo)
+        catch{case e: Exception =>
+          throwExWithTrace(e.getClass.getName.toSlash, e.getMessage)
+        }
       case m @ rt.Method.Cls(clsIndex, methodIndex, sig, static, codethunk) =>
 
         assert(!m.native, "method cannot be native: " + ClsTable.clsIndex(clsIndex).name + " " + sig.unparse)

src/test/scala/metascala/full/JavaLibTest.scala

@@ -9,9 +9,10 @@ import scalaxy.loops._
 import java.math.BigInteger
 import java.util.regex.{Matcher, Pattern}
 import java.util.concurrent.atomic.{AtomicLong, AtomicInteger, AtomicBoolean}
-import org.mozilla.javascript.Context
+import org.mozilla.javascript.{VMBridge, Kit, Context}
 import java.util.concurrent.{ConcurrentLinkedQueue, ConcurrentHashMap}
 import java.util.concurrent.locks.ReentrantLock
+import org.mozilla.javascript.jdk15.VMBridge_jdk15
 
 
 class JavaLibTest extends FreeSpec {
@@ -138,14 +139,15 @@ class JavaLibTest extends FreeSpec {
       val map = new ConcurrentHashMap[Int, Int]()
       map.put(123, 456)
     }
-    "rhino" in tester.test{
-      val cx = Context.enter()
-      val scope = cx.initStandardObjects()
-      val script = "var s = 'omg'"
-      val obj = cx.evaluateString(scope, script, "Test Script", 1, null)
-      println(obj)
-      1
-    }
+//    "rhino" in tester.test{
+//      classOf[VMBridge_jdk15].newInstance()
+//      /*val cx = Context.enter()
+//      val scope = cx.initStandardObjects()
+//      val script = "var s = 'omg'"
+//      val obj = cx.evaluateString(scope, script, "Test Script", 1, null)
+//      println(obj)
+//      1*/
+//    }
   }
 
 }