Starting our own version of JPF with support for generics.

[jpf-core.git] / src / peers / gov / nasa / jpf / vm / JPF_java_lang_Class.java

diff --git a/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java b/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java
index c76ecb8d139cc5281bfd54752d59f527202b5c46..651e48b248fae9fc3583a597e753f145d1857a1e 100644 (file)
--- a/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java
+++ b/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java
@@ -26,6 +26,12 @@ import java.util.Set;
 import gov.nasa.jpf.Config;
 import gov.nasa.jpf.annotation.MJI;
 
+// TODO: DIRTY HACKS!
+import java.lang.reflect.TypeVariable;
+import sun.reflect.generics.factory.CoreReflectionFactory;
+import sun.reflect.generics.factory.GenericsFactory;
+import sun.reflect.generics.repository.ClassRepository;
+import sun.reflect.generics.scope.ClassScope;
 
 /**
  * MJI NativePeer class for java.lang.Class library abstraction
@@ -35,6 +41,8 @@ public class JPF_java_lang_Class extends NativePeer {
   static final String FIELD_CLASSNAME = "java.lang.reflect.Field";
   static final String METHOD_CLASSNAME = "java.lang.reflect.Method";
   static final String CONSTRUCTOR_CLASSNAME = "java.lang.reflect.Constructor";
+  // TODO: DIRTY HACKS!
+  static final String TYPEVARIABLE_CLASSNAME = "java.lang.reflect.TypeVariable";
   
   public static boolean init (Config conf){
     // we create Method and Constructor objects, so we better make sure these
@@ -146,6 +154,48 @@ public class JPF_java_lang_Class extends NativePeer {
     return ci.getClassObjectRef();
   }
 
+  // TODO: DIRTY HACKS!
+  /*int createTypeVariableObject (MJIEnv env, ClassInfo objectCi, MethodInfo mi) {
+    // NOTE - we rely on Constructor and Method peers being initialized
+    if (mi.isCtor()){
+      return JPF_java_lang_reflect_Constructor.createConstructorObject(env, objectCi, mi);
+    } else {
+      return JPF_java_lang_reflect_Method.createMethodObject(env, objectCi, mi);
+    }
+  }
+
+  // accessor for factory
+  private GenericsFactory getFactory() {
+    // create scope and factory
+    return CoreReflectionFactory.make(this, ClassScope.make(this));
+  }
+
+  @MJI
+  public int getTypeParameters_____3Ljava_lang_reflect_TypeVariable_2 (MJIEnv env, int objRef){
+    ClassInfo tci = getInitializedClassInfo(env, TYPEVARIABLE_CLASSNAME);
+    if (tci == null) {
+      env.repeatInvocation();
+      return MJIEnv.NULL;
+    }
+    // Get the object and the type parameters
+    ClassInfo ci = env.getReferredClassInfo(objRef);
+    String signature = ci.getType();
+    ClassRepository genericInfo = ClassRepository.make(signature, getFactory());
+    TypeVariable[] typeVariables = (TypeVariable[]) genericInfo.getTypeParameters();
+
+    int aref = env.newObjectArray("Ljava/lang/reflect/TypeVariable;", typeVariables.length);
+
+    for(int i=0, j=0; i<typeVariables.length; i++){
+      if (typeVariables[i] != null) {
+        int mref = env.newObject(ci);
+        env.setReferenceArrayElement(aref,j++,mref);
+      }
+    }
+
+    return aref;
+  }*/
+  // TODO: DIRTY HACKS!
+
   @MJI
   public boolean desiredAssertionStatus____Z (MJIEnv env, int robj) {
     ClassInfo ci = env.getReferredClassInfo(robj);