--- /dev/null
+/*
+ * Copyright (C) 2014, United States Government, as represented by the
+ * Administrator of the National Aeronautics and Space Administration.
+ * All rights reserved.
+ *
+ * The Java Pathfinder core (jpf-core) platform is licensed under the
+ * Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package gov.nasa.jpf.vm;
+
+import gov.nasa.jpf.Config;
+import gov.nasa.jpf.annotation.MJI;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Set;
+
+
+/**
+ * MJI NativePeer class for java.lang.Class library abstraction
+ */
+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";
+
+ public static boolean init (Config conf){
+ // we create Method and Constructor objects, so we better make sure these
+ // classes are initialized (they already might be)
+ JPF_java_lang_reflect_Method.init(conf);
+ JPF_java_lang_reflect_Constructor.init(conf);
+ return true;
+ }
+
+ @MJI
+ public boolean isArray____Z (MJIEnv env, int robj) {
+ ClassInfo ci = env.getReferredClassInfo( robj);
+ return ci.isArray();
+ }
+
+ @MJI
+ public int getComponentType____Ljava_lang_Class_2 (MJIEnv env, int robj) {
+ if (isArray____Z(env, robj)) {
+ ThreadInfo ti = env.getThreadInfo();
+ Instruction insn = ti.getPC();
+ ClassInfo ci = env.getReferredClassInfo( robj).getComponentClassInfo();
+
+ if (ci.initializeClass(ti)){
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ return ci.getClassObjectRef();
+ }
+
+ return MJIEnv.NULL;
+ }
+
+ @MJI
+ public boolean isInstance__Ljava_lang_Object_2__Z (MJIEnv env, int robj,
+ int r1) {
+ ElementInfo sei = env.getStaticElementInfo(robj);
+ ClassInfo ci = sei.getClassInfo();
+ ClassInfo ciOther = env.getClassInfo(r1);
+ return (ciOther.isInstanceOf(ci));
+ }
+
+ @MJI
+ public boolean isInterface____Z (MJIEnv env, int robj){
+ ClassInfo ci = env.getReferredClassInfo( robj);
+ return ci.isInterface();
+ }
+
+ @MJI
+ public boolean isAssignableFrom__Ljava_lang_Class_2__Z (MJIEnv env, int rcls,
+ int r1) {
+ ElementInfo sei1 = env.getStaticElementInfo(rcls);
+ ClassInfo ci1 = sei1.getClassInfo();
+
+ ElementInfo sei2 = env.getStaticElementInfo(r1);
+ ClassInfo ci2 = sei2.getClassInfo();
+
+ return ci2.isInstanceOf( ci1);
+ }
+
+ @MJI
+ public int getAnnotations_____3Ljava_lang_annotation_Annotation_2 (MJIEnv env, int robj){
+ ClassInfo ci = env.getReferredClassInfo( robj);
+ AnnotationInfo[] ai = ci.getAnnotations();
+
+ try {
+ return env.newAnnotationProxies(ai);
+ } catch (ClinitRequired x){
+ env.handleClinitRequest(x.getRequiredClassInfo());
+ return MJIEnv.NULL;
+ }
+ }
+
+ @MJI
+ public int getAnnotation__Ljava_lang_Class_2__Ljava_lang_annotation_Annotation_2 (MJIEnv env, int robj,
+ int annoClsRef){
+ ClassInfo ci = env.getReferredClassInfo( robj);
+ ClassInfo aci = env.getReferredClassInfo(annoClsRef);
+
+ AnnotationInfo ai = ci.getAnnotation(aci.getName());
+ if (ai != null){
+ ClassInfo aciProxy = aci.getAnnotationProxy();
+
+ try {
+ return env.newAnnotationProxy(aciProxy, ai);
+ } catch (ClinitRequired x){
+ env.handleClinitRequest(x.getRequiredClassInfo());
+ return MJIEnv.NULL;
+ }
+ } else {
+ return MJIEnv.NULL;
+ }
+ }
+
+ @MJI
+ public int getPrimitiveClass__Ljava_lang_String_2__Ljava_lang_Class_2 (MJIEnv env,
+ int rcls, int stringRef) {
+ // we don't really have to check for a valid class name here, since
+ // this is a package default method that just gets called from
+ // the clinit of box classes
+ // note this does NOT return the box class (e.g. java.lang.Integer), which
+ // is a normal, functional class, but a primitive class (e.g. 'int') that
+ // is rather a strange beast (not even Object derived)
+
+ ClassLoaderInfo scli = env.getSystemClassLoaderInfo(); // this is the one responsible for builtin classes
+ String primClsName = env.getStringObject(stringRef); // always initialized
+
+ ClassInfo ci = scli.getResolvedClassInfo(primClsName);
+ return ci.getClassObjectRef();
+ }
+
+ @MJI
+ public boolean desiredAssertionStatus____Z (MJIEnv env, int robj) {
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ return ci.desiredAssertionStatus();
+ }
+
+ public static int getClassObject (MJIEnv env, ClassInfo ci){
+ ThreadInfo ti = env.getThreadInfo();
+ Instruction insn = ti.getPC();
+
+ if (ci.initializeClass(ti)){
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ StaticElementInfo ei = ci.getStaticElementInfo();
+ int ref = ei.getClassObjectRef();
+
+ return ref;
+ }
+
+ @MJI
+ public int forName__Ljava_lang_String_2__Ljava_lang_Class_2 (MJIEnv env,
+ int rcls,
+ int clsNameRef) {
+ if (clsNameRef == MJIEnv.NULL){
+ env.throwException("java.lang.NullPointerException", "no class name provided");
+ return MJIEnv.NULL;
+ }
+
+ String clsName = env.getStringObject(clsNameRef);
+
+ if (clsName.isEmpty()){
+ env.throwException("java.lang.ClassNotFoundException", "empty class name");
+ return MJIEnv.NULL;
+ }
+
+ ThreadInfo ti = env.getThreadInfo();
+ MethodInfo mi = ti.getTopFrame().getPrevious().getMethodInfo();
+ // class of the method that includes the invocation of Class.forName()
+ ClassInfo cls = mi.getClassInfo();
+
+ String name;
+ // for array type, the component terminal must be resolved
+ if(clsName.charAt(0)=='[') {
+ name = Types.getComponentTerminal(clsName);
+ } else{
+ name = clsName;
+ }
+
+ // make the classloader of the class including the invocation of
+ // Class.forName() resolve the class with the given name
+ try {
+ cls.resolveReferencedClass(name);
+ } catch(LoadOnJPFRequired lre) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ // The class obtained here is the same as the resolved one, except
+ // if it represents an array type
+ ClassInfo ci = cls.getClassLoaderInfo().getResolvedClassInfo(clsName);
+
+ return getClassObject(env, ci);
+ }
+
+ /**
+ * this is an example of a native method issuing direct calls - otherwise known
+ * as a round trip.
+ * We don't have to deal with class init here anymore, since this is called
+ * via the class object of the class to instantiate
+ */
+ @MJI
+ public int newInstance____Ljava_lang_Object_2 (MJIEnv env, int robj) {
+ ThreadInfo ti = env.getThreadInfo();
+ DirectCallStackFrame frame = ti.getReturnedDirectCall();
+
+ ClassInfo ci = env.getReferredClassInfo(robj); // what are we
+ MethodInfo miCtor = ci.getMethod("<init>()V", true); // note there always is one since something needs to call Object()
+
+ if (frame == null){ // first time around
+ if(ci.isAbstract()){ // not allowed to instantiate
+ env.throwException("java.lang.InstantiationException");
+ return MJIEnv.NULL;
+ }
+
+ // <2do> - still need to handle protected
+ if (miCtor.isPrivate()) {
+ env.throwException("java.lang.IllegalAccessException", "cannot access non-public member of class " + ci.getName());
+ return MJIEnv.NULL;
+ }
+
+ int objRef = env.newObjectOfUncheckedClass(ci); // create the thing
+
+ frame = miCtor.createDirectCallStackFrame(ti, 1);
+ // note that we don't set this as a reflection call since it is supposed to propagate exceptions
+ frame.setReferenceArgument(0, objRef, null);
+ frame.setLocalReferenceVariable(0, objRef); // (1) store ref for retrieval during re-exec
+ ti.pushFrame(frame);
+
+ // check if we have to push clinits
+ ci.initializeClass(ti);
+
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+
+ } else { // re-execution
+ int objRef = frame.getLocalVariable(0); // that's the object ref we set in (1)
+ return objRef;
+ }
+ }
+
+ @MJI
+ public int getSuperclass____Ljava_lang_Class_2 (MJIEnv env, int robj) {
+ ClassInfo ci = env.getReferredClassInfo( robj);
+ ClassInfo sci = ci.getSuperClass();
+ if (sci != null) {
+ return sci.getClassObjectRef();
+ } else {
+ return MJIEnv.NULL;
+ }
+ }
+
+ int getMethod (MJIEnv env, int clsRef, ClassInfo ciMethod, String mname, int argTypesRef,
+ boolean isRecursiveLookup, boolean publicOnly) {
+
+ ClassInfo ci = env.getReferredClassInfo( clsRef);
+
+ StringBuilder sb = new StringBuilder(mname);
+ sb.append('(');
+ int nParams = argTypesRef != MJIEnv.NULL ? env.getArrayLength(argTypesRef) : 0;
+ for (int i=0; i<nParams; i++) {
+ int cRef = env.getReferenceArrayElement(argTypesRef, i);
+ ClassInfo cit = env.getReferredClassInfo( cRef);
+ String tname = cit.getName();
+ String tcode = tname;
+ tcode = Types.getTypeSignature(tcode, false);
+ sb.append(tcode);
+ }
+ sb.append(')');
+ String fullMthName = sb.toString();
+
+ MethodInfo mi = ci.getReflectionMethod(fullMthName, isRecursiveLookup);
+ if (mi == null || (publicOnly && !mi.isPublic())) {
+ env.throwException("java.lang.NoSuchMethodException", ci.getName() + '.' + fullMthName);
+ return MJIEnv.NULL;
+
+ } else {
+ return createMethodObject(env, ciMethod, mi);
+ }
+ }
+
+ int createMethodObject (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);
+ }
+ }
+
+ @MJI
+ public int getDeclaredMethod__Ljava_lang_String_2_3Ljava_lang_Class_2__Ljava_lang_reflect_Method_2 (MJIEnv env, int clsRef,
+ int nameRef, int argTypesRef) {
+ ClassInfo mci = getInitializedClassInfo(env, METHOD_CLASSNAME);
+ if (mci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ String mname = env.getStringObject(nameRef);
+ return getMethod(env, clsRef, mci, mname, argTypesRef, false, false);
+ }
+
+ @MJI
+ public int getDeclaredConstructor___3Ljava_lang_Class_2__Ljava_lang_reflect_Constructor_2 (MJIEnv env,
+ int clsRef,
+ int argTypesRef){
+ ClassInfo mci = getInitializedClassInfo(env, CONSTRUCTOR_CLASSNAME);
+ if (mci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ int ctorRef = getMethod(env,clsRef, mci, "<init>",argTypesRef,false, false);
+ return ctorRef;
+ }
+
+ @MJI
+ public int getMethod__Ljava_lang_String_2_3Ljava_lang_Class_2__Ljava_lang_reflect_Method_2 (MJIEnv env, int clsRef,
+ int nameRef, int argTypesRef) {
+ ClassInfo mci = getInitializedClassInfo(env, METHOD_CLASSNAME);
+ if (mci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ String mname = env.getStringObject(nameRef);
+ return getMethod( env, clsRef, mci, mname, argTypesRef, true, true);
+ }
+
+ private void addDeclaredMethodsRec (boolean includeSuperClasses, HashMap<String,MethodInfo>methods, ClassInfo ci){
+
+ if (includeSuperClasses){ // do NOT include Object methods for interfaces
+ ClassInfo sci = ci.getSuperClass();
+ if (sci != null){
+ addDeclaredMethodsRec( includeSuperClasses, methods,sci);
+ }
+ }
+
+ ClassLoaderInfo cl = ci.getClassLoaderInfo();
+ for (String ifcName : ci.getDirectInterfaceNames()){
+ ClassInfo ici = cl.getResolvedClassInfo(ifcName); // has to be already defined, so no exception
+ addDeclaredMethodsRec( includeSuperClasses, methods,ici);
+ }
+
+ for (MethodInfo mi : ci.getDeclaredMethodInfos()) {
+ // filter out non-public, <clinit> and <init>
+ if (mi.isPublic() && (mi.getName().charAt(0) != '<')) {
+ String mname = mi.getUniqueName();
+
+ if (!(ci.isInterface() && methods.containsKey(mname))){
+ methods.put(mname, mi);
+ }
+ }
+ }
+ }
+
+ @MJI
+ public int getMethods_____3Ljava_lang_reflect_Method_2 (MJIEnv env, int objref) {
+ ClassInfo mci = getInitializedClassInfo(env, METHOD_CLASSNAME);
+ if (mci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ ClassInfo ci = env.getReferredClassInfo(objref);
+
+ // collect all the public, non-ctor instance methods
+ if (!ci.isPrimitive()) {
+ HashMap<String,MethodInfo> methods = new HashMap<String,MethodInfo>();
+ addDeclaredMethodsRec( !ci.isInterface(), methods,ci);
+
+ int n = methods.size();
+ int aref = env.newObjectArray("Ljava/lang/reflect/Method;", n);
+ int i=0;
+
+ for (MethodInfo mi : methods.values()){
+ int mref = createMethodObject(env, mci, mi);
+ env.setReferenceArrayElement(aref,i++,mref);
+ }
+
+ return aref;
+
+ } else {
+ return env.newObjectArray("Ljava/lang/reflect/Method;", 0);
+ }
+ }
+
+ @MJI
+ public int getDeclaredMethods_____3Ljava_lang_reflect_Method_2 (MJIEnv env, int objref) {
+ ClassInfo mci = getInitializedClassInfo(env, METHOD_CLASSNAME);
+ if (mci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ ClassInfo ci = env.getReferredClassInfo(objref);
+ MethodInfo[] methodInfos = ci.getDeclaredMethodInfos();
+
+ // we have to filter out the ctors and the static init
+ int nMth = methodInfos.length;
+ for (int i=0; i<methodInfos.length; i++){
+ if (methodInfos[i].getName().charAt(0) == '<'){
+ methodInfos[i] = null;
+ nMth--;
+ }
+ }
+
+ int aref = env.newObjectArray("Ljava/lang/reflect/Method;", nMth);
+
+ for (int i=0, j=0; i<methodInfos.length; i++) {
+ if (methodInfos[i] != null){
+ int mref = createMethodObject(env, mci, methodInfos[i]);
+ env.setReferenceArrayElement(aref,j++,mref);
+ }
+ }
+
+ return aref;
+ }
+
+ int getConstructors (MJIEnv env, int objref, boolean publicOnly){
+ ClassInfo mci = getInitializedClassInfo(env, CONSTRUCTOR_CLASSNAME);
+ if (mci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ ClassInfo ci = env.getReferredClassInfo(objref);
+ ArrayList<MethodInfo> ctors = new ArrayList<MethodInfo>();
+
+ // we have to filter out the ctors and the static init
+ for (MethodInfo mi : ci.getDeclaredMethodInfos()){
+ if (mi.getName().equals("<init>")){
+ if (!publicOnly || mi.isPublic()) {
+ ctors.add(mi);
+ }
+ }
+ }
+
+ int nCtors = ctors.size();
+ int aref = env.newObjectArray("Ljava/lang/reflect/Constructor;", nCtors);
+
+ for (int i=0; i<nCtors; i++){
+ env.setReferenceArrayElement(aref, i, createMethodObject(env, mci, ctors.get(i)));
+ }
+
+ return aref;
+ }
+
+ @MJI
+ public int getConstructors_____3Ljava_lang_reflect_Constructor_2 (MJIEnv env, int objref){
+ return getConstructors(env, objref, true);
+ }
+
+ @MJI
+ public int getDeclaredConstructors_____3Ljava_lang_reflect_Constructor_2 (MJIEnv env, int objref){
+ return getConstructors(env, objref, false);
+ }
+
+ @MJI
+ public int getConstructor___3Ljava_lang_Class_2__Ljava_lang_reflect_Constructor_2 (MJIEnv env, int clsRef,
+ int argTypesRef){
+ ClassInfo mci = getInitializedClassInfo(env, CONSTRUCTOR_CLASSNAME);
+ if (mci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ // <2do> should only return a public ctor
+ return getMethod(env,clsRef, mci, "<init>",argTypesRef,false,true);
+ }
+
+ // this is only used for system classes such as java.lang.reflect.Method
+ ClassInfo getInitializedClassInfo (MJIEnv env, String clsName){
+ ThreadInfo ti = env.getThreadInfo();
+ Instruction insn = ti.getPC();
+ ClassInfo ci = ClassLoaderInfo.getSystemResolvedClassInfo( clsName);
+
+ if (ci.initializeClass(ti)){
+ return null;
+ } else {
+ return ci;
+ }
+ }
+
+ @MJI
+ public void initialize0____V (MJIEnv env, int clsObjRef){
+ ClassInfo ci = env.getReferredClassInfo( clsObjRef);
+ ci.initializeClass(ThreadInfo.currentThread);
+ }
+
+ Set<ClassInfo> getInitializedInterfaces (MJIEnv env, ClassInfo ci){
+ ThreadInfo ti = env.getThreadInfo();
+ Instruction insn = ti.getPC();
+
+ Set<ClassInfo> ifcs = ci.getAllInterfaceClassInfos();
+ for (ClassInfo ciIfc : ifcs){
+ if (ciIfc.initializeClass(ti)){
+ return null;
+ }
+ }
+
+ return ifcs;
+ }
+
+ static int createFieldObject (MJIEnv env, FieldInfo fi, ClassInfo fci){
+ int regIdx = JPF_java_lang_reflect_Field.registerFieldInfo(fi);
+
+ int eidx = env.newObject(fci);
+ ElementInfo ei = env.getModifiableElementInfo(eidx);
+ ei.setIntField("regIdx", regIdx);
+
+ return eidx;
+ }
+
+ @MJI
+ public int getDeclaredFields_____3Ljava_lang_reflect_Field_2 (MJIEnv env, int objRef) {
+ ClassInfo fci = getInitializedClassInfo(env, FIELD_CLASSNAME);
+ if (fci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ ClassInfo ci = env.getReferredClassInfo(objRef);
+ int nInstance = ci.getNumberOfDeclaredInstanceFields();
+ int nStatic = ci.getNumberOfStaticFields();
+ int aref = env.newObjectArray("Ljava/lang/reflect/Field;", nInstance + nStatic);
+ int i, j=0;
+
+ for (i=0; i<nStatic; i++) {
+ FieldInfo fi = ci.getStaticField(i);
+ env.setReferenceArrayElement(aref, j++, createFieldObject(env, fi, fci));
+ }
+
+ for (i=0; i<nInstance; i++) {
+ FieldInfo fi = ci.getDeclaredInstanceField(i);
+ env.setReferenceArrayElement(aref, j++, createFieldObject(env, fi, fci));
+ }
+
+ return aref;
+ }
+
+ @MJI
+ public int getFields_____3Ljava_lang_reflect_Field_2 (MJIEnv env, int clsRef){
+ ClassInfo fci = getInitializedClassInfo(env, FIELD_CLASSNAME);
+ if (fci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ ClassInfo ci = env.getReferredClassInfo(clsRef);
+ // interfaces might not be initialized yet, so we have to check first
+ Set<ClassInfo> ifcs = getInitializedInterfaces( env, ci);
+ if (ifcs == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ ArrayList<FieldInfo> fiList = new ArrayList<FieldInfo>();
+ for (; ci != null; ci = ci.getSuperClass()){
+ // the host VM returns them in order of declaration, but the spec says there is no guaranteed order so we keep it simple
+ for (FieldInfo fi : ci.getDeclaredInstanceFields()){
+ if (fi.isPublic()){
+ fiList.add(fi);
+ }
+ }
+ for (FieldInfo fi : ci.getDeclaredStaticFields()){
+ if (fi.isPublic()){
+ fiList.add(fi);
+ }
+ }
+ }
+
+ for (ClassInfo ciIfc : ifcs){
+ for (FieldInfo fi : ciIfc.getDeclaredStaticFields()){
+ fiList.add(fi); // there are no non-public fields in interfaces
+ }
+ }
+
+ int aref = env.newObjectArray("Ljava/lang/reflect/Field;", fiList.size());
+ int j=0;
+ for (FieldInfo fi : fiList){
+ env.setReferenceArrayElement(aref, j++, createFieldObject(env, fi, fci));
+ }
+
+ return aref;
+ }
+
+ int getField (MJIEnv env, int clsRef, int nameRef, boolean isRecursiveLookup) {
+ ClassInfo ci = env.getReferredClassInfo( clsRef);
+ String fname = env.getStringObject(nameRef);
+ FieldInfo fi = null;
+
+ if (isRecursiveLookup) {
+ fi = ci.getInstanceField(fname);
+ if (fi == null) {
+ fi = ci.getStaticField(fname);
+ }
+ } else {
+ fi = ci.getDeclaredInstanceField(fname);
+ if (fi == null) {
+ fi = ci.getDeclaredStaticField(fname);
+ }
+ }
+
+ if (fi == null) {
+ env.throwException("java.lang.NoSuchFieldException", fname);
+ return MJIEnv.NULL;
+
+ } else {
+ // don't do a Field clinit before we know there is such a field
+ ClassInfo fci = getInitializedClassInfo( env, FIELD_CLASSNAME);
+ if (fci == null) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+
+ return createFieldObject( env, fi, fci);
+ }
+ }
+
+ @MJI
+ public int getDeclaredField__Ljava_lang_String_2__Ljava_lang_reflect_Field_2 (MJIEnv env, int clsRef, int nameRef) {
+ return getField(env,clsRef,nameRef, false);
+ }
+
+ @MJI
+ public int getField__Ljava_lang_String_2__Ljava_lang_reflect_Field_2 (MJIEnv env, int clsRef, int nameRef) {
+ return getField(env,clsRef,nameRef, true);
+ }
+
+ @MJI
+ public int getModifiers____I (MJIEnv env, int clsRef){
+ ClassInfo ci = env.getReferredClassInfo(clsRef);
+ return ci.getModifiers();
+ }
+
+ @MJI
+ public int getEnumConstants_____3Ljava_lang_Object_2 (MJIEnv env, int clsRef){
+ ClassInfo ci = env.getReferredClassInfo(clsRef);
+
+ if (env.requiresClinitExecution(ci)){
+ env.repeatInvocation();
+ return 0;
+ }
+
+ if (ci.getSuperClass().getName().equals("java.lang.Enum")) {
+ ArrayList<FieldInfo> list = new ArrayList<FieldInfo>();
+ String cName = ci.getName();
+
+ for (FieldInfo fi : ci.getDeclaredStaticFields()) {
+ if (fi.isFinal() && cName.equals(fi.getType())){
+ list.add(fi);
+ }
+ }
+
+ int aRef = env.newObjectArray(cName, list.size());
+ StaticElementInfo sei = ci.getStaticElementInfo();
+ int i=0;
+ for (FieldInfo fi : list){
+ env.setReferenceArrayElement( aRef, i++, sei.getReferenceField(fi));
+ }
+ return aRef;
+ }
+
+ return MJIEnv.NULL;
+ }
+
+ @MJI
+ public int getInterfaces_____3Ljava_lang_Class_2 (MJIEnv env, int clsRef){
+ ClassInfo ci = env.getReferredClassInfo(clsRef);
+ int aref = MJIEnv.NULL;
+ ThreadInfo ti = env.getThreadInfo();
+
+ // contrary to the API doc, this only returns the interfaces directly
+ // implemented by this class, not it's bases
+ // <2do> this is not exactly correct, since the interfaces should be ordered
+ Set<ClassInfo> interfaces = ci.getInterfaceClassInfos();
+ aref = env.newObjectArray("Ljava/lang/Class;", interfaces.size());
+
+ int i=0;
+ for (ClassInfo ifc: interfaces){
+ env.setReferenceArrayElement(aref, i++, ifc.getClassObjectRef());
+ }
+
+ return aref;
+ }
+
+
+ /**
+ * <2do> needs to load from the classfile location, NOT the MJIEnv (native) class
+ *
+ * @author Sebastian Gfeller (sebastian.gfeller@gmail.com)
+ * @author Tihomir Gvero (tihomir.gvero@gmail.com)
+ */
+ @MJI
+ public int getByteArrayFromResourceStream__Ljava_lang_String_2___3B(MJIEnv env, int clsRef, int nameRef) {
+ String name = env.getStringObject(nameRef);
+
+ // <2do> this is not loading from the classfile location! fix it
+ InputStream is = env.getClass().getResourceAsStream(name);
+ if (is == null){
+ return MJIEnv.NULL;
+ }
+ // We assume that the entire input stream can be read at the moment,
+ // although this could break.
+ byte[] content = null;
+ try {
+ content = new byte[is.available()];
+ is.read(content);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ // Now if everything worked, the content should be in the byte buffer.
+ // We put this buffer into the JPF VM.
+ return env.newByteArray(content);
+ }
+
+ @MJI
+ public int getEnclosingClass____Ljava_lang_Class_2 (MJIEnv env, int clsRef) {
+ ClassInfo ciEncl = env.getReferredClassInfo( clsRef).getEnclosingClassInfo();
+
+ if (ciEncl == null){
+ return MJIEnv.NULL;
+ }
+
+ if (ciEncl.initializeClass(env.getThreadInfo())) {
+ env.repeatInvocation();
+ return 0;
+ }
+
+ return ciEncl.getClassObjectRef();
+ }
+
+ @MJI
+ public int getDeclaredClasses_____3Ljava_lang_Class_2 (MJIEnv env, int clsRef){
+ ClassInfo ci = env.getReferredClassInfo(clsRef);
+ String[] innerClassNames = ci.getInnerClasses();
+ int aref = MJIEnv.NULL;
+ ThreadInfo ti = env.getThreadInfo();
+
+ MethodInfo mi = ti.getTopFrame().getPrevious().getMethodInfo();
+ // class of the method that includes the invocation of Class.getDeclaredClasses
+ ClassInfo cls = mi.getClassInfo();
+
+ // first resolve all the inner classes
+ int length = innerClassNames.length;
+ ClassInfo[] resolvedInnerClass = new ClassInfo[length];
+ for(int i=0; i<length; i++) {
+ try {
+ resolvedInnerClass[i] = cls.resolveReferencedClass(innerClassNames[i]);
+ } catch(LoadOnJPFRequired lre) {
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+ }
+
+ aref = env.newObjectArray("Ljava/lang/Class;", innerClassNames.length);
+ for (int i=0; i<length; i++){
+ ClassInfo ici = resolvedInnerClass[i];
+ if (!ici.isRegistered()) {
+ ici.registerClass(ti);
+ }
+ env.setReferenceArrayElement(aref, i, ici.getClassObjectRef());
+ }
+
+ return aref;
+ }
+
+ private String getCanonicalName (ClassInfo ci){
+ if (ci.isArray()){
+ String canonicalName = getCanonicalName(ci.getComponentClassInfo());
+ if (canonicalName != null){
+ return canonicalName + "[]";
+ } else{
+ return null;
+ }
+ }
+ if (isLocalOrAnonymousClass(ci)) {
+ return null;
+ }
+ if (ci.getEnclosingClassInfo() == null){
+ return ci.getName();
+ } else{
+ String enclosingName = getCanonicalName(ci.getEnclosingClassInfo());
+ if (enclosingName == null){ return null; }
+ return enclosingName + "." + ci.getSimpleName();
+ }
+ }
+
+ @MJI
+ public int getCanonicalName____Ljava_lang_String_2 (MJIEnv env, int clsRef){
+ ClassInfo ci = env.getReferredClassInfo(clsRef);
+ return env.newString(getCanonicalName(ci));
+ }
+
+ @MJI
+ public boolean isAnnotation____Z (MJIEnv env, int clsObjRef){
+ ClassInfo ci = env.getReferredClassInfo(clsObjRef);
+ return (ci.getModifiers() & 0x2000) != 0;
+ }
+
+ @MJI
+ public boolean isAnnotationPresent__Ljava_lang_Class_2__Z (MJIEnv env, int clsObjRef, int annoClsObjRef){
+ ClassInfo ci = env.getReferredClassInfo(clsObjRef);
+ ClassInfo ciAnno = env.getReferredClassInfo(annoClsObjRef);
+
+ return ci.getAnnotation( ciAnno.getName()) != null;
+ }
+
+ @MJI
+ public int getDeclaredAnnotations_____3Ljava_lang_annotation_Annotation_2 (MJIEnv env, int robj){
+ ClassInfo ci = env.getReferredClassInfo(robj);
+
+ try{
+ return env.newAnnotationProxies(ci.getDeclaredAnnotations());
+ } catch (ClinitRequired x){
+ env.handleClinitRequest(x.getRequiredClassInfo());
+ return MJIEnv.NULL;
+ }
+ }
+
+ @MJI
+ public int getEnclosingConstructor____Ljava_lang_reflect_Constructor_2 (MJIEnv env, int robj){
+ ClassInfo mci = getInitializedClassInfo(env, CONSTRUCTOR_CLASSNAME);
+ if (mci == null){
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ MethodInfo enclosingMethod = ci.getEnclosingMethodInfo();
+
+ if ((enclosingMethod != null) && enclosingMethod.isCtor()){
+ return createMethodObject(env, mci, enclosingMethod);
+ }
+ return MJIEnv.NULL;
+ }
+
+ @MJI
+ public int getEnclosingMethod____Ljava_lang_reflect_Method_2 (MJIEnv env, int robj){
+ ClassInfo mci = getInitializedClassInfo(env, METHOD_CLASSNAME);
+ if (mci == null){
+ env.repeatInvocation();
+ return MJIEnv.NULL;
+ }
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ MethodInfo enclosingMethod = ci.getEnclosingMethodInfo();
+
+ if ((enclosingMethod != null) && !enclosingMethod.isCtor()){
+ return createMethodObject(env, mci, enclosingMethod);
+ }
+ return MJIEnv.NULL;
+ }
+
+ @MJI
+ public boolean isAnonymousClass____Z (MJIEnv env, int robj){
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ String cname = null;
+ if (ci.getName().contains("$")){
+ cname = ci.getName().substring(ci.getName().lastIndexOf('$') + 1);
+ }
+ return (cname == null) ? false : cname.matches("\\d+?");
+ }
+
+ @MJI
+ public boolean isEnum____Z (MJIEnv env, int robj){
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ return ci.isEnum();
+ }
+
+ // Similar to getEnclosingClass() except it returns null for the case of
+ // anonymous class.
+ @MJI
+ public int getDeclaringClass____Ljava_lang_Class_2 (MJIEnv env, int clsRef){
+ ClassInfo ci = env.getReferredClassInfo(clsRef);
+ if (isLocalOrAnonymousClass(ci)){
+ return MJIEnv.NULL;
+ } else{
+ return getEnclosingClass____Ljava_lang_Class_2(env, clsRef);
+ }
+ }
+
+ @MJI
+ public boolean isLocalClass____Z (MJIEnv env, int robj){
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ return isLocalOrAnonymousClass(ci) && !isAnonymousClass____Z(env, robj);
+ }
+
+ private boolean isLocalOrAnonymousClass (ClassInfo ci){
+ return (ci.getEnclosingMethodInfo() != null);
+ }
+
+ @MJI
+ public boolean isMemberClass____Z (MJIEnv env, int robj){
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ return (ci.getEnclosingClassInfo() != null) && !isLocalOrAnonymousClass(ci);
+ }
+
+ /**
+ * Append the package name prefix of the class represented by robj, if the name is not
+ * absolute. OW, remove leading "/".
+ */
+ @MJI
+ public int getResolvedName__Ljava_lang_String_2__Ljava_lang_String_2 (MJIEnv env, int robj, int resRef){
+ String rname = env.getStringObject(resRef);
+ ClassInfo ci = env.getReferredClassInfo(robj);
+ if (rname == null) {
+ return MJIEnv.NULL;
+ }
+ if (!rname.startsWith("/")) {
+ ClassInfo c = ci;
+ while (c.isArray()) {
+ c = c.getComponentClassInfo();
+ }
+ String baseName = c.getName();
+ int index = baseName.lastIndexOf('.');
+ if (index != -1) {
+ rname = baseName.substring(0, index).replace('.', '/')
+ +"/"+rname;
+ }
+ } else {
+ rname = rname.substring(1);
+ }
+
+ return env.newString(rname);
+ }
+}
projects / jpf-core.git / blobdiff