/**
* Returns a non-array JVM object corresponding to the given non-array JPF object. If such an
* object already exists, it is returned. Otherwise a new one is created.
*/
protected Object getJVMNonArrObj(int JPFRef, MJIEnv env, FeatureExpr ctx)
throws ConversionException {
Object JVMObj = null;
if (JPFRef != MJIEnv.NULL) {
// First check if the object has been already created
JVMObj = ConverterBase.objMapJPF2JVM.get(JPFRef);
/**
* If the object has not been created & the given JPF object is not NULL, the corresponding
* JVM object is created from JPFRef
*/
if (JVMObj == null) {
// Used to store instance fields
DynamicElementInfo dei = (DynamicElementInfo) env.getHeap().get(JPFRef);
ClassInfo JPFCl = dei.getClassInfo();
if (!JPFCl.isRegistered()) {
JPFCl.registerClass(ctx, env.getThreadInfo());
}
// we treat Strings differently
if (JPFCl.isStringClassInfo()) {
JVMObj = createStringObject(JPFRef, env, ctx);
} else {
int JPFClsRef = JPFCl.getStaticElementInfo().getClassObjectRef();
Class<?> JVMCl = this.getJVMCls(JPFClsRef, env, ctx);
// There is only one instance of every class. There is no need to update
// Class objects
if (JVMCl == Class.class) {
try {
String name = env.getReferredClassInfo(ctx, JPFRef).getName();
if (Utilities.isPrimitiveClass(name)) {
JVMObj = Utilities.getPrimitiveClass(name);
} else {
JVMObj = loadClass(name, env, ctx);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return JVMObj;
} else {
// Creates a new instance of JVMCl
JVMObj = instantiateFrom(JVMCl);
}
ConverterBase.objMapJPF2JVM.put(JPFRef, JVMObj);
setInstanceFields(JVMObj, dei, env, ctx);
}
} else {
// Need to update the JVM object fields
DynamicElementInfo dei = (DynamicElementInfo) env.getHeap().get(JPFRef);
updateInstanceFields(JVMObj, dei, env, ctx);
}
}
return JVMObj;
}
/**
* Returns a JVM object corresponding to the given JPF object. If such an object already exists,
* it is returned. Otherwise a new one is created.
*/
protected Object getJVMObj(int JPFRef, MJIEnv env, FeatureExpr ctx) throws ConversionException {
if (env.isArray(JPFRef)) {
return this.getJVMArrObj(JPFRef, env, ctx);
} else {
return this.getJVMNonArrObj(JPFRef, env, ctx);
}
}
/**
* Returns a new JVM Class object corresponding to the given JPF class. If such a Class object
* already exists, it is returned. Otherwise a new one is created.
*/
protected Class<?> getJVMCls(int JPFRef, MJIEnv env, FeatureExpr ctx) throws ConversionException {
Class<?> JVMCls = null;
if (JPFRef != MJIEnv.NULL) {
// First check if the class object has been already created.
JVMCls = ConverterBase.classMapJPF2JVM.get(JPFRef);
/**
* If the Class object has not been created & the given JPF class is not NULL, the
* corresponding JVM class object is created from JPFRef
*/
if (JVMCls == null) {
ClassInfo ci = env.getReferredClassInfo(ctx, JPFRef);
// Used to store static fields
StaticElementInfo sei = ci.getStaticElementInfo();
try {
JVMCls = loadClass(sei.getClassInfo().getName(), env, ctx);
ConverterBase.classMapJPF2JVM.put(JPFRef, JVMCls);
} catch (ClassNotFoundException e) {
throw new NoClassDefFoundError(sei.getClassInfo().getName());
}
assert (JVMCls.getName() != ci.getName());
setStaticFields(JVMCls, sei, env, ctx);
}
}
return JVMCls;
}
protected Class<?> loadClass(String cname, MJIEnv env, FeatureExpr ctx)
throws ClassNotFoundException {
if (Utilities.isArray(cname)) {
return Class.forName(cname);
} else {
ClassLoader cl = env.getConfig().getClassLoader();
return cl.loadClass(cname);
}
}
public static Class<?> obtainJVMCls(int JPFRef, MJIEnv env, FeatureExpr ctx)
throws ConversionException {
if (JPFRef == MJIEnv.NULL) {
return null;
}
ClassInfo ci = env.getReferredClassInfo(ctx, JPFRef);
JPF2JVMConverter converter = ConverterBase.converterFactory.getJPF2JVMConverter(ci.getName());
return converter.getJVMCls(JPFRef, env, ctx);
}
@MJI
public void $init(MJIEnv env, int objref, FeatureExpr ctx) {
ThreadInfo ti = env.getThreadInfo();
StackFrame caller = ti.getCallerStackFrame();
Instruction insn = caller.getPC().getValue();
InsnExecCount a = insn.getAttr(InsnExecCount.class);
if (a == null) {
a = new InsnExecCount();
insn.addAttr(a);
}
SystemState ss = env.getSystemState();
if (!ss.hasRestorer(a)) {
env.getSystemState().putRestorer(a, new InsnCountRestorer(a));
}
a.count++;
env.setIntField(ctx, objref, "id", new One<>(a.count));
}
public static Object obtainJVMObj(int JPFRef, MJIEnv env, FeatureExpr ctx)
throws ConversionException {
if (JPFRef == MJIEnv.NULL) {
return null;
}
DynamicElementInfo dei = (DynamicElementInfo) env.getHeap().get(JPFRef);
ClassInfo ci = dei.getClassInfo();
JPF2JVMConverter converter = ConverterBase.converterFactory.getJPF2JVMConverter(ci.getName());
return converter.getJVMObj(JPFRef, env, ctx);
}
/**
* Returns a JVM array corresponding to the given JPF array. If such an array already exists, it
* is returned. Otherwise a new one is created.
*
* @param JPFRef an integer representing a JPF array
* @return a JVM array corresponding to the given JPF array, JPFRef
* @throws ConversionException if any incorrect input parameter is observed
*/
protected Object getJVMArrObj(int JPFRef, MJIEnv env, FeatureExpr ctx)
throws ConversionException {
Object JVMArr = null;
if (JPFRef != MJIEnv.NULL) {
// First check if the array has been already created
JVMArr = ConverterBase.objMapJPF2JVM.get(JPFRef);
/**
* If the array has not been created & the given JPF array is not NULL, the corresponding JVM
* array is created from JPFRef
*/
if (JVMArr == null) {
// Used to store array elements
DynamicElementInfo dei = (DynamicElementInfo) env.getHeap().get(JPFRef);
// Array of primitive type
if (dei.getClassInfo().getComponentClassInfo().isPrimitive()) {
JVMArr = Utilities.createJVMPrimitiveArr(dei);
}
// Array of Non-primitives
else {
// int[] JPFArr = ((ReferenceArrayFields) dei.getFields()).asReferenceArray();
Conditional<Integer>[] JPFArrConditional =
((ReferenceArrayFields) dei.getFields()).asReferenceArray();
int[] JPFArr = new int[JPFArrConditional.length];
for (int i = 0; i < JPFArrConditional.length; i++) {
JPFArr[i] = JPFArrConditional[i].getValue();
}
int arrSize = JPFArr.length;
Class<?> compType = null;
try {
compType = loadClass(dei.getClassInfo().getComponentClassInfo().getName(), env, ctx);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Object[] arrObj = (Object[]) Array.newInstance(compType, arrSize);
for (int i = 0; i < arrSize; i++) {
arrObj[i] = obtainJVMObj(JPFArr[i], env, ctx);
}
JVMArr = arrObj;
}
ConverterBase.objMapJPF2JVM.put(JPFRef, JVMArr);
}
}
return JVMArr;
}
protected Object createStringObject(int JPFRef, MJIEnv env, FeatureExpr ctx)
throws ConversionException {
DynamicElementInfo str = (DynamicElementInfo) env.getHeap().get(JPFRef);
if (!str.getClassInfo().isStringClassInfo()) {
throw new ConversionException();
}
FieldInfo fi = str.getFieldInfo("value");
int fieldValueRef = str.getFields().getReferenceValue(fi.getStorageOffset()).getValue();
// this is String.value which is of type of char[]
Object value = this.getJVMObj(fieldValueRef, env, ctx);
// In case that value is of the type One
Object JVMObj;
if (value instanceof Conditional)
JVMObj = new String((char[]) ((Conditional<?>) value).simplify(ctx).getValue());
else {
System.out.println("Warning from JPF2JVMConverter.java L244, JVMObj is not One");
JVMObj = new String((char[]) value);
}
ConverterBase.objMapJPF2JVM.put(JPFRef, JVMObj);
return JVMObj;
}