Object* Java_java_lang_Class_getEnclosingMethod(Env* env, Class* thiz) {
Method* method = rvmAttributeGetEnclosingMethod(env, thiz);
if (!method || METHOD_IS_CONSTRUCTOR(method)) return NULL;
Class* jlr_Method = rvmFindClassUsingLoader(env, "java/lang/reflect/Method", NULL);
if (!jlr_Method) return NULL;
Method* constructor = rvmGetInstanceMethod(env, jlr_Method, "<init>", "(J)V");
if (!constructor) return NULL;
jvalue args[1];
args[0].j = PTR_TO_LONG(method);
return rvmNewObjectA(env, jlr_Method, constructor, args);
}
Object* createFieldObject(Env* env, Field* field) {
if (!java_lang_reflect_Field) {
java_lang_reflect_Field = rvmFindClassUsingLoader(env, "java/lang/reflect/Field", NULL);
if (!java_lang_reflect_Field) return NULL;
}
if (!java_lang_reflect_Field_init) {
java_lang_reflect_Field_init = rvmGetInstanceMethod(env, java_lang_reflect_Field, "<init>", "(J)V");
if (!java_lang_reflect_Field_init) return NULL;
}
jvalue initArgs[1];
initArgs[0].j = PTR_TO_LONG(field);
return rvmNewObjectA(env, java_lang_reflect_Field, java_lang_reflect_Field_init, initArgs);
}
Object* createConstructorObject(Env* env, Method* method) {
if (!java_lang_reflect_Constructor) {
java_lang_reflect_Constructor = rvmFindClassUsingLoader(env, "java/lang/reflect/Constructor", NULL);
if (!java_lang_reflect_Constructor) return NULL;
}
if (!java_lang_reflect_Constructor_init) {
java_lang_reflect_Constructor_init = rvmGetInstanceMethod(env, java_lang_reflect_Constructor, "<init>", "(J)V");
if (!java_lang_reflect_Constructor_init) return NULL;
}
jvalue initArgs[1];
initArgs[0].j = PTR_TO_LONG(method);
return rvmNewObjectA(env, java_lang_reflect_Constructor, java_lang_reflect_Constructor_init, initArgs);
}
void throwInvocationTargetException(Env* env, Object* throwable) {
rvmExceptionClear(env);
if (!java_lang_reflect_InvocationTargetException) {
java_lang_reflect_InvocationTargetException = rvmFindClassUsingLoader(env, "java/lang/reflect/InvocationTargetException", NULL);
if (!java_lang_reflect_InvocationTargetException) return;
}
if (!java_lang_reflect_InvocationTargetException_init) {
java_lang_reflect_InvocationTargetException_init = rvmGetMethod(env, java_lang_reflect_InvocationTargetException, "<init>", "(Ljava/lang/Throwable;)V");
if (!java_lang_reflect_InvocationTargetException_init) return;
}
jvalue initArgs[1];
initArgs[0].l = (jobject) throwable;
Object* exception = rvmNewObjectA(env, java_lang_reflect_InvocationTargetException, java_lang_reflect_InvocationTargetException_init, initArgs);
if (!exception) return;
rvmThrow(env, exception);
}
jboolean rvmThrowNew(Env* env, JClass* clazz, const char* message) {
Method* constructor = rvmGetInstanceMethod(env, clazz, "<init>", "(Ljava/lang/String;)V");
if (!constructor) return FALSE;
Object* string = NULL;
// TODO: Check that clazz != NULL?
if (message) {
string = rvmNewStringUTF(env, message, -1);
if (!string) return FALSE;
}
jvalue args[1];
args[0].l = (jobject) string;
Object* e = rvmNewObjectA(env, clazz, constructor, args);
if (!e) return FALSE;
rvmThrow(env, e);
return TRUE;
}
ObjectArray* rvmCallStackToStackTraceElements(Env* env, CallStack* callStack, jint first) {
if (!callStack || callStack->length == 0) {
return empty_java_lang_StackTraceElement_array;
}
// Count the number of methods
jint index = first;
jint length = 0;
while (rvmGetNextCallStackMethod(env, callStack, &index)) {
length++;
}
if (length == 0) {
return empty_java_lang_StackTraceElement_array;
}
ObjectArray* array = rvmNewObjectArray(env, length, java_lang_StackTraceElement, NULL, NULL);
if (!array) return NULL;
if (length > 0) {
jvalue args[4];
index = first;
jint i;
for (i = 0; i < length; i++) {
Method* m = rvmGetNextCallStackMethod(env, callStack, &index);
args[0].l = (jobject) m->clazz;
args[1].l = (jobject) rvmNewStringUTF(env, m->name, -1);
if (!args[1].l) return NULL;
args[2].l = (jobject) rvmAttributeGetClassSourceFile(env, m->clazz);
if (rvmExceptionOccurred(env)) {
return NULL;
}
args[3].i = METHOD_IS_NATIVE(m) ? -2 : -1; // TODO: Line numbers
array->values[i] = rvmNewObjectA(env, java_lang_StackTraceElement,
java_lang_StackTraceElement_constructor, args);
if (!array->values[i]) return NULL;
}
}
return array;
}
Object* Java_java_lang_reflect_Constructor_internalNewInstance(Env* env, JClass* clazz, jlong methodPtr, ObjectArray* parameterTypes, ObjectArray* args) {
Method* method = (Method*) LONG_TO_PTR(methodPtr);
/*
* The Java code has already checked that the constructor is accessible
* to the the caller, that the class can be instatiated and that the number
* of arguments are correct. The args array is never null.
*/
jvalue* jvalueArgs = validateAndUnwrapArgs(env, parameterTypes, args);
if (!jvalueArgs) return NULL;
Object* o = rvmNewObjectA(env, method->clazz, method, jvalueArgs);
if (!o) {
Object* exception = rvmExceptionOccurred(env);
if (exception->clazz != java_lang_ExceptionInInitializerError) {
throwInvocationTargetException(env, rvmExceptionOccurred(env));
}
return NULL;
}
return o;
}
Object* rvmNewDirectByteBuffer(Env* env, void* address, jlong capacity) {
jvalue args[2];
args[0].i = (jint) address;
args[1].i = (jint) capacity;
return rvmNewObjectA(env, java_nio_ReadWriteDirectByteBuffer, java_nio_ReadWriteDirectByteBuffer_init, args);
}
static jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue* args) {
return (jobject) rvmNewObjectA((Env*) env, (Class*) clazz, (Method*) methodID, args);
}
