Long* rvmBoxLong(Env* env, jlong value) {
jint index = value + 128;
if (index >= 0 && index < longsCache->length && longsCache->values[index] != NULL) {
return (Long*) longsCache->values[index];
}
jvalue args[1];
args[0].j = value;
return (Long*) rvmCallObjectClassMethodA(env, java_lang_Long, java_lang_Long_valueOf, args);
}
Integer* rvmBoxInt(Env* env, jint value) {
jint index = value + 128;
if (index >= 0 && index < integersCache->length && integersCache->values[index] != NULL) {
return (Integer*) integersCache->values[index];
}
jvalue args[1];
args[0].i = value;
return (Integer*) rvmCallObjectClassMethodA(env, java_lang_Integer, java_lang_Integer_valueOf, args);
}
Character* rvmBoxChar(Env* env, jchar value) {
jint index = value;
if (index >= 0 && index < charactersCache->length && charactersCache->values[index] != NULL) {
return (Character*) charactersCache->values[index];
}
jvalue args[1];
args[0].c = value;
return (Character*) rvmCallObjectClassMethodA(env, java_lang_Character, java_lang_Character_valueOf, args);
}
Short* rvmBoxShort(Env* env, jshort value) {
jint index = value + 128;
if (index >= 0 && index < shortsCache->length && shortsCache->values[index] != NULL) {
return (Short*) shortsCache->values[index];
}
jvalue args[1];
args[0].s = value;
return (Short*) rvmCallObjectClassMethodA(env, java_lang_Short, java_lang_Short_valueOf, args);
}
Byte* rvmBoxByte(Env* env, jbyte value) {
jint index = value + 128;
if (index >= 0 && index < bytesCache->length && bytesCache->values[index] != NULL) {
return (Byte*) bytesCache->values[index];
}
jvalue args[1];
args[0].b = value;
return (Byte*) rvmCallObjectClassMethodA(env, java_lang_Byte, java_lang_Byte_valueOf, args);
}
static jobject CallStaticObjectMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue* args) {
return (jobject) rvmCallObjectClassMethodA((Env*) env, (Class*) clazz, (Method*) methodID, args);
}
Object* rvmCallObjectClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return NULL;
return rvmCallObjectClassMethodA(env, clazz, method, jargs);
}
Object* Java_java_lang_reflect_Method_internalInvoke(Env* env, Class* clazz, jlong methodPtr, ObjectArray* parameterTypes, Object* receiver, ObjectArray* args) {
Method* method = (Method*) LONG_TO_PTR(methodPtr);
/*
* The Java code has already checked that the method is accessible
* to the the caller, that the receiver isn't null (for non static methods),
* that the receiver is an instance of the declaring class (for non static methods)
* and that the number of arguments are correct. The args array is never null.
*/
jvalue* jvalueArgs = validateAndUnwrapArgs(env, parameterTypes, args);
if (!jvalueArgs) return NULL;
const char* retDesc = rvmGetReturnType(method->desc);
jvalue jvalueRet[1];
if (METHOD_IS_STATIC(method)) {
switch (retDesc[0]) {
case 'V':
rvmCallVoidClassMethodA(env, method->clazz, method, jvalueArgs);
jvalueRet->l = NULL;
break;
case 'Z':
jvalueRet->z = rvmCallBooleanClassMethodA(env, method->clazz, method, jvalueArgs);
break;
case 'B':
jvalueRet->b = rvmCallByteClassMethodA(env, method->clazz, method, jvalueArgs);
break;
case 'S':
jvalueRet->s = rvmCallShortClassMethodA(env, method->clazz, method, jvalueArgs);
break;
case 'C':
jvalueRet->c = rvmCallCharClassMethodA(env, method->clazz, method, jvalueArgs);
break;
case 'I':
jvalueRet->i = rvmCallIntClassMethodA(env, method->clazz, method, jvalueArgs);
break;
case 'J':
jvalueRet->j = rvmCallLongClassMethodA(env, method->clazz, method, jvalueArgs);
break;
case 'F':
jvalueRet->f = rvmCallFloatClassMethodA(env, method->clazz, method, jvalueArgs);
break;
case 'D':
jvalueRet->d = rvmCallDoubleClassMethodA(env, method->clazz, method, jvalueArgs);
break;
default:
jvalueRet->l = (jobject) rvmCallObjectClassMethodA(env, method->clazz, method, jvalueArgs);
break;
}
} else {
switch (retDesc[0]) {
case 'V':
rvmCallVoidInstanceMethodA(env, receiver, method, jvalueArgs);
jvalueRet->l = NULL;
break;
case 'Z':
jvalueRet->z = rvmCallBooleanInstanceMethodA(env, receiver, method, jvalueArgs);
break;
case 'B':
jvalueRet->b = rvmCallByteInstanceMethodA(env, receiver, method, jvalueArgs);
break;
case 'S':
jvalueRet->s = rvmCallShortInstanceMethodA(env, receiver, method, jvalueArgs);
break;
case 'C':
jvalueRet->c = rvmCallCharInstanceMethodA(env, receiver, method, jvalueArgs);
break;
case 'I':
jvalueRet->i = rvmCallIntInstanceMethodA(env, receiver, method, jvalueArgs);
break;
case 'J':
jvalueRet->j = rvmCallLongInstanceMethodA(env, receiver, method, jvalueArgs);
break;
case 'F':
jvalueRet->f = rvmCallFloatInstanceMethodA(env, receiver, method, jvalueArgs);
break;
case 'D':
jvalueRet->d = rvmCallDoubleInstanceMethodA(env, receiver, method, jvalueArgs);
break;
default:
jvalueRet->l = (jobject) rvmCallObjectInstanceMethodA(env, receiver, method, jvalueArgs);
break;
}
}
if (rvmExceptionCheck(env)) {
throwInvocationTargetException(env, rvmExceptionOccurred(env));
return NULL;
}
if (retDesc[0] != 'L' && retDesc[0] != '[') {
// Return type is primitive. Box it.
Class* retType = rvmFindClassByDescriptor(env, retDesc, NULL);
return rvmBox(env, retType, jvalueRet);
} else {
return (Object*) jvalueRet->l;
}
}
Double* rvmBoxDouble(Env* env, jdouble value) {
jvalue args[1];
args[0].d = value;
return (Double*) rvmCallObjectClassMethodA(env, java_lang_Double, java_lang_Double_valueOf, args);
}
Float* rvmBoxFloat(Env* env, jfloat value) {
jvalue args[1];
args[0].f = value;
return (Float*) rvmCallObjectClassMethodA(env, java_lang_Float, java_lang_Float_valueOf, args);
}
