| //===- ClasspathReflect.cpp - Internal representation of core system classes -// |
| // |
| // The VMKit project |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| //===- ClasspathVMField.cpp - GNU classpath java/lang/reflect/Field -------===// |
| // |
| // The VMKit project |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "Classpath.h" |
| #include "ClasspathReflect.h" |
| #include "JavaClass.h" |
| #include "JavaThread.h" |
| #include "JavaConstantPool.h" |
| #include "JavaTypes.h" |
| #include "JavaUpcalls.h" |
| #include "Jnjvm.h" |
| |
| |
| #include "Reader.h" |
| |
| #if 0 |
| using namespace vmkit; |
| #define dprintf(...) do { printf("ClasspathVMField: "); printf(__VA_ARGS__); } while(0) |
| #else |
| #define dprintf(...) |
| #endif |
| |
| using namespace j3; |
| |
| extern "C" { |
| |
| JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_getAnnotation( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* VMField, JavaObjectClass* annotationClass) { |
| JavaObject* res = 0; |
| JavaObject* newHashMap = 0; |
| llvm_gcroot(res, 0); |
| llvm_gcroot(newHashMap, 0); |
| llvm_gcroot(VMField, 0); |
| llvm_gcroot(annotationClass, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| Classpath* upcalls = vm->upcalls; |
| |
| dprintf("*************VMField_getAnnotation*************\n"); |
| if (annotationClass) { |
| /* Retrieving annotationClass classname */ |
| UserClass* clazz = JavaObjectClass::getClass(annotationClass)->asClass(); |
| dprintf("searched annotation : %s\n\n", UTF8Buffer(clazz->name).cString()); |
| |
| /* Retrieving VMField.class attributes list */ |
| UserClass* compilingClass = JavaObjectVMField::getClass(VMField); |
| JavaField* field = JavaObjectVMField::getInternalField(VMField); |
| JavaAttribute* annotationsAtt = |
| field->lookupAttribute(JavaAttribute::annotationsAttribute); |
| dprintf("JavaField : %s\n", UTF8Buffer(field->name).cString()); |
| |
| if (annotationsAtt) { |
| Reader reader(annotationsAtt, compilingClass->bytes); |
| AnnotationReader AR(reader, compilingClass); |
| uint16 numAnnotations = reader.readU2(); |
| |
| for (uint16 i = 0; i < numAnnotations; ++i) { |
| uint16 typeIndex = reader.readU2(); |
| const UTF8* annoType = compilingClass->ctpInfo->UTF8At(typeIndex); |
| |
| // Remove the L and ; in the name annotation type (L.....;) |
| // for the comparison. |
| dprintf("Comparing with : %s\n", UTF8Buffer(annoType).cString()); |
| if (clazz->name->equals(annoType->elements+1, annoType->size-2)) { |
| newHashMap = AR.createAnnotationMapValues(annotationClass); |
| break; |
| } else { |
| AR.readAnnotationElementValues(); |
| } |
| } // end for |
| |
| if (newHashMap) { |
| dprintf("Annotation creation\n"); |
| res = upcalls->createAnnotation->invokeJavaObjectStatic(vm, upcalls->newAnnotationHandler, &annotationClass, &newHashMap); |
| } |
| } |
| } else { |
| vm->nullPointerException(); |
| } |
| |
| END_NATIVE_EXCEPTION |
| dprintf("Annotation found\n"); |
| return res; |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_getDeclaredAnnotations( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* VMField) { |
| ArrayObject* arrayRes = 0; |
| JavaObject* res = 0; |
| JavaObject* annon = 0; |
| JavaObject* newHashMap = 0; |
| JavaObject* annotationClass = 0; |
| llvm_gcroot(res, 0); |
| llvm_gcroot(annon, 0); |
| llvm_gcroot(newHashMap, 0); |
| llvm_gcroot(VMField, 0); |
| llvm_gcroot(annotationClass, 0); |
| llvm_gcroot(arrayRes, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| Classpath* upcalls = vm->upcalls; |
| |
| /* Retrieving VMField.class attributes list */ |
| UserClass* compilingClass = JavaObjectVMField::getClass(VMField); |
| JavaField* field = JavaObjectVMField::getInternalField(VMField); |
| JavaAttribute* annotationsAtt = |
| field->lookupAttribute(JavaAttribute::annotationsAttribute); |
| dprintf("JavaField : %s\n", UTF8Buffer(field->name).cString()); |
| |
| JnjvmClassLoader* loader = compilingClass->classLoader; |
| |
| if (annotationsAtt) { |
| Reader reader(annotationsAtt, compilingClass->bytes); |
| AnnotationReader AR(reader, compilingClass); |
| uint16 numAnnotations = reader.readU2(); |
| |
| UserClassArray* array = upcalls->constructorArrayAnnotation; |
| arrayRes = (ArrayObject *)(res = array->doNew(numAnnotations, vm)); |
| dprintf("JavaField : %s with %d fields \n", UTF8Buffer(field->name).cString(), numAnnotations); |
| for (uint16 i = 0; i < numAnnotations; ++i) { |
| uint16 typeIndex = reader.readU2(); |
| const UTF8* annoType = compilingClass->ctpInfo->UTF8At(typeIndex); |
| annoType = annoType->extract(loader->hashUTF8, 1,annoType->size-1); |
| dprintf("Annotation type : %s\n", UTF8Buffer(annoType).cString()); |
| |
| UserClass* AnnonClass = 0; |
| UserCommonClass* commClass = loader->lookupClass(annoType); |
| |
| if (commClass) |
| AnnonClass = commClass -> asClass(); |
| else |
| AnnonClass = loader->loadName(annoType, true, true, NULL); |
| |
| |
| assert(AnnonClass && "Panic, imposible conditions"); |
| |
| dprintf("Loaded class : %s \n", UTF8Buffer(AnnonClass->name).cString()); |
| annotationClass = AnnonClass->getClassDelegatee(vm); |
| |
| newHashMap = AR.createAnnotationMapValues(annotationClass); |
| |
| annon = upcalls->createAnnotation->invokeJavaObjectStatic(vm, upcalls->newAnnotationHandler, &annotationClass, &newHashMap); |
| ArrayObject::setElement(arrayRes, annon, i); |
| } // end for |
| } |
| else { |
| UserClassArray* array = upcalls->constructorArrayAnnotation; |
| res = array->doNew(0, vm); |
| } |
| |
| END_NATIVE_EXCEPTION |
| return res; |
| } |
| |
| JNIEXPORT jint JNICALL Java_java_lang_reflect_VMField_getModifiersInternal( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field) { |
| jint res = 0; |
| |
| llvm_gcroot(Field, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| |
| res = field->access; |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_getType( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field) { |
| |
| JavaObject* res = 0; |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(res, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| |
| UserCommonClass* cls = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| |
| JnjvmClassLoader* loader = cls->classLoader; |
| UserCommonClass* fieldCl = field->getSignature()->assocClass(loader); |
| res = fieldCl->getClassDelegatee(vm); |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT jint JNICALL Java_java_lang_reflect_VMField_getInt( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| jint res = 0; |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| const Typedef* type = field->getSignature(); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| |
| if (prim->isInt()) { |
| if (stat) { |
| res = (sint32)field->getStaticInt32Field(); |
| } else { |
| res = (sint32)field->getInstanceInt32Field(obj); |
| } |
| } else if (prim->isChar()) { |
| if (stat) { |
| res = (uint32)field->getStaticInt16Field(); |
| } else { |
| res = (uint32)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isByte()) { |
| if (stat) { |
| res = (sint32)field->getStaticInt8Field(); |
| } else { |
| res = (sint32)field->getInstanceInt8Field(obj); |
| } |
| } else if (prim->isShort()) { |
| if (stat) { |
| res = (sint32)field->getStaticInt16Field(); |
| } else { |
| res = (sint32)field->getInstanceInt16Field(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| |
| } |
| |
| JNIEXPORT jlong JNICALL Java_java_lang_reflect_VMField_getLong( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| jlong res = 0; |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| |
| if (prim->isInt()) { |
| if (stat) { |
| res = (sint64)field->getStaticInt32Field(); |
| } else { |
| res = (sint64)field->getInstanceInt32Field(obj); |
| } |
| } else if (prim->isChar()) { |
| if (stat) { |
| res = (uint64)field->getStaticInt16Field(); |
| } else { |
| res = (uint64)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isByte()) { |
| if (stat) { |
| res = (sint64)field->getStaticInt8Field(); |
| } else { |
| res = (sint64)field->getInstanceInt8Field(obj); |
| } |
| } else if (prim->isShort()) { |
| if (stat) { |
| res = (sint64)field->getStaticInt16Field(); |
| } else { |
| res = (sint64)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| res = (sint64)field->getStaticLongField(); |
| } else { |
| res = (sint64)field->getInstanceLongField(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT jboolean JNICALL Java_java_lang_reflect_VMField_getBoolean( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| jboolean res = 0; |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isBool()) { |
| if (stat) { |
| res = (uint8)field->getStaticInt8Field(); |
| } else { |
| res = (uint8)field->getInstanceInt8Field(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| |
| } |
| |
| JNIEXPORT jfloat JNICALL Java_java_lang_reflect_VMField_getFloat( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| jfloat res = 0; |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isByte()) { |
| if (stat) { |
| res = (jfloat)field->getStaticInt8Field(); |
| } else { |
| res = (jfloat)field->getInstanceInt8Field(obj); |
| } |
| } else if (prim->isInt()) { |
| if (stat) { |
| res = (jfloat)field->getStaticInt32Field(); |
| } else { |
| res = (jfloat)field->getInstanceInt32Field(obj); |
| } |
| } else if (prim->isShort()) { |
| if (stat) { |
| res = (jfloat)field->getStaticInt16Field(); |
| } else { |
| res = (jfloat)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| res = (jfloat)field->getStaticLongField(); |
| } else { |
| res = (jfloat)field->getInstanceLongField(obj); |
| } |
| } else if (prim->isChar()) { |
| // Cast to uint32 because char is unsigned. |
| if (stat) { |
| res = (jfloat)(uint32)field->getStaticInt16Field(); |
| } else { |
| res = (jfloat)(uint32)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| res = (jfloat)field->getStaticFloatField(); |
| } else { |
| res = (jfloat)field->getInstanceFloatField(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT jbyte JNICALL Java_java_lang_reflect_VMField_getByte( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| jbyte res = 0; |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isByte()) { |
| if (stat) { |
| res = (sint8)field->getStaticInt8Field(); |
| } else { |
| res = (sint8)field->getInstanceInt8Field(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT jchar JNICALL Java_java_lang_reflect_VMField_getChar( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| jchar res = 0; |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isChar()) { |
| if (stat) { |
| res = (uint16)field->getStaticInt16Field(); |
| } else { |
| res = (uint16)field->getInstanceInt16Field(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| |
| } |
| |
| JNIEXPORT jshort JNICALL Java_java_lang_reflect_VMField_getShort( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| |
| jshort res = 0; |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isShort()) { |
| if (stat) { |
| res = (sint16)field->getStaticInt16Field(); |
| } else { |
| res = (sint16)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isByte()) { |
| if (stat) { |
| res = (sint16)field->getStaticInt8Field(); |
| } else { |
| res = (sint16)field->getInstanceInt8Field(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT jdouble JNICALL Java_java_lang_reflect_VMField_getDouble( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| jdouble res = 0; |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isByte()) { |
| if (stat) { |
| res = (jdouble)(sint64)field->getStaticInt8Field(); |
| } else { |
| res = (jdouble)(sint64)field->getInstanceInt8Field(obj); |
| } |
| } else if (prim->isInt()) { |
| if (stat) { |
| res = (jdouble)(sint64)field->getStaticInt32Field(); |
| } else { |
| res = (jdouble)(sint64)field->getInstanceInt32Field(obj); |
| } |
| } else if (prim->isShort()) { |
| if (stat) { |
| res = (jdouble)(sint64)field->getStaticInt16Field(); |
| } else { |
| res = (jdouble)(sint64)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| res = (jdouble)(sint64)field->getStaticLongField(); |
| } else { |
| res = (jdouble)(sint64)field->getInstanceLongField(obj); |
| } |
| } else if (prim->isChar()) { |
| if (stat) { |
| res = (jdouble)(uint64)field->getStaticInt16Field(); |
| } else { |
| res = (jdouble)(uint64)field->getInstanceInt16Field(obj); |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| res = (jdouble)field->getStaticFloatField(); |
| } else { |
| res = (jdouble)field->getInstanceFloatField(obj); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| res = (jdouble)field->getStaticDoubleField(); |
| } else { |
| res = (jdouble)field->getInstanceDoubleField(obj); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_get( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj) { |
| |
| |
| JavaObject* res = 0; |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| llvm_gcroot(res, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isBool()) { |
| uint8 val = stat ? field->getStaticInt8Field() : |
| field->getInstanceInt8Field(obj); |
| res = vm->upcalls->boolClass->doNew(vm); |
| vm->upcalls->boolValue->setInstanceInt8Field(res, val); |
| } else if (prim->isByte()) { |
| sint8 val = stat ? field->getStaticInt8Field() : |
| field->getInstanceInt8Field(obj); |
| res = vm->upcalls->byteClass->doNew(vm); |
| vm->upcalls->byteValue->setInstanceInt8Field(res, val); |
| } else if (prim->isChar()) { |
| uint16 val = stat ? field->getStaticInt16Field() : |
| field->getInstanceInt16Field(obj); |
| res = vm->upcalls->charClass->doNew(vm); |
| vm->upcalls->charValue->setInstanceInt16Field(res, val); |
| } else if (prim->isShort()) { |
| sint16 val = stat ? field->getStaticInt16Field() : |
| field->getInstanceInt16Field(obj); |
| res = vm->upcalls->shortClass->doNew(vm); |
| vm->upcalls->shortValue->setInstanceInt16Field(res, val); |
| } else if (prim->isInt()) { |
| sint64 val = stat ? field->getStaticInt32Field() : |
| field->getInstanceInt32Field(obj); |
| res = vm->upcalls->intClass->doNew(vm); |
| vm->upcalls->intValue->setInstanceInt32Field(res, val); |
| } else if (prim->isLong()) { |
| sint64 val = stat ? field->getStaticLongField() : |
| field->getInstanceLongField(obj); |
| res = vm->upcalls->longClass->doNew(vm); |
| vm->upcalls->longValue->setInstanceLongField(res, val); |
| } else if (prim->isFloat()) { |
| float val = stat ? field->getStaticFloatField() : |
| field->getInstanceFloatField(obj); |
| res = vm->upcalls->floatClass->doNew(vm); |
| vm->upcalls->floatValue->setInstanceFloatField(res, val); |
| } else if (prim->isDouble()) { |
| double val = stat ? field->getStaticDoubleField() : |
| field->getInstanceDoubleField(obj); |
| res = vm->upcalls->doubleClass->doNew(vm); |
| vm->upcalls->doubleValue->setInstanceDoubleField(res, val); |
| } |
| } else { |
| if (stat) { |
| res = field->getStaticObjectField(); |
| } else { |
| res = field->getInstanceObjectField(obj); |
| } |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| return res; |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_set( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, JavaObject* val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| llvm_gcroot(val, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| verifyNull(Field); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| jvalue buf; |
| bool stat = isStatic(field->access); |
| |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| JavaObject::decapsulePrimitive(val, vm, &buf, type); |
| |
| |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isBool()) { |
| if (stat) { |
| field->setStaticInt8Field(buf.z); |
| } else { |
| field->setInstanceInt8Field(obj, buf.z); |
| } |
| } else if (prim->isByte()) { |
| if (stat) { |
| field->setStaticInt8Field(buf.b); |
| } else { |
| field->setInstanceInt8Field(obj, buf.b); |
| } |
| } else if (prim->isChar()) { |
| if (stat) { |
| field->setStaticInt16Field(buf.c); |
| } else { |
| field->setInstanceInt16Field(obj, buf.c); |
| } |
| } else if (prim->isShort()) { |
| if (stat) { |
| field->setStaticInt16Field(buf.s); |
| } else { |
| field->setInstanceInt16Field(obj, buf.s); |
| } |
| } else if (prim->isInt()) { |
| if (stat) { |
| field->setStaticInt32Field(buf.i); |
| } else { |
| field->setInstanceInt32Field(obj, buf.i); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| field->setStaticLongField(buf.j); |
| } else { |
| field->setInstanceLongField(obj, buf.j); |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| field->setStaticFloatField(buf.f); |
| } else { |
| field->setInstanceFloatField(obj, buf.f); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField(buf.d); |
| } else { |
| field->setInstanceDoubleField(obj, buf.d); |
| } |
| } |
| } else { |
| if (stat) { |
| field->setStaticObjectField(val); |
| } else { |
| field->setInstanceObjectField(obj, val); |
| } |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setBoolean( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jboolean val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isBool()) { |
| if (stat) { |
| field->setStaticInt8Field((uint8)val); |
| } else { |
| field->setInstanceInt8Field(obj, (uint8)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setByte( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jbyte val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isByte()) { |
| if (stat) { |
| field->setStaticInt8Field((sint8)val); |
| } else { |
| field->setInstanceInt8Field(obj, (sint8)val); |
| } |
| } else if (prim->isShort()) { |
| if (stat) { |
| field->setStaticInt16Field((sint16)val); |
| } else { |
| field->setInstanceInt16Field(obj, (sint16)val); |
| } |
| } else if (prim->isInt()) { |
| if (stat) { |
| field->setStaticInt32Field((sint32)val); |
| } else { |
| field->setInstanceInt32Field(obj, (sint32)val); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| field->setStaticLongField((sint64)val); |
| } else { |
| field->setInstanceLongField(obj, (sint64)val); |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| field->setStaticFloatField((float)val); |
| } else { |
| field->setInstanceFloatField(obj, (float)val); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField((double)val); |
| } else { |
| field->setInstanceDoubleField(obj, (double)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setChar( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jchar val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isChar()) { |
| if (stat) { |
| field->setStaticInt16Field((uint16)val); |
| } else { |
| field->setInstanceInt16Field(obj, (uint16)val); |
| } |
| } else if (prim->isInt()) { |
| if (stat) { |
| field->setStaticInt32Field((uint32)val); |
| } else { |
| field->setInstanceInt32Field(obj, (uint32)val); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| field->setStaticLongField((uint64)val); |
| } else { |
| field->setInstanceLongField(obj, (uint64)val); |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| field->setStaticFloatField((float)(uint32)val); |
| } else { |
| field->setInstanceFloatField(obj, (float)(uint32)val); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField((double)(uint64)val); |
| } else { |
| field->setInstanceDoubleField(obj, (double)(uint64)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setShort( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jshort val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isShort()) { |
| if (stat) { |
| field->setStaticInt16Field((sint16)val); |
| } else { |
| field->setInstanceInt16Field(obj, (sint16)val); |
| } |
| } else if (prim->isInt()) { |
| if (stat) { |
| field->setStaticInt32Field((sint32)val); |
| } else { |
| field->setInstanceInt32Field(obj, (sint32)val); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| field->setStaticLongField((sint64)val); |
| } else { |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| field->setStaticFloatField((float)val); |
| } else { |
| field->setInstanceFloatField(obj, (float)val); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField((double)val); |
| } else { |
| field->setInstanceDoubleField(obj, (double)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setInt( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jint val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isInt()) { |
| if (stat) { |
| field->setStaticInt32Field((sint32)val); |
| } else { |
| field->setInstanceInt32Field(obj, (sint32)val); |
| } |
| } else if (prim->isLong()) { |
| if (stat) { |
| field->setStaticLongField((sint64)val); |
| } else { |
| field->setInstanceLongField(obj, (sint64)val); |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| field->setStaticFloatField((float)val); |
| } else { |
| field->setInstanceFloatField(obj, (float)val); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField((double)val); |
| } else { |
| field->setInstanceDoubleField(obj, (double)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setLong( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jlong val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isLong()) { |
| if (stat) { |
| field->setStaticLongField((sint64)val); |
| } else { |
| field->setInstanceLongField(obj, (sint64)val); |
| } |
| } else if (prim->isFloat()) { |
| if (stat) { |
| field->setStaticFloatField((float)val); |
| } else { |
| field->setInstanceFloatField(obj, (float)val); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField((double)val); |
| } else { |
| field->setInstanceDoubleField(obj, (double)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setFloat( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jfloat val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isFloat()) { |
| if (stat) { |
| field->setStaticFloatField((float)val); |
| } else { |
| field->setInstanceFloatField(obj, (float)val); |
| } |
| } else if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField((double)val); |
| } else { |
| field->setInstanceDoubleField(obj, (double)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setDouble( |
| #ifdef NATIVE_JNI |
| JNIEnv *env, |
| #endif |
| JavaObjectVMField* Field, JavaObject* obj, jdouble val) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(obj, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| verifyNull(Field); |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field); |
| JavaField* field = JavaObjectVMField::getInternalField(Field); |
| bool stat = isStatic(field->access); |
| |
| if (stat) { |
| cl->asClass()->initialiseClass(vm); |
| } else { |
| verifyNull(obj); |
| } |
| |
| const Typedef* type = field->getSignature(); |
| if (type->isPrimitive()) { |
| const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type; |
| if (prim->isDouble()) { |
| if (stat) { |
| field->setStaticDoubleField((double)val); |
| } else { |
| field->setInstanceDoubleField(obj, (double)val); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| } else { |
| vm->illegalArgumentException("wrong type"); |
| } |
| |
| END_NATIVE_EXCEPTION |
| } |
| |
| } |