Christian Thalinger
Edwin Steiner
- $Id: jni.c 4530 2006-02-21 09:11:53Z twisti $
+ $Id: jni.c 4559 2006-03-05 23:24:50Z twisti $
*/
void *ptr_env = (void*) &JNI_JNIEnvTable;
-#define PTR_TO_ITEM(ptr) ((u8)(size_t)(ptr))
-
/* global variables ***********************************************************/
/* global reference table *****************************************************/
}
-static void fill_callblock_from_vargs(void *obj, methoddesc *descr,
- jni_callblock blk[], va_list data,
- s4 rettype)
-{
- typedesc *paramtypes;
- s4 i;
-
- paramtypes = descr->paramtypes;
-
- /* if method is non-static fill first block and skip `this' pointer */
-
- i = 0;
-
- if (obj != NULL) {
- /* the `this' pointer */
- blk[0].itemtype = TYPE_ADR;
- blk[0].item = PTR_TO_ITEM(obj);
-
- paramtypes++;
- i++;
- }
-
- for (; i < descr->paramcount; i++, paramtypes++) {
- switch (paramtypes->decltype) {
- /* primitive types */
- case PRIMITIVETYPE_BYTE:
- case PRIMITIVETYPE_CHAR:
- case PRIMITIVETYPE_SHORT:
- case PRIMITIVETYPE_BOOLEAN:
- blk[i].itemtype = TYPE_INT;
- blk[i].item = (s8) va_arg(data, s4);
- break;
-
- case PRIMITIVETYPE_INT:
- blk[i].itemtype = TYPE_INT;
- blk[i].item = (s8) va_arg(data, s4);
- break;
-
- case PRIMITIVETYPE_LONG:
- blk[i].itemtype = TYPE_LNG;
- blk[i].item = (s8) va_arg(data, s8);
- break;
-
- case PRIMITIVETYPE_FLOAT:
- blk[i].itemtype = TYPE_FLT;
-#if defined(__ALPHA__)
- /* this keeps the assembler function much simpler */
-
- *((jdouble *) (&blk[i].item)) = (jdouble) va_arg(data, jdouble);
-#else
- *((jfloat *) (&blk[i].item)) = (jfloat) va_arg(data, jdouble);
-#endif
- break;
-
- case PRIMITIVETYPE_DOUBLE:
- blk[i].itemtype = TYPE_DBL;
- *((jdouble *) (&blk[i].item)) = (jdouble) va_arg(data, jdouble);
- break;
-
- case TYPE_ADR:
- blk[i].itemtype = TYPE_ADR;
- blk[i].item = PTR_TO_ITEM(va_arg(data, void*));
- break;
- }
- }
-
- /* The standard doesn't say anything about return value checking,
- but it appears to be useful. */
+/* _Jv_jni_vmargs_from_objectarray *********************************************
- if (rettype != descr->returntype.decltype)
- log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
-}
+ XXX
+*******************************************************************************/
-/* XXX it could be considered if we should do typechecking here in the future */
-
-static bool fill_callblock_from_objectarray(void *obj, methoddesc *descr,
- jni_callblock blk[],
+static bool _Jv_jni_vmargs_from_objectarray(java_objectheader *o,
+ methoddesc *descr,
+ vm_arg *vmargs,
java_objectarray *params)
{
java_objectheader *param;
i = 0;
- if (obj) {
+ if (o != NULL) {
/* this pointer */
- blk[0].itemtype = TYPE_ADR;
- blk[0].item = PTR_TO_ITEM(obj);
+ vmargs[0].type = TYPE_ADR;
+ vmargs[0].data = (u8) (ptrint) o;
paramtypes++;
paramcount--;
case TYPE_FLOAT:
case TYPE_DOUBLE:
param = params->data[j];
- if (!param)
+
+ if (param == NULL)
goto illegal_arg;
/* internally used data type */
- blk[i].itemtype = paramtypes->type;
+ vmargs[i].type = paramtypes->type;
/* convert the value according to its declared type */
switch (paramtypes->decltype) {
case PRIMITIVETYPE_BOOLEAN:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Boolean *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Boolean *) param)->value;
else
goto illegal_arg;
break;
case PRIMITIVETYPE_BYTE:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
break;
case PRIMITIVETYPE_CHAR:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Character *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Character *) param)->value;
else
goto illegal_arg;
break;
case PRIMITIVETYPE_SHORT:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Short *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Short *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
break;
case PRIMITIVETYPE_INT:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Integer *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Integer *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
- blk[i].item = (s8) ((java_lang_Short *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Short *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
break;
case PRIMITIVETYPE_LONG:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Long *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Long *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_INT].class_wrap)
- blk[i].item = (s8) ((java_lang_Integer *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Integer *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
- blk[i].item = (s8) ((java_lang_Short *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Short *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
break;
case PRIMITIVETYPE_FLOAT:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- *((jfloat *) (&blk[i].item)) = (jfloat) ((java_lang_Float *) param)->value;
+ *((jfloat *) (&vmargs[i].data)) = (jfloat) ((java_lang_Float *) param)->value;
else
goto illegal_arg;
break;
case PRIMITIVETYPE_DOUBLE:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- *((jdouble *) (&blk[i].item)) = (jdouble) ((java_lang_Double *) param)->value;
+ *((jdouble *) (&vmargs[i].data)) = (jdouble) ((java_lang_Double *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_FLOAT].class_wrap)
- *((jfloat *) (&blk[i].item)) = (jfloat) ((java_lang_Float *) param)->value;
+ *((jfloat *) (&vmargs[i].data)) = (jfloat) ((java_lang_Float *) param)->value;
else
goto illegal_arg;
break;
default:
goto illegal_arg;
- } /* end declared type switch */
+ }
break;
case TYPE_ADDRESS:
goto illegal_arg;
}
}
- blk[i].itemtype = TYPE_ADR;
- blk[i].item = PTR_TO_ITEM(params->data[j]);
- break;
+ vmargs[i].type = TYPE_ADR;
+ vmargs[i].data = (u8) (ptrint) params->data[j];
+ break;
default:
goto illegal_arg;
- } /* end param type switch */
-
- } /* end param loop */
+ }
+ }
/* if (rettype) */
/* *rettype = descr->returntype.decltype; */
methodinfo *m, va_list ap)
{
methodinfo *resm;
- s4 paramcount;
- jni_callblock *blk;
- java_objectheader *ret;
- s4 dumpsize;
+ java_objectheader *ro;
STATISTICS(jniinvokation());
resm = method_vftbl_lookup(vftbl, m);
}
- /* mark start of dump memory area */
+ STATISTICS(jnicallXmethodnvokation());
+
+ ro = vm_call_method_valist(resm, o, ap);
- dumpsize = dump_size();
+ return ro;
+}
- paramcount = resm->parseddesc->paramcount;
- blk = DMNEW(jni_callblock, paramcount);
+/* _Jv_jni_CallObjectMethodA ***************************************************
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap, TYPE_ADR);
+ Internal function to call Java Object methods.
- STATISTICS(jnicallXmethodnvokation());
+*******************************************************************************/
- ASM_CALLJAVAFUNCTION2_ADR(ret, resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
+static java_objectheader *_Jv_jni_CallObjectMethodA(java_objectheader *o,
+ vftbl_t *vftbl,
+ methodinfo *m, jvalue *args)
+{
+ methodinfo *resm;
+ java_objectheader *ro;
+
+ STATISTICS(jniinvokation());
+
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
+ }
+
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
+
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
+
+ if (o != NULL)
+ o = NULL;
+
+ /* for convenience */
+
+ resm = m;
+
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
- /* release dump area */
+ resm = method_vftbl_lookup(vftbl, m);
+ }
- dump_release(dumpsize);
+ STATISTICS(jnicallXmethodnvokation());
- return ret;
+ ro = vm_call_method_jvalue(resm, o, args);
+
+ return ro;
}
*******************************************************************************/
static jint _Jv_jni_CallIntMethod(java_objectheader *o, vftbl_t *vftbl,
- methodinfo *m, va_list ap, s4 type)
+ methodinfo *m, va_list ap)
{
- methodinfo *resm;
- s4 paramcount;
- jni_callblock *blk;
- jint ret;
- s4 dumpsize;
+ methodinfo *resm;
+ jint i;
STATISTICS(jniinvokation());
resm = method_vftbl_lookup(vftbl, m);
}
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- paramcount = resm->parseddesc->paramcount;
-
- blk = DMNEW(jni_callblock, paramcount);
-
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap, type);
-
STATISTICS(jnicallXmethodnvokation());
- ASM_CALLJAVAFUNCTION2_INT(ret, resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
-
- /* release dump area */
+ i = vm_call_method_int_valist(resm, o, ap);
- dump_release(dumpsize);
-
- return ret;
+ return i;
}
static jlong _Jv_jni_CallLongMethod(java_objectheader *o, vftbl_t *vftbl,
methodinfo *m, va_list ap)
{
- methodinfo *resm;
- s4 paramcount;
- jni_callblock *blk;
- jlong ret;
- s4 dumpsize;
+ methodinfo *resm;
+ jlong l;
STATISTICS(jniinvokation());
resm = method_vftbl_lookup(vftbl, m);
}
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- paramcount = resm->parseddesc->paramcount;
-
- blk = DMNEW(jni_callblock, paramcount);
-
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap, PRIMITIVETYPE_LONG);
-
STATISTICS(jnicallXmethodnvokation());
- ASM_CALLJAVAFUNCTION2_LONG(ret, resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
-
- /* release dump area */
+ l = vm_call_method_long_valist(resm, o, ap);
- dump_release(dumpsize);
-
- return ret;
+ return l;
}
static jfloat _Jv_jni_CallFloatMethod(java_objectheader *o, vftbl_t *vftbl,
methodinfo *m, va_list ap)
{
- methodinfo *resm;
- s4 paramcount;
- jni_callblock *blk;
- jdouble ret;
- s4 dumpsize;
+ methodinfo *resm;
+ jfloat f;
/* Class initialization is done by the JIT compiler. This is ok
since a static method always belongs to the declaring class. */
resm = method_vftbl_lookup(vftbl, m);
}
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- paramcount = resm->parseddesc->paramcount;
-
- blk = DMNEW(jni_callblock, paramcount);
-
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap,
- PRIMITIVETYPE_FLOAT);
-
STATISTICS(jnicallXmethodnvokation());
- ASM_CALLJAVAFUNCTION2_FLOAT(ret, resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
-
- /* release dump area */
-
- dump_release(dumpsize);
+ f = vm_call_method_float_valist(resm, o, ap);
- return ret;
+ return f;
}
static jdouble _Jv_jni_CallDoubleMethod(java_objectheader *o, vftbl_t *vftbl,
methodinfo *m, va_list ap)
{
- methodinfo *resm;
- s4 paramcount;
- jni_callblock *blk;
- jfloat ret;
- s4 dumpsize;
+ methodinfo *resm;
+ jdouble d;
/* Class initialization is done by the JIT compiler. This is ok
since a static method always belongs to the declaring class. */
resm = method_vftbl_lookup(vftbl, m);
}
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- paramcount = resm->parseddesc->paramcount;
-
- blk = DMNEW(jni_callblock, paramcount);
-
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap,
- PRIMITIVETYPE_DOUBLE);
+ d = vm_call_method_double_valist(resm, o, ap);
- STATISTICS(jnicallXmethodnvokation());
-
- ASM_CALLJAVAFUNCTION2_DOUBLE(ret, resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
-
- /* release dump area */
-
- dump_release(dumpsize);
-
- return ret;
+ return d;
}
static void _Jv_jni_CallVoidMethod(java_objectheader *o, vftbl_t *vftbl,
methodinfo *m, va_list ap)
{
- methodinfo *resm;
- s4 paramcount;
- jni_callblock *blk;
- s4 dumpsize;
+ methodinfo *resm;
if (m == NULL) {
exceptions_throw_nullpointerexception();
resm = method_vftbl_lookup(vftbl, m);
}
- /* mark start of dump memory area */
+ STATISTICS(jnicallXmethodnvokation());
+
+ (void) vm_call_method_valist(resm, o, ap);
+}
- dumpsize = dump_size();
- paramcount = resm->parseddesc->paramcount;
+/* _Jv_jni_CallVoidMethodA *****************************************************
- blk = DMNEW(jni_callblock, paramcount);
+ Internal function to call Java void methods.
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap, TYPE_VOID);
+*******************************************************************************/
- STATISTICS(jnicallXmethodnvokation());
+static void _Jv_jni_CallVoidMethodA(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, jvalue *args)
+{
+ methodinfo *resm;
- ASM_CALLJAVAFUNCTION2(resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return;
+ }
- /* release dump area */
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
+
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
+
+ if (o != NULL)
+ o = NULL;
+
+ /* for convenience */
+
+ resm = m;
+
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
+
+ resm = method_vftbl_lookup(vftbl, m);
+ }
+
+ STATISTICS(jnicallXmethodnvokation());
- dump_release(dumpsize);
+ (void) vm_call_method_jvalue(resm, o, args);
}
java_objectarray *params)
{
methodinfo *resm;
- jni_callblock *blk;
+ vm_arg *vmargs;
java_objectheader *ro;
s4 argcount;
s4 paramcount;
class the method belongs to. For static methods the obj
parameter is ignored. */
- if (!(m->flags & ACC_STATIC) && o &&
- (!builtin_instanceof(o, m->class)))
- {
+ if (!(m->flags & ACC_STATIC) && o && (!builtin_instanceof(o, m->class))) {
*exceptionptr =
new_exception_message(string_java_lang_IllegalArgumentException,
"Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
resm = m;
}
- blk = MNEW(jni_callblock, argcount);
+ vmargs = MNEW(vm_arg, argcount);
- if (!fill_callblock_from_objectarray(o, resm->parseddesc, blk, params))
+ if (!_Jv_jni_vmargs_from_objectarray(o, resm->parseddesc, vmargs, params))
return NULL;
switch (resm->parseddesc->returntype.decltype) {
case TYPE_VOID:
- ASM_CALLJAVAFUNCTION2(resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ (void) vm_call_method_vmarg(resm, argcount, vmargs);
ro = NULL;
break;
s4 i;
java_lang_Boolean *bo;
- ASM_CALLJAVAFUNCTION2_INT(i, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Boolean);
s4 i;
java_lang_Byte *bo;
- ASM_CALLJAVAFUNCTION2_INT(i, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Byte);
s4 i;
java_lang_Character *co;
- ASM_CALLJAVAFUNCTION2_INT(i, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Character);
s4 i;
java_lang_Short *so;
- ASM_CALLJAVAFUNCTION2_INT(i, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Short);
s4 i;
java_lang_Integer *io;
- ASM_CALLJAVAFUNCTION2_INT(i, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Integer);
s8 l;
java_lang_Long *lo;
- ASM_CALLJAVAFUNCTION2_LONG(l, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ l = vm_call_method_long_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Long);
float f;
java_lang_Float *fo;
- ASM_CALLJAVAFUNCTION2_FLOAT(f, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ f = vm_call_method_float_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Float);
double d;
java_lang_Double *_do;
- ASM_CALLJAVAFUNCTION2_DOUBLE(d, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ d = vm_call_method_double_vmarg(resm, argcount, vmargs);
ro = builtin_new(class_java_lang_Double);
break;
case TYPE_ADR:
- ASM_CALLJAVAFUNCTION2_ADR(ro, resm, argcount,
- argcount * sizeof(jni_callblock),
- blk);
+ ro = vm_call_method_vmarg(resm, argcount, vmargs);
break;
default:
/* if this happens the exception has already been set by
fill_callblock_from_objectarray */
- MFREE(blk, jni_callblock, argcount);
+ MFREE(vmargs, vm_arg, argcount);
return NULL;
}
- MFREE(blk, jni_callblock, argcount);
+ MFREE(vmargs, vm_arg, argcount);
if (*exceptionptr) {
java_objectheader *cause;
/* print the stacktrace */
- ASM_CALLJAVAFUNCTION(m, e, NULL, NULL, NULL);
+ (void) vm_call_method(m, e);
}
}
o = builtin_new(clazz);
- if (!o)
+ if (o == NULL)
return NULL;
/* call constructor */
o = builtin_new(clazz);
- if (!o)
+ if (o == NULL)
return NULL;
/* call constructor */
}
-/***********************************************************************************
+/* NewObjectA *****************************************************************
- Constructs a new Java object
- arguments that are to be passed to the constructor are placed in
- args array of jvalues
+ Programmers place all arguments that are to be passed to the
+ constructor in an args array of jvalues that immediately follows
+ the methodID argument. NewObjectA() accepts the arguments in this
+ array, and, in turn, passes them to the Java method that the
+ programmer wishes to invoke.
-***********************************************************************************/
+*******************************************************************************/
jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
{
+ java_objectheader *o;
+ methodinfo *m;
+
STATISTICS(jniinvokation());
- log_text("JNI-Call: NewObjectA: IMPLEMENT ME!");
+ m = (methodinfo *) methodID;
+
+ /* create object */
- return NewLocalRef(env, NULL);
+ o = builtin_new(clazz);
+
+ if (o == NULL)
+ return NULL;
+
+ /* call constructor */
+
+ _Jv_jni_CallVoidMethodA(o, o->vftbl, m, args);
+
+ return NewLocalRef(env, o);
}
}
-jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
+jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallObjectMethodA: IMPLEMENT ME!");
+ java_objectheader *o;
+ methodinfo *m;
+ java_objectheader *ret;
- return NewLocalRef(env, NULL);
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ ret = _Jv_jni_CallObjectMethodA(o, o->vftbl, m, args);
+
+ return NewLocalRef(env, ret);
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap, PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
return b;
o = (java_objectheader *) obj;
m = (methodinfo *) methodID;
- b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args, PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
return b;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
return b;
o = (java_objectheader *) obj;
m = (methodinfo *) methodID;
- b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
return b;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- c = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap, PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
return c;
o = (java_objectheader *) obj;
m = (methodinfo *) methodID;
- c = _Jv_jni_CallIntMethod(o, o->vftbl, m, args, PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
return c;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- s = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap, PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
return s;
o = (java_objectheader *) obj;
m = (methodinfo *) methodID;
- s = _Jv_jni_CallIntMethod(o, o->vftbl, m, args, PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
return s;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- i = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap, PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
return i;
o = (java_objectheader *) obj;
m = (methodinfo *) methodID;
- i = _Jv_jni_CallIntMethod(o, o->vftbl, m, args, PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
return i;
}
void CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallVoidMethodA: IMPLEMENT ME!");
+ java_objectheader *o;
+ methodinfo *m;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethodA(o, o->vftbl, m, args);
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap, PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
return b;
c = (classinfo *) clazz;
m = (methodinfo *) methodID;
- b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args, PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
return b;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
return b;
c = (classinfo *) clazz;
m = (methodinfo *) methodID;
- b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
return b;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap, PRIMITIVETYPE_CHAR);
+ ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
return ch;
c = (classinfo *) clazz;
m = (methodinfo *) methodID;
- ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, args, PRIMITIVETYPE_CHAR);
+ ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
return ch;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- s = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap, PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
return s;
c = (classinfo *) clazz;
m = (methodinfo *) methodID;
- s = _Jv_jni_CallIntMethod(o, c->vftbl, m, args, PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
return s;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- i = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap, PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
return i;
c = (classinfo *) clazz;
m = (methodinfo *) methodID;
- i = _Jv_jni_CallIntMethod(o, c->vftbl, m, args, PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
return i;
}
void CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
-{
- log_text("JNI-Call: CallNonvirtualVoidMethodA: IMPLEMENT ME!");
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethodA(o, c->vftbl, m, args);
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap, PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
return b;
m = (methodinfo *) methodID;
- b = _Jv_jni_CallIntMethod(NULL, NULL, m, args, PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
return b;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
return b;
m = (methodinfo *) methodID;
- b = _Jv_jni_CallIntMethod(NULL, NULL, m, args, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
return b;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- c = _Jv_jni_CallIntMethod(NULL, NULL, m, ap, PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
return c;
m = (methodinfo *) methodID;
- c = _Jv_jni_CallIntMethod(NULL, NULL, m, args, PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
return c;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- s = _Jv_jni_CallIntMethod(NULL, NULL, m, ap, PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
return s;
m = (methodinfo *) methodID;
- s = _Jv_jni_CallIntMethod(NULL, NULL, m, args, PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
return s;
}
m = (methodinfo *) methodID;
va_start(ap, methodID);
- i = _Jv_jni_CallIntMethod(NULL, NULL, m, ap, PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
return i;
m = (methodinfo *) methodID;
- i = _Jv_jni_CallIntMethod(NULL, NULL, m, args, PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
return i;
}
void CallStaticVoidMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args)
{
- log_text("JNI-Call: CallStaticVoidMethodA: IMPLEMENT ME!");
+ methodinfo *m;
+
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethodA(NULL, NULL, m, args);
}
builtin_monitorenter(*global_ref_table);
#endif
- ASM_CALLJAVAFUNCTION_ADR(o, getmid, *global_ref_table, lobj, NULL, NULL);
+ o = vm_call_method(getmid, *global_ref_table, lobj);
refcount = (java_lang_Integer *) o;
return NULL;
}
- ASM_CALLJAVAFUNCTION(putmid, *global_ref_table, lobj, newval, NULL);
+ (void) vm_call_method(putmid, *global_ref_table, lobj, newval);
} else {
/* we can access the object itself, as we are in a
builtin_monitorenter(*global_ref_table);
#endif
- ASM_CALLJAVAFUNCTION_ADR(o, getmid, *global_ref_table, globalRef, NULL,
- NULL);
+ o = vm_call_method(getmid, *global_ref_table, globalRef);
refcount = (java_lang_Integer *) o;
val = refcount->value - 1;
if (val == 0) {
- ASM_CALLJAVAFUNCTION(removemid, *global_ref_table, refcount, NULL,
- NULL);
+ (void) vm_call_method(removemid, *global_ref_table, refcount);
} else {
/* we do not create a new object, but set the new value into
projects / cacao.git / blobdiff