/* src/native/jni.c - implementation of the Java Native Interface functions
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
J. Wenninger, Institut f. Computersprachen - TU Wien
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Rainhard Grafl
- Roman Obermaisser
-
- Changes: Joseph Wenninger
- Martin Platter
- Christian Thalinger
- Edwin Steiner
-
- $Id: jni.c 4522 2006-02-14 20:27:06Z edwin $
+ $Id: jni.c 7408 2007-02-26 22:11:38Z twisti $
*/
#include "vm/types.h"
-#include "mm/boehm.h"
+#include "mm/gc-common.h"
#include "mm/memory.h"
#include "native/jni.h"
#include "native/native.h"
-#include "native/include/gnu_classpath_Pointer.h"
+#if defined(ENABLE_JAVASE)
+# if defined(WITH_CLASSPATH_GNU)
+# include "native/include/gnu_classpath_Pointer.h"
-#if SIZEOF_VOID_P == 8
-# include "native/include/gnu_classpath_Pointer64.h"
-#else
-# include "native/include/gnu_classpath_Pointer32.h"
+# if SIZEOF_VOID_P == 8
+# include "native/include/gnu_classpath_Pointer64.h"
+# else
+# include "native/include/gnu_classpath_Pointer32.h"
+# endif
+# endif
#endif
#include "native/include/java_lang_Object.h"
#include "native/include/java_lang_Long.h"
#include "native/include/java_lang_Float.h"
#include "native/include/java_lang_Double.h"
+#include "native/include/java_lang_String.h"
#include "native/include/java_lang_Throwable.h"
-#include "native/include/java_lang_reflect_Method.h"
-#include "native/include/java_lang_reflect_Constructor.h"
-#include "native/include/java_lang_reflect_Field.h"
-#include "native/include/java_lang_Class.h" /* for java_lang_VMClass.h */
-#include "native/include/java_lang_VMClass.h"
-#include "native/include/java_lang_VMClassLoader.h"
-#include "native/include/java_nio_Buffer.h"
-#include "native/include/java_nio_DirectByteBufferImpl.h"
+#if defined(ENABLE_JAVASE)
+# include "native/include/java_lang_ClassLoader.h"
+
+# include "native/include/java_lang_reflect_Constructor.h"
+# include "native/include/java_lang_reflect_Field.h"
+# include "native/include/java_lang_reflect_Method.h"
+
+# include "native/include/java_nio_Buffer.h"
+# include "native/include/java_nio_DirectByteBufferImpl.h"
+#endif
#if defined(ENABLE_JVMTI)
-# include "native/jvmti/jvmti.h"
+# include "native/jvmti/cacaodbg.h"
#endif
-#if defined(USE_THREADS)
-# if defined(NATIVE_THREADS)
-# include "threads/native/threads.h"
-# else
-# include "threads/green/threads.h"
-# endif
+#include "native/vm/java_lang_Class.h"
+
+#if defined(ENABLE_JAVASE)
+# include "native/vm/java_lang_ClassLoader.h"
+#endif
+
+#if defined(ENABLE_THREADS)
+# include "threads/native/lock.h"
+# include "threads/native/threads.h"
+#else
+# include "threads/none/lock.h"
+# include "threads/none/threads.h"
#endif
#include "toolbox/logging.h"
+
#include "vm/builtin.h"
#include "vm/exceptions.h"
#include "vm/global.h"
#include "vm/initialize.h"
-#include "vm/loader.h"
-#include "vm/options.h"
-#include "vm/resolve.h"
-#include "vm/statistics.h"
#include "vm/stringlocal.h"
+#include "vm/vm.h"
+
#include "vm/jit/asmpart.h"
#include "vm/jit/jit.h"
-#include "vm/statistics.h"
+#include "vm/jit/stacktrace.h"
+#include "vmcore/loader.h"
+#include "vmcore/options.h"
+#include "vmcore/resolve.h"
+#include "vmcore/statistics.h"
-/* XXX TWISTI hack: define it extern so they can be found in this file */
-
-extern const struct JNIInvokeInterface JNI_JavaVMTable;
-extern struct JNINativeInterface JNI_JNIEnvTable;
-
-/* pointers to VM and the environment needed by GetJavaVM and GetEnv */
-
-static JavaVM ptr_jvm = (JavaVM) &JNI_JavaVMTable;
-void *ptr_env = (void*) &JNI_JNIEnvTable;
-
-
-#define PTR_TO_ITEM(ptr) ((u8)(size_t)(ptr))
/* global variables ***********************************************************/
/* global reference table *****************************************************/
-static java_objectheader **global_ref_table;
+/* hashsize must be power of 2 */
+
+#define HASHTABLE_GLOBAL_REF_SIZE 64 /* initial size of globalref-hash */
-/* jmethodID and jclass caching variables for NewGlobalRef and DeleteGlobalRef*/
-static classinfo *ihmclass = NULL;
-static methodinfo *putmid = NULL;
-static methodinfo *getmid = NULL;
-static methodinfo *removemid = NULL;
+static hashtable *hashtable_global_ref; /* hashtable for globalrefs */
/* direct buffer stuff ********************************************************/
+#if defined(ENABLE_JAVASE)
static classinfo *class_java_nio_Buffer;
static classinfo *class_java_nio_DirectByteBufferImpl;
static classinfo *class_java_nio_DirectByteBufferImpl_ReadWrite;
-#if SIZEOF_VOID_P == 8
+
+# if defined(WITH_CLASSPATH_GNU)
+# if SIZEOF_VOID_P == 8
static classinfo *class_gnu_classpath_Pointer64;
-#else
+# else
static classinfo *class_gnu_classpath_Pointer32;
-#endif
+# endif
+# endif
static methodinfo *dbbirw_init;
+#endif
/* local reference table ******************************************************/
-#if !defined(USE_THREADS)
+#if !defined(ENABLE_THREADS)
localref_table *_no_threads_localref_table;
#endif
/* accessing instance fields macros *******************************************/
-#define SET_FIELD(obj,type,var,value) \
- *((type *) ((ptrint) (obj) + (ptrint) (var)->offset)) = (type) (value)
+#define SET_FIELD(o,type,f,value) \
+ *((type *) ((ptrint) (o) + (ptrint) ((fieldinfo *) (f))->offset)) = (type) (value)
-#define GET_FIELD(obj,type,var) \
- *((type *) ((ptrint) (obj) + (ptrint) (var)->offset))
+#define GET_FIELD(o,type,f) \
+ *((type *) ((ptrint) (o) + (ptrint) ((fieldinfo *) (f))->offset))
/* some forward declarations **************************************************/
-jobject NewLocalRef(JNIEnv *env, jobject ref);
+jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref);
+jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity);
/* jni_init ********************************************************************
bool jni_init(void)
{
- /* initalize global reference table */
-
- if (!(ihmclass =
- load_class_bootstrap(utf_new_char("java/util/IdentityHashMap"))))
- return false;
-
- global_ref_table = GCNEW(jobject);
-
- if (!(*global_ref_table = native_new_and_init(ihmclass)))
- return false;
+ /* create global ref hashtable */
- if (!(getmid = class_resolvemethod(ihmclass, utf_get,
- utf_java_lang_Object__java_lang_Object)))
- return false;
-
- if (!(putmid = class_resolvemethod(ihmclass, utf_put,
- utf_new_char("(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"))))
- return false;
+ hashtable_global_ref = NEW(hashtable);
- if (!(removemid =
- class_resolvemethod(ihmclass, utf_remove,
- utf_java_lang_Object__java_lang_Object)))
- return false;
+ hashtable_create(hashtable_global_ref, HASHTABLE_GLOBAL_REF_SIZE);
+#if defined(ENABLE_JAVASE)
/* direct buffer stuff */
if (!(class_java_nio_Buffer =
utf_new_char("(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V"))))
return false;
-#if SIZEOF_VOID_P == 8
+# if defined(WITH_CLASSPATH_GNU)
+# if SIZEOF_VOID_P == 8
if (!(class_gnu_classpath_Pointer64 =
load_class_bootstrap(utf_new_char("gnu/classpath/Pointer64"))) ||
!link_class(class_gnu_classpath_Pointer64))
return false;
-#else
+# else
if (!(class_gnu_classpath_Pointer32 =
load_class_bootstrap(utf_new_char("gnu/classpath/Pointer32"))) ||
!link_class(class_gnu_classpath_Pointer32))
return false;
-#endif
+# endif
+# endif
+#endif /* defined(ENABLE_JAVASE) */
return true;
}
-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 */
+/* jni_init_localref_table *****************************************************
- i = 0;
+ Initializes the local references table of the current thread.
- if (obj != NULL) {
- /* the `this' pointer */
- blk[0].itemtype = TYPE_ADR;
- blk[0].item = PTR_TO_ITEM(obj);
+*******************************************************************************/
- paramtypes++;
- i++;
- }
+bool jni_init_localref_table(void)
+{
+ localref_table *lrt;
- 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;
+ lrt = GCNEW(localref_table);
- case PRIMITIVETYPE_INT:
- blk[i].itemtype = TYPE_INT;
- blk[i].item = (s8) va_arg(data, s4);
- break;
+ if (lrt == NULL)
+ return false;
- case PRIMITIVETYPE_LONG:
- blk[i].itemtype = TYPE_LNG;
- blk[i].item = (s8) va_arg(data, s8);
- break;
+ lrt->capacity = LOCALREFTABLE_CAPACITY;
+ lrt->used = 0;
+ lrt->localframes = 1;
+ lrt->prev = LOCALREFTABLE;
- case PRIMITIVETYPE_FLOAT:
- blk[i].itemtype = TYPE_FLT;
-#if defined(__ALPHA__)
- /* this keeps the assembler function much simpler */
+ /* clear the references array (memset is faster then a for-loop) */
- *((jdouble *) (&blk[i].item)) = (jdouble) va_arg(data, jdouble);
-#else
- *((jfloat *) (&blk[i].item)) = (jfloat) va_arg(data, jdouble);
-#endif
- break;
+ MSET(lrt->refs, 0, java_objectheader*, LOCALREFTABLE_CAPACITY);
- case PRIMITIVETYPE_DOUBLE:
- blk[i].itemtype = TYPE_DBL;
- *((jdouble *) (&blk[i].item)) = (jdouble) va_arg(data, jdouble);
- break;
+ LOCALREFTABLE = lrt;
- case TYPE_ADR:
- blk[i].itemtype = TYPE_ADR;
- blk[i].item = PTR_TO_ITEM(va_arg(data, void*));
- break;
- }
- }
+ return true;
+}
- /* The standard doesn't say anything about return value checking,
- but it appears to be useful. */
- if (rettype != descr->returntype.decltype)
- log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
-}
+/* _Jv_jni_vmargs_from_objectarray *********************************************
+ 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)
{
- jobject param;
- s4 paramcount;
- typedesc *paramtypes;
- classinfo *c;
- s4 i;
- s4 j;
+ java_objectheader *param;
+ s4 paramcount;
+ typedesc *paramtypes;
+ classinfo *c;
+ s4 i;
+ s4 j;
+ s8 value;
paramcount = descr->paramcount;
paramtypes = descr->paramtypes;
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.l = (u8) (ptrint) o;
paramtypes++;
paramcount--;
switch (paramtypes->type) {
/* primitive types */
case TYPE_INT:
- case TYPE_LONG:
- case TYPE_FLOAT:
- case TYPE_DOUBLE:
+ case TYPE_LNG:
+ case TYPE_FLT:
+ case TYPE_DBL:
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;
+ value = (s8) ((java_lang_Boolean *) param)->value;
else
goto illegal_arg;
+
+ vmargs[i].data.l = value;
break;
case PRIMITIVETYPE_BYTE:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ value = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
+
+ vmargs[i].data.l = value;
break;
case PRIMITIVETYPE_CHAR:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Character *) param)->value;
+ value = (s8) ((java_lang_Character *) param)->value;
else
goto illegal_arg;
+
+ vmargs[i].data.l = value;
break;
case PRIMITIVETYPE_SHORT:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Short *) param)->value;
+ value = (s8) ((java_lang_Short *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ value = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
+
+ vmargs[i].data.l = value;
break;
case PRIMITIVETYPE_INT:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Integer *) param)->value;
+ value = (s8) ((java_lang_Integer *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
- blk[i].item = (s8) ((java_lang_Short *) param)->value;
+ value = (s8) ((java_lang_Short *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ value = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
+
+ vmargs[i].data.l = value;
break;
case PRIMITIVETYPE_LONG:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- blk[i].item = (s8) ((java_lang_Long *) param)->value;
+ value = (s8) ((java_lang_Long *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_INT].class_wrap)
- blk[i].item = (s8) ((java_lang_Integer *) param)->value;
+ value = (s8) ((java_lang_Integer *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
- blk[i].item = (s8) ((java_lang_Short *) param)->value;
+ value = (s8) ((java_lang_Short *) param)->value;
else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
- blk[i].item = (s8) ((java_lang_Byte *) param)->value;
+ value = (s8) ((java_lang_Byte *) param)->value;
else
goto illegal_arg;
+
+ vmargs[i].data.l = value;
break;
case PRIMITIVETYPE_FLOAT:
if (c == primitivetype_table[paramtypes->decltype].class_wrap)
- *((jfloat *) (&blk[i].item)) = (jfloat) ((java_lang_Float *) param)->value;
+ vmargs[i].data.f = (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;
+ vmargs[i].data.d = (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;
+ vmargs[i].data.f = (jfloat) ((java_lang_Float *) param)->value;
else
goto illegal_arg;
break;
default:
goto illegal_arg;
- } /* end declared type switch */
+ }
break;
- case TYPE_ADDRESS:
+ case TYPE_ADR:
if (!resolve_class_from_typedesc(paramtypes, true, true, &c))
return false;
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.l = (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());
- dumpsize = dump_size();
+ ro = vm_call_method_valist(resm, o, ap);
- paramcount = resm->parseddesc->paramcount;
+ return ro;
+}
- blk = DMNEW(jni_callblock, paramcount);
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap, TYPE_ADR);
+/* _Jv_jni_CallObjectMethodA ***************************************************
- STATISTICS(jnicallXmethodnvokation());
+ Internal function to call Java Object methods.
+
+*******************************************************************************/
+
+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. */
- ASM_CALLJAVAFUNCTION2_ADR(ret, resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
+ resm = method_vftbl_lookup(vftbl, m);
+ }
- /* release dump area */
+ STATISTICS(jnicallXmethodnvokation());
- dump_release(dumpsize);
+ ro = vm_call_method_jvalue(resm, o, args);
- return ret;
+ 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 */
+ STATISTICS(jnicallXmethodnvokation());
+
+ i = vm_call_method_int_valist(resm, o, ap);
+
+ return i;
+}
- dumpsize = dump_size();
- paramcount = resm->parseddesc->paramcount;
+/* _Jv_jni_CallIntMethodA ******************************************************
- blk = DMNEW(jni_callblock, paramcount);
+ Internal function to call Java integer class methods (boolean,
+ byte, char, short, int).
- fill_callblock_from_vargs(o, resm->parseddesc, blk, ap, type);
+*******************************************************************************/
- STATISTICS(jnicallXmethodnvokation());
+static jint _Jv_jni_CallIntMethodA(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, jvalue *args)
+{
+ methodinfo *resm;
+ jint i;
+
+ STATISTICS(jniinvokation());
+
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return 0;
+ }
+
+ /* 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. */
- ASM_CALLJAVAFUNCTION2_INT(ret, resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
+ resm = method_vftbl_lookup(vftbl, m);
+ }
- /* release dump area */
+ STATISTICS(jnicallXmethodnvokation());
- dump_release(dumpsize);
+ i = vm_call_method_int_jvalue(resm, o, args);
- 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 */
+ f = vm_call_method_float_valist(resm, o, ap);
- dump_release(dumpsize);
-
- 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;
+
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return;
+ }
+
+ /* 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. */
- ASM_CALLJAVAFUNCTION2(resm, paramcount,
- paramcount * sizeof(jni_callblock),
- blk);
+ resm = method_vftbl_lookup(vftbl, m);
+ }
- /* release dump area */
+ STATISTICS(jnicallXmethodnvokation());
- dump_release(dumpsize);
+ (void) vm_call_method_jvalue(resm, o, args);
}
*******************************************************************************/
-jobject *_Jv_jni_invokeNative(methodinfo *m, jobject obj,
- java_objectarray *params)
+java_objectheader *_Jv_jni_invokeNative(methodinfo *m, java_objectheader *o,
+ java_objectarray *params)
{
methodinfo *resm;
- jni_callblock *blk;
- java_objectheader *o;
+ vm_arg *vmargs;
+ java_objectheader *ro;
s4 argcount;
s4 paramcount;
+ java_objectheader *xptr;
- if (!m) {
+ if (m == NULL) {
exceptions_throw_nullpointerexception();
return NULL;
}
if (!(m->flags & ACC_STATIC))
paramcount--;
- /* For instance methods the object has to be an instance of the */
- /* class the method belongs to. For static methods the obj parameter */
- /* is ignored. */
+ /* For instance methods the object has to be an instance of the
+ class the method belongs to. For static methods the obj
+ parameter is ignored. */
- if (!(m->flags & ACC_STATIC) && obj &&
- (!builtin_instanceof((java_objectheader *) obj, m->class)))
- {
- *exceptionptr =
- new_exception_message(string_java_lang_IllegalArgumentException,
- "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
+ if (!(m->flags & ACC_STATIC) && o && (!builtin_instanceof(o, m->class))) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
if (((params == NULL) && (paramcount != 0)) ||
(params && (params->header.size != paramcount)))
{
- *exceptionptr =
- new_exception(string_java_lang_IllegalArgumentException);
+ exceptions_throw_illegalargumentexception();
return NULL;
}
/* for instance methods we need an object */
- if (!(m->flags & ACC_STATIC) && !obj)
- {
- *exceptionptr =
- new_exception_message(string_java_lang_NullPointerException,
- "Static mismatch in Java_java_lang_reflect_Method_invokeNative");
+ if (!(m->flags & ACC_STATIC) && (o == NULL)) {
+ /* XXX not sure if that is the correct exception */
+ exceptions_throw_nullpointerexception();
return NULL;
}
- /* for static methods, zero obj to make subsequent code simpler */
+ /* for static methods, zero object to make subsequent code simpler */
if (m->flags & ACC_STATIC)
- obj = NULL;
+ o = NULL;
- if (obj) {
+ if (o != NULL) {
/* for instance methods we must do a vftbl lookup */
- resm = method_vftbl_lookup(obj->vftbl, m);
- }
+ resm = method_vftbl_lookup(o->vftbl, m);
+ }
else {
/* for static methods, just for convenience */
resm = m;
}
- blk = MNEW(jni_callblock, argcount);
+ vmargs = MNEW(vm_arg, argcount);
- if (!fill_callblock_from_objectarray(obj, 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);
- o = NULL;
+ ro = NULL;
break;
case PRIMITIVETYPE_BOOLEAN: {
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);
- o = builtin_new(class_java_lang_Boolean);
+ ro = builtin_new(class_java_lang_Boolean);
/* setting the value of the object direct */
- bo = (java_lang_Boolean *) o;
+ bo = (java_lang_Boolean *) ro;
bo->value = i;
}
break;
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);
- o = builtin_new(class_java_lang_Byte);
+ ro = builtin_new(class_java_lang_Byte);
/* setting the value of the object direct */
- bo = (java_lang_Byte *) o;
+ bo = (java_lang_Byte *) ro;
bo->value = i;
}
break;
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);
- o = builtin_new(class_java_lang_Character);
+ ro = builtin_new(class_java_lang_Character);
/* setting the value of the object direct */
- co = (java_lang_Character *) o;
+ co = (java_lang_Character *) ro;
co->value = i;
}
break;
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);
- o = builtin_new(class_java_lang_Short);
+ ro = builtin_new(class_java_lang_Short);
/* setting the value of the object direct */
- so = (java_lang_Short *) o;
+ so = (java_lang_Short *) ro;
so->value = i;
}
break;
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);
- o = builtin_new(class_java_lang_Integer);
+ ro = builtin_new(class_java_lang_Integer);
/* setting the value of the object direct */
- io = (java_lang_Integer *) o;
+ io = (java_lang_Integer *) ro;
io->value = i;
}
break;
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);
- o = builtin_new(class_java_lang_Long);
+ ro = builtin_new(class_java_lang_Long);
/* setting the value of the object direct */
- lo = (java_lang_Long *) o;
+ lo = (java_lang_Long *) ro;
lo->value = l;
}
break;
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);
- o = builtin_new(class_java_lang_Float);
+ ro = builtin_new(class_java_lang_Float);
/* setting the value of the object direct */
- fo = (java_lang_Float *) o;
+ fo = (java_lang_Float *) ro;
fo->value = f;
}
break;
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);
- o = builtin_new(class_java_lang_Double);
+ ro = builtin_new(class_java_lang_Double);
/* setting the value of the object direct */
- _do = (java_lang_Double *) o;
+ _do = (java_lang_Double *) ro;
_do->value = d;
}
break;
case TYPE_ADR:
- ASM_CALLJAVAFUNCTION2_ADR(o, 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 (jobject *) 0;
+ return NULL;
}
- MFREE(blk, jni_callblock, argcount);
+ MFREE(vmargs, vm_arg, argcount);
- if (*exceptionptr) {
- java_objectheader *cause;
-
- cause = *exceptionptr;
+ xptr = exceptions_get_exception();
+ if (xptr != NULL) {
/* clear exception pointer, we are calling JIT code again */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
- *exceptionptr =
- new_exception_throwable(string_java_lang_reflect_InvocationTargetException,
- (java_lang_Throwable *) cause);
+ exceptions_throw_invocationtargetexception(xptr);
}
- return (jobject *) o;
+ return ro;
}
*******************************************************************************/
-jint GetVersion(JNIEnv *env)
+jint _Jv_JNI_GetVersion(JNIEnv *env)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jclass DefineClass(JNIEnv *env, const char *name, jobject loader,
- const jbyte *buf, jsize bufLen)
+jclass _Jv_JNI_DefineClass(JNIEnv *env, const char *name, jobject loader,
+ const jbyte *buf, jsize bufLen)
{
+#if defined(ENABLE_JAVASE)
java_lang_ClassLoader *cl;
java_lang_String *s;
java_bytearray *ba;
STATISTICS(jniinvokation());
cl = (java_lang_ClassLoader *) loader;
- s = javastring_new_char(name);
+ s = javastring_new_from_utf_string(name);
ba = (java_bytearray *) buf;
- c = (jclass) Java_java_lang_VMClassLoader_defineClass(env, NULL, cl, s, ba,
- 0, bufLen, NULL);
+ c = (jclass) _Jv_java_lang_ClassLoader_defineClass(cl, s, ba, 0, bufLen,
+ NULL);
+
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
+#else
+ vm_abort("_Jv_JNI_DefineClass: not implemented in this configuration");
+
+ /* keep compiler happy */
- return (jclass) NewLocalRef(env, (jobject) c);
+ return 0;
+#endif
}
*******************************************************************************/
-jclass FindClass(JNIEnv *env, const char *name)
+jclass _Jv_JNI_FindClass(JNIEnv *env, const char *name)
{
- utf *u;
- classinfo *c;
- java_objectheader *cl;
+#if defined(ENABLE_JAVASE)
+ utf *u;
+ classinfo *cc;
+ classinfo *c;
STATISTICS(jniinvokation());
u = utf_new_char_classname((char *) name);
/* Check stacktrace for classloader, if one found use it,
- otherwise use the system classloader. */
-
-#if defined(__ALPHA__) || defined(__ARM__) || defined(__I386__) || defined(__MIPS__) || defined(__POWERPC__) || defined(__X86_64__)
- /* these JITs support stacktraces, and so does the interpreter */
-
- cl = stacktrace_getCurrentClassLoader();
-#else
-# if defined(ENABLE_INTRP)
- /* the interpreter supports stacktraces, even if the JIT does not */
-
- if (opt_intrp)
- cl = stacktrace_getCurrentClassLoader();
+ otherwise use the system classloader. */
+
+ /* Quote from the JNI documentation:
+
+ In the Java 2 Platform, FindClass locates the class loader
+ associated with the current native method. If the native code
+ belongs to a system class, no class loader will be
+ involved. Otherwise, the proper class loader will be invoked to
+ load and link the named class. When FindClass is called through
+ the Invocation Interface, there is no current native method or
+ its associated class loader. In that case, the result of
+ ClassLoader.getBaseClassLoader is used." */
+
+ cc = stacktrace_getCurrentClass();
+
+ if (cc == NULL)
+ c = load_class_from_sysloader(u);
else
-# endif
- cl = NULL;
-#endif
+ c = load_class_from_classloader(u, cc->classloader);
- if (!(c = load_class_from_classloader(u, cl)))
+ if (c == NULL)
return NULL;
if (!link_class(c))
return NULL;
- return (jclass) NewLocalRef(env, (jobject) c);
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
+#else
+ vm_abort("_Jv_JNI_FindClass: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
-/* FromReflectedMethod *********************************************************
+/* GetSuperclass ***************************************************************
+
+ If clazz represents any class other than the class Object, then
+ this function returns the object that represents the superclass of
+ the class specified by clazz.
- Converts java.lang.reflect.Method or java.lang.reflect.Constructor
- object to a method ID.
-
*******************************************************************************/
-
-jmethodID FromReflectedMethod(JNIEnv *env, jobject method)
-{
- methodinfo *mi;
- classinfo *c;
- s4 slot;
-
- STATISTICS(jniinvokation());
-
- if (method == NULL)
- return NULL;
-
- if (builtin_instanceof(method, class_java_lang_reflect_Method)) {
- java_lang_reflect_Method *rm;
-
- rm = (java_lang_reflect_Method *) method;
- c = (classinfo *) (rm->declaringClass);
- slot = rm->slot;
-
- } else if (builtin_instanceof(method, class_java_lang_reflect_Constructor)) {
- java_lang_reflect_Constructor *rc;
-
- rc = (java_lang_reflect_Constructor *) method;
- c = (classinfo *) (rc->clazz);
- slot = rc->slot;
-
- } else
- return NULL;
-
- if ((slot < 0) || (slot >= c->methodscount)) {
- /* this usually means a severe internal cacao error or somebody
- tempered around with the reflected method */
- log_text("error illegal slot for method in class(FromReflectedMethod)");
- assert(0);
- }
-
- mi = &(c->methods[slot]);
-
- return mi;
-}
-
-
-/* GetSuperclass ***************************************************************
-
- If clazz represents any class other than the class Object, then
- this function returns the object that represents the superclass of
- the class specified by clazz.
-
-*******************************************************************************/
-
-jclass GetSuperclass(JNIEnv *env, jclass sub)
+
+jclass _Jv_JNI_GetSuperclass(JNIEnv *env, jclass sub)
{
classinfo *c;
if (!c)
return NULL;
- return (jclass) NewLocalRef(env, (jobject) c);
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
}
*******************************************************************************/
-jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
+jboolean _Jv_JNI_IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
{
+ java_lang_Class *csup;
+ java_lang_Class *csub;
+
+ csup = (java_lang_Class *) sup;
+ csub = (java_lang_Class *) sub;
+
STATISTICS(jniinvokation());
- return Java_java_lang_VMClass_isAssignableFrom(env,
- NULL,
- (java_lang_Class *) sup,
- (java_lang_Class *) sub);
+ return _Jv_java_lang_Class_isAssignableFrom(csup, csub);
}
*******************************************************************************/
-jint Throw(JNIEnv *env, jthrowable obj)
+jint _Jv_JNI_Throw(JNIEnv *env, jthrowable obj)
{
+ java_objectheader *o;
+
STATISTICS(jniinvokation());
- *exceptionptr = (java_objectheader *) obj;
+ o = (java_objectheader *) obj;
+
+ exceptions_set_exception(o);
return JNI_OK;
}
*******************************************************************************/
-jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
+jint _Jv_JNI_ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
{
- java_lang_Throwable *o;
- java_lang_String *s;
+ classinfo *c;
+ java_objectheader *o;
+ java_objectheader *s;
STATISTICS(jniinvokation());
- s = (java_lang_String *) javastring_new_char(msg);
+ c = (classinfo *) clazz;
+ s = javastring_new_from_utf_string(msg);
/* instantiate exception object */
- o = (java_lang_Throwable *) native_new_and_init_string((classinfo *) clazz,
- s);
+ o = native_new_and_init_string(c, s);
- if (!o)
+ if (o == NULL)
return -1;
- *exceptionptr = (java_objectheader *) o;
+ exceptions_set_exception(o);
return 0;
}
*******************************************************************************/
-jthrowable ExceptionOccurred(JNIEnv *env)
+jthrowable _Jv_JNI_ExceptionOccurred(JNIEnv *env)
{
- java_objectheader *e;
+ java_objectheader *o;
STATISTICS(jniinvokation());
- e = *exceptionptr;
+ o = exceptions_get_exception();
- return NewLocalRef(env, (jthrowable) e);
+ return _Jv_JNI_NewLocalRef(env, (jthrowable) o);
}
*******************************************************************************/
-void ExceptionDescribe(JNIEnv *env)
+void _Jv_JNI_ExceptionDescribe(JNIEnv *env)
{
- java_objectheader *e;
+ java_objectheader *o;
methodinfo *m;
STATISTICS(jniinvokation());
- e = *exceptionptr;
+ o = exceptions_get_exception();
- if (e) {
+ if (o == NULL) {
/* clear exception, because we are calling jit code again */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
/* get printStackTrace method from exception class */
- m = class_resolveclassmethod(e->vftbl->class,
+ m = class_resolveclassmethod(o->vftbl->class,
utf_printStackTrace,
utf_void__void,
NULL,
true);
- if (!m)
+ if (m == NULL)
/* XXX what should we do? */
return;
/* print the stacktrace */
- ASM_CALLJAVAFUNCTION(m, e, NULL, NULL, NULL);
+ (void) vm_call_method(m, o);
}
}
*******************************************************************************/
-void ExceptionClear(JNIEnv *env)
+void _Jv_JNI_ExceptionClear(JNIEnv *env)
{
STATISTICS(jniinvokation());
- *exceptionptr = NULL;
+ exceptions_clear_exception();
}
*******************************************************************************/
-void FatalError(JNIEnv *env, const char *msg)
+void _Jv_JNI_FatalError(JNIEnv *env, const char *msg)
{
STATISTICS(jniinvokation());
- throw_cacao_exception_exit(string_java_lang_InternalError, msg);
+ /* this seems to be the best way */
+
+ vm_abort(msg);
}
*******************************************************************************/
-jint PushLocalFrame(JNIEnv* env, jint capacity)
+jint _Jv_JNI_PushLocalFrame(JNIEnv* env, jint capacity)
{
+ s4 additionalrefs;
+ localref_table *lrt;
+ localref_table *nlrt;
+
STATISTICS(jniinvokation());
- log_text("JNI-Call: PushLocalFrame: IMPLEMENT ME!");
+ if (capacity <= 0)
+ return -1;
+
+ /* Allocate new local reference table on Java heap. Calculate the
+ additional memory we have to allocate. */
- assert(0);
+ if (capacity > LOCALREFTABLE_CAPACITY)
+ additionalrefs = capacity - LOCALREFTABLE_CAPACITY;
+ else
+ additionalrefs = 0;
+
+ nlrt = GCMNEW(u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P);
+
+ if (nlrt == NULL)
+ return -1;
+
+ /* get current local reference table from thread */
+
+ lrt = LOCALREFTABLE;
+
+ /* Set up the new local reference table and add it to the local
+ frames chain. */
+
+ nlrt->capacity = capacity;
+ nlrt->used = 0;
+ nlrt->localframes = lrt->localframes + 1;
+ nlrt->prev = lrt;
+
+ /* store new local reference table in thread */
+
+ LOCALREFTABLE = nlrt;
return 0;
}
+
/* PopLocalFrame ***************************************************************
Pops off the current local reference frame, frees all the local
*******************************************************************************/
-jobject PopLocalFrame(JNIEnv* env, jobject result)
+jobject _Jv_JNI_PopLocalFrame(JNIEnv* env, jobject result)
{
+ localref_table *lrt;
+ localref_table *plrt;
+ s4 localframes;
+
STATISTICS(jniinvokation());
- log_text("JNI-Call: PopLocalFrame: IMPLEMENT ME!");
+ /* get current local reference table from thread */
- assert(0);
+ lrt = LOCALREFTABLE;
+
+ localframes = lrt->localframes;
+
+ /* Don't delete the top local frame, as this one is allocated in
+ the native stub on the stack and is freed automagically on
+ return. */
+
+ if (localframes == 1)
+ return _Jv_JNI_NewLocalRef(env, result);
+
+ /* release all current local frames */
+
+ for (; localframes >= 1; localframes--) {
+ /* get previous frame */
+
+ plrt = lrt->prev;
+
+ /* clear all reference entries */
+
+ MSET(&lrt->refs[0], 0, java_objectheader*, lrt->capacity);
+
+ lrt->prev = NULL;
+
+ /* set new local references table */
+
+ lrt = plrt;
+ }
+
+ /* store new local reference table in thread */
+
+ LOCALREFTABLE = lrt;
/* add local reference and return the value */
- return NewLocalRef(env, NULL);
+ return _Jv_JNI_NewLocalRef(env, result);
}
*******************************************************************************/
-void DeleteLocalRef(JNIEnv *env, jobject localRef)
+void _Jv_JNI_DeleteLocalRef(JNIEnv *env, jobject localRef)
{
java_objectheader *o;
localref_table *lrt;
lrt = LOCALREFTABLE;
- /* remove the reference */
+ /* go through all local frames */
- for (i = 0; i < lrt->capacity; i++) {
- if (lrt->refs[i] == o) {
- lrt->refs[i] = NULL;
- lrt->used--;
+ for (; lrt != NULL; lrt = lrt->prev) {
- return;
+ /* and try to remove the reference */
+
+ for (i = 0; i < lrt->capacity; i++) {
+ if (lrt->refs[i] == o) {
+ lrt->refs[i] = NULL;
+ lrt->used--;
+
+ return;
+ }
}
}
/* if (opt_checkjni) */
/* FatalError(env, "Bad global or local ref passed to JNI"); */
- log_text("JNI-DeleteLocalRef: Bad global or local ref passed to JNI");
+ log_text("JNI-DeleteLocalRef: Local ref passed to JNI not found");
}
*******************************************************************************/
-jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
+jboolean _Jv_JNI_IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jobject NewLocalRef(JNIEnv *env, jobject ref)
+jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref)
{
localref_table *lrt;
s4 i;
lrt = LOCALREFTABLE;
- /* check if we have space for the requested reference */
+ /* Check if we have space for the requested reference? No,
+ allocate a new frame. This is actually not what the spec says,
+ but for compatibility reasons... */
if (lrt->used == lrt->capacity) {
-/* throw_cacao_exception_exit(string_java_lang_InternalError, */
-/* "Too many local references"); */
- fprintf(stderr, "Too many local references");
- assert(0);
+ if (_Jv_JNI_EnsureLocalCapacity(env, 16) != 0)
+ return NULL;
+
+ /* get the new local reference table */
+
+ lrt = LOCALREFTABLE;
}
/* insert the reference */
*******************************************************************************/
-jint EnsureLocalCapacity(JNIEnv* env, jint capacity)
+jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity)
{
localref_table *lrt;
/* check if capacity elements are available in the local references table */
- if ((lrt->used + capacity) > lrt->capacity) {
- *exceptionptr = new_exception(string_java_lang_OutOfMemoryError);
- return -1;
- }
+ if ((lrt->used + capacity) > lrt->capacity)
+ return _Jv_JNI_PushLocalFrame(env, capacity);
return 0;
}
*******************************************************************************/
-jobject AllocObject(JNIEnv *env, jclass clazz)
+jobject _Jv_JNI_AllocObject(JNIEnv *env, jclass clazz)
{
+ classinfo *c;
java_objectheader *o;
STATISTICS(jniinvokation());
- if ((clazz->flags & ACC_INTERFACE) || (clazz->flags & ACC_ABSTRACT)) {
- *exceptionptr =
- new_exception_utfmessage(string_java_lang_InstantiationException,
- clazz->name);
+ c = (classinfo *) clazz;
+
+ if ((c->flags & ACC_INTERFACE) || (c->flags & ACC_ABSTRACT)) {
+ exceptions_throw_instantiationexception(c);
return NULL;
}
- o = builtin_new(clazz);
+ o = builtin_new(c);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
*******************************************************************************/
-jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jobject _Jv_JNI_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
java_objectheader *o;
+ methodinfo *m;
va_list ap;
STATISTICS(jniinvokation());
+ m = (methodinfo *) methodID;
+
/* create object */
o = builtin_new(clazz);
- if (!o)
+ if (o == NULL)
return NULL;
/* call constructor */
va_start(ap, methodID);
- _Jv_jni_CallVoidMethod(o, o->vftbl, methodID, ap);
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap);
va_end(ap);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
*******************************************************************************/
-jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
+jobject _Jv_JNI_NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
+ methodinfo *m;
STATISTICS(jniinvokation());
+ m = (methodinfo *) methodID;
+
/* create object */
o = builtin_new(clazz);
- if (!o)
+ if (o == NULL)
return NULL;
/* call constructor */
- _Jv_jni_CallVoidMethod(o, o->vftbl, methodID, args);
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, args);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-/***********************************************************************************
+/* 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)
+jobject _Jv_JNI_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 _Jv_JNI_NewLocalRef(env, o);
}
*******************************************************************************/
-jclass GetObjectClass(JNIEnv *env, jobject obj)
+jclass _Jv_JNI_GetObjectClass(JNIEnv *env, jobject obj)
{
- classinfo *c;
+ java_objectheader *o;
+ classinfo *c;
STATISTICS(jniinvokation());
-
- if (!obj || !obj->vftbl)
+
+ o = (java_objectheader *) obj;
+
+ if ((o == NULL) || (o->vftbl == NULL))
return NULL;
- c = obj->vftbl->class;
+ c = o->vftbl->class;
- return (jclass) NewLocalRef(env, (jobject) c);
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
}
*******************************************************************************/
-jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
+jboolean _Jv_JNI_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
{
+ java_lang_Class *c;
+ java_lang_Object *o;
+
STATISTICS(jniinvokation());
- return Java_java_lang_VMClass_isInstance(env,
- NULL,
- (java_lang_Class *) clazz,
- (java_lang_Object *) obj);
+ c = (java_lang_Class *) clazz;
+ o = (java_lang_Object *) obj;
+
+ return _Jv_java_lang_Class_isInstance(c, o);
}
-/***************** converts a java.lang.reflect.Field to a field ID ***************/
-
-jfieldID FromReflectedField(JNIEnv* env, jobject field)
+/* Reflection Support *********************************************************/
+
+/* FromReflectedMethod *********************************************************
+
+ Converts java.lang.reflect.Method or java.lang.reflect.Constructor
+ object to a method ID.
+
+*******************************************************************************/
+
+jmethodID _Jv_JNI_FromReflectedMethod(JNIEnv *env, jobject method)
{
- java_lang_reflect_Field *f;
- classinfo *c;
- jfieldID fid; /* the JNI-fieldid of the wrapping object */
+#if defined(ENABLE_JAVASE)
+ methodinfo *mi;
+ classinfo *c;
+ s4 slot;
STATISTICS(jniinvokation());
- /*log_text("JNI-Call: FromReflectedField");*/
+ if (method == NULL)
+ return NULL;
+
+ if (builtin_instanceof(method, class_java_lang_reflect_Method)) {
+ java_lang_reflect_Method *rm;
+
+ rm = (java_lang_reflect_Method *) method;
+ c = (classinfo *) (rm->declaringClass);
+ slot = rm->slot;
+ }
+ else if (builtin_instanceof(method, class_java_lang_reflect_Constructor)) {
+ java_lang_reflect_Constructor *rc;
- f=(java_lang_reflect_Field *)field;
- if (f==0) return 0;
- c=(classinfo*)(f->declaringClass);
- if ( (f->slot<0) || (f->slot>=c->fieldscount)) {
- /*this usually means a severe internal cacao error or somebody
- tempered around with the reflected method*/
- log_text("error illegal slot for field in class(FromReflectedField)");
- assert(0);
+ rc = (java_lang_reflect_Constructor *) method;
+ c = (classinfo *) (rc->clazz);
+ slot = rc->slot;
}
- fid=&(c->fields[f->slot]);
- return fid;
+ else
+ return NULL;
+
+ mi = &(c->methods[slot]);
+
+ return (jmethodID) mi;
+#else
+ vm_abort("_Jv_JNI_FromReflectedMethod: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
+}
+
+
+/* FromReflectedField **********************************************************
+
+ Converts a java.lang.reflect.Field to a field ID.
+
+*******************************************************************************/
+
+jfieldID _Jv_JNI_FromReflectedField(JNIEnv* env, jobject field)
+{
+#if defined(ENABLE_JAVASE)
+ java_lang_reflect_Field *rf;
+ classinfo *c;
+ fieldinfo *f;
+
+ STATISTICS(jniinvokation());
+
+ rf = (java_lang_reflect_Field *) field;
+
+ if (rf == NULL)
+ return NULL;
+
+ c = (classinfo *) rf->declaringClass;
+
+ f = &(c->fields[rf->slot]);
+
+ return (jfieldID) f;
+#else
+ vm_abort("_Jv_JNI_FromReflectedField: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
+jobject _Jv_JNI_ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID,
+ jboolean isStatic)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
- jboolean isStatic)
+jobject _Jv_JNI_ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
+ jboolean isStatic)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name,
- const char *sig)
+jmethodID _Jv_JNI_GetMethodID(JNIEnv* env, jclass clazz, const char *name,
+ const char *sig)
{
classinfo *c;
utf *uname;
return NULL;
}
- return m;
+ return (jmethodID) m;
}
/* JNI-functions for calling instance methods *********************************/
-jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jobject _Jv_JNI_CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
- java_objectheader* ret;
+ java_objectheader *o;
+ methodinfo *m;
+ java_objectheader *ret;
va_list ap;
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
va_start(ap, methodID);
- ret = _Jv_jni_CallObjectMethod(obj, obj->vftbl, methodID, ap);
+ ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, ap);
va_end(ap);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, ret);
}
-jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jobject _Jv_JNI_CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- java_objectheader* ret;
+ java_objectheader *o;
+ methodinfo *m;
+ java_objectheader *ret;
- ret = _Jv_jni_CallObjectMethod(obj, obj->vftbl, methodID, args);
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- return NewLocalRef(env, ret);
+ ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, args);
+
+ return _Jv_JNI_NewLocalRef(env, ret);
}
-jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
+jobject _Jv_JNI_CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
- log_text("JNI-Call: CallObjectMethodA: IMPLEMENT ME!");
+ java_objectheader *o;
+ methodinfo *m;
+ java_objectheader *ret;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ ret = _Jv_jni_CallObjectMethodA(o, o->vftbl, m, args);
- return NewLocalRef(env, NULL);
+ return _Jv_JNI_NewLocalRef(env, ret);
}
-jboolean CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jboolean _Jv_JNI_CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
- va_list ap;
- jboolean ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, ap,
- PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return b;
}
-jboolean CallBooleanMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jboolean _Jv_JNI_CallBooleanMethodV(JNIEnv *env, jobject obj,
+ jmethodID methodID, va_list args)
{
- jboolean ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, args,
- PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
- return ret;
+ return b;
}
-jboolean CallBooleanMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
+jboolean _Jv_JNI_CallBooleanMethodA(JNIEnv *env, jobject obj,
+ jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallBooleanMethodA");
+ java_objectheader *o;
+ methodinfo *m;
+ jboolean b;
- return 0;
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethodA(o, o->vftbl, m, args);
+
+ return b;
}
-jbyte CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jbyte _Jv_JNI_CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
- va_list ap;
- jbyte ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jbyte b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, ap,
- PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return b;
}
-jbyte CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+
+jbyte _Jv_JNI_CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- jbyte ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jbyte b;
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, args,
- PRIMITIVETYPE_BYTE);
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- return ret;
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
+
+ return b;
}
-jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jbyte _Jv_JNI_CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallByteMethodA: IMPLEMENT ME!");
}
-jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jchar _Jv_JNI_CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
- va_list ap;
- jchar ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jchar c;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, ap,
- PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return c;
}
-jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jchar _Jv_JNI_CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- jchar ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jchar c;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, args,
- PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
- return ret;
+ return c;
}
-jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jchar _Jv_JNI_CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallCharMethodA: IMPLEMENT ME!");
}
-jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jshort _Jv_JNI_CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
- va_list ap;
- jshort ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jshort s;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, ap,
- PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return s;
}
-jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jshort _Jv_JNI_CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- jshort ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jshort s;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, args,
- PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
- return ret;
+ return s;
}
-jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jshort _Jv_JNI_CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallShortMethodA: IMPLEMENT ME!");
-jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jint _Jv_JNI_CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
- va_list ap;
- jint ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jint i;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, ap,
- PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return i;
}
-jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jint _Jv_JNI_CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- jint ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jint i;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, obj->vftbl, methodID, args,
- PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
- return ret;
+ return i;
}
-jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jint _Jv_JNI_CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallIntMethodA: IMPLEMENT ME!");
-jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jlong _Jv_JNI_CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
- va_list ap;
- jlong ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jlong l;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallLongMethod(obj, obj->vftbl, methodID, ap);
+ l = _Jv_jni_CallLongMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return l;
}
-jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jlong _Jv_JNI_CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- jlong ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jlong l;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallLongMethod(obj, obj->vftbl, methodID, args);
+ l = _Jv_jni_CallLongMethod(o, o->vftbl, m, args);
- return ret;
+ return l;
}
-jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jlong _Jv_JNI_CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallLongMethodA: IMPLEMENT ME!");
-jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jfloat _Jv_JNI_CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
- va_list ap;
- jfloat ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jfloat f;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallFloatMethod(obj, obj->vftbl, methodID, ap);
+ f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return f;
}
-jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jfloat _Jv_JNI_CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- jfloat ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jfloat f;
- ret = _Jv_jni_CallFloatMethod(obj, obj->vftbl, methodID, args);
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- return ret;
+ f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, args);
+
+ return f;
}
-jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jfloat _Jv_JNI_CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallFloatMethodA: IMPLEMENT ME!");
-jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jdouble _Jv_JNI_CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
- va_list ap;
- jdouble ret;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jdouble d;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallDoubleMethod(obj, obj->vftbl, methodID, ap);
+ d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, ap);
va_end(ap);
- return ret;
+ return d;
}
-jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jdouble _Jv_JNI_CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- jdouble ret;
+ java_objectheader *o;
+ methodinfo *m;
+ jdouble d;
- ret = _Jv_jni_CallDoubleMethod(obj, obj->vftbl, methodID, args);
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
- return ret;
+ d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, args);
+
+ return d;
}
-jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jdouble _Jv_JNI_CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallDoubleMethodA: IMPLEMENT ME!");
-void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+void _Jv_JNI_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
- va_list ap;
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- _Jv_jni_CallVoidMethod(obj, obj->vftbl, methodID, ap);
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap);
va_end(ap);
}
-void CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+void _Jv_JNI_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
- _Jv_jni_CallVoidMethod(obj, obj->vftbl, methodID, args);
+ java_objectheader *o;
+ methodinfo *m;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, args);
}
-void CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+void _Jv_JNI_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);
}
-jobject CallNonvirtualObjectMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jobject _Jv_JNI_CallNonvirtualObjectMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ ...)
{
- java_objectheader *ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ java_objectheader *r;
va_list ap;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
va_start(ap, methodID);
- ret = _Jv_jni_CallObjectMethod(obj, clazz->vftbl, methodID, ap);
+ r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, ap);
va_end(ap);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, r);
}
-jobject CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jobject _Jv_JNI_CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
- java_objectheader* ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ java_objectheader *r;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallObjectMethod(obj, clazz->vftbl, methodID, args);
+ r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, args);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, r);
}
-jobject CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jobject _Jv_JNI_CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!");
- return NewLocalRef(env, NULL);
+ return _Jv_JNI_NewLocalRef(env, NULL);
}
-jboolean CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jboolean _Jv_JNI_CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ ...)
{
- va_list ap;
- jboolean ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, ap,
- PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
-
+ return b;
}
-jboolean CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jboolean _Jv_JNI_CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
- jboolean ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, args,
- PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
- return ret;
+ return b;
}
-jboolean CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jboolean _Jv_JNI_CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualBooleanMethodA: IMPLEMENT ME!");
}
-jbyte CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jbyte _Jv_JNI_CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jbyte ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jbyte b;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, ap,
- PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
+ return b;
}
-jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jbyte _Jv_JNI_CallNonvirtualByteMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jbyte ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jbyte b;
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, args,
- PRIMITIVETYPE_BYTE);
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
- return ret;
+ return b;
}
-jbyte CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jbyte _Jv_JNI_CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualByteMethodA: IMPLEMENT ME!");
-jchar CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jchar _Jv_JNI_CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jchar ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jchar ch;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, ap,
- PRIMITIVETYPE_CHAR);
+ ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
+ return ch;
}
-jchar CallNonvirtualCharMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jchar _Jv_JNI_CallNonvirtualCharMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jchar ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jchar ch;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, args,
- PRIMITIVETYPE_CHAR);
+ ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
- return ret;
+ return ch;
}
-jchar CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jchar _Jv_JNI_CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualCharMethodA: IMPLEMENT ME!");
-jshort CallNonvirtualShortMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jshort _Jv_JNI_CallNonvirtualShortMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID, ...)
{
- va_list ap;
- jshort ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jshort s;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, ap,
- PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
+ return s;
}
-jshort CallNonvirtualShortMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jshort _Jv_JNI_CallNonvirtualShortMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
- jshort ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jshort s;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, args,
- PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
- return ret;
+ return s;
}
-jshort CallNonvirtualShortMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jshort _Jv_JNI_CallNonvirtualShortMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualShortMethodA: IMPLEMENT ME!");
-jint CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jint _Jv_JNI_CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jint ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jint i;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, ap,
- PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
+ return i;
}
-jint CallNonvirtualIntMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jint _Jv_JNI_CallNonvirtualIntMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jint ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jint i;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(obj, clazz->vftbl, methodID, args,
- PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
- return ret;
+ return i;
}
-jint CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jint _Jv_JNI_CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualIntMethodA: IMPLEMENT ME!");
-jlong CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jlong _Jv_JNI_CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jlong ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jlong l;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallLongMethod(obj, clazz->vftbl, methodID, ap);
+ l = _Jv_jni_CallLongMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
+ return l;
}
-jlong CallNonvirtualLongMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jlong _Jv_JNI_CallNonvirtualLongMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jlong ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jlong l;
- ret = _Jv_jni_CallLongMethod(obj, clazz->vftbl, methodID, args);
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- return 0;
+ l = _Jv_jni_CallLongMethod(o, c->vftbl, m, args);
+
+ return l;
}
-jlong CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jlong _Jv_JNI_CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualLongMethodA: IMPLEMENT ME!");
-jfloat CallNonvirtualFloatMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jfloat _Jv_JNI_CallNonvirtualFloatMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID, ...)
{
- va_list ap;
- jfloat ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jfloat f;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallFloatMethod(obj, clazz->vftbl, methodID, ap);
+ f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
+ return f;
}
-jfloat CallNonvirtualFloatMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jfloat _Jv_JNI_CallNonvirtualFloatMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
- jfloat ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jfloat f;
- ret = _Jv_jni_CallFloatMethod(obj, clazz->vftbl, methodID, args);
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, args);
- return ret;
+ return f;
}
-jfloat CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jfloat _Jv_JNI_CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
- STATISTICS(jniinvokation());
-
log_text("JNI-Call: CallNonvirtualFloatMethodA: IMPLEMENT ME!");
return 0;
-jdouble CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jdouble _Jv_JNI_CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ ...)
{
- va_list ap;
- jdouble ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jdouble d;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallDoubleMethod(obj, clazz->vftbl, methodID, ap);
+ d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, ap);
va_end(ap);
- return ret;
+ return d;
}
-jdouble CallNonvirtualDoubleMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jdouble _Jv_JNI_CallNonvirtualDoubleMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
- jdouble ret;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jdouble d;
- ret = _Jv_jni_CallDoubleMethod(obj, clazz->vftbl, methodID, args);
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, args);
- return ret;
+ return d;
}
-jdouble CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jdouble _Jv_JNI_CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualDoubleMethodA: IMPLEMENT ME!");
-void CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
-{
- va_list ap;
+void _Jv_JNI_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- _Jv_jni_CallVoidMethod(obj, clazz->vftbl, methodID, ap);
+ _Jv_jni_CallVoidMethod(o, c->vftbl, m, ap);
va_end(ap);
}
-void CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+void _Jv_JNI_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
- _Jv_jni_CallVoidMethod(obj, clazz->vftbl, methodID, args);
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethod(o, c->vftbl, m, args);
}
-void CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
-{
- log_text("JNI-Call: CallNonvirtualVoidMethodA: IMPLEMENT ME!");
+void _Jv_JNI_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue * args)
+{
+ 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);
}
*******************************************************************************/
-jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name,
- const char *sig)
+jfieldID _Jv_JNI_GetFieldID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
+ classinfo *c;
fieldinfo *f;
utf *uname;
utf *udesc;
STATISTICS(jniinvokation());
+ c = (classinfo *) clazz;
+
uname = utf_new_char((char *) name);
udesc = utf_new_char((char *) sig);
f = class_findfield(clazz, uname, udesc);
- if (!f)
- *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
+ if (f == NULL)
+ exceptions_throw_nosuchfielderror(c, uname);
- return f;
+ return (jfieldID) f;
}
*******************************************************************************/
-jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jobject _Jv_JNI_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
java_objectheader *o;
o = GET_FIELD(obj, java_objectheader*, fieldID);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jboolean _Jv_JNI_GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jbyte GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jbyte _Jv_JNI_GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jchar GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jchar _Jv_JNI_GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jshort GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jshort _Jv_JNI_GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jint GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jint _Jv_JNI_GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- s4 i;
+ java_objectheader *o;
+ fieldinfo *f;
+ s4 i;
STATISTICS(jniinvokation());
- i = GET_FIELD(obj, s4, fieldID);
+ o = (java_objectheader *) obj;
+ f = (fieldinfo *) fieldID;
+
+ i = GET_FIELD(o, s4, f);
return i;
}
-jlong GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jlong _Jv_JNI_GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s8 l;
}
-jfloat GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jfloat _Jv_JNI_GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
float f;
}
-jdouble GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jdouble _Jv_JNI_GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
double d;
*******************************************************************************/
-void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)
+void _Jv_JNI_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jobject value)
{
STATISTICS(jniinvokation());
}
-void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value)
+void _Jv_JNI_SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jboolean value)
{
STATISTICS(jniinvokation());
}
-void SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value)
+void _Jv_JNI_SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jbyte value)
{
STATISTICS(jniinvokation());
}
-void SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value)
+void _Jv_JNI_SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jchar value)
{
STATISTICS(jniinvokation());
}
-void SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value)
+void _Jv_JNI_SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jshort value)
{
STATISTICS(jniinvokation());
}
-void SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value)
+void _Jv_JNI_SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value)
{
STATISTICS(jniinvokation());
}
-void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value)
+void _Jv_JNI_SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jlong value)
{
STATISTICS(jniinvokation());
}
-void SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value)
+void _Jv_JNI_SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jfloat value)
{
STATISTICS(jniinvokation());
}
-void SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value)
+void _Jv_JNI_SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jdouble value)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
- const char *sig)
+jmethodID _Jv_JNI_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
classinfo *c;
utf *uname;
return NULL;
}
- return m;
+ return (jmethodID) m;
}
-jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jobject _Jv_JNI_CallStaticObjectMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- java_objectheader *ret;
+ methodinfo *m;
+ java_objectheader *o;
va_list ap;
+ m = (methodinfo *) methodID;
+
va_start(ap, methodID);
- ret = _Jv_jni_CallObjectMethod(NULL, NULL, methodID, ap);
+ o = _Jv_jni_CallObjectMethod(NULL, NULL, m, ap);
va_end(ap);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jobject _Jv_JNI_CallStaticObjectMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- java_objectheader *ret;
+ methodinfo *m;
+ java_objectheader *o;
+
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallObjectMethod(NULL, NULL, methodID, args);
+ o = _Jv_jni_CallObjectMethod(NULL, NULL, m, args);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jobject _Jv_JNI_CallStaticObjectMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallStaticObjectMethodA: IMPLEMENT ME!");
+ methodinfo *m;
+ java_objectheader *o;
+
+ m = (methodinfo *) methodID;
+
+ o = _Jv_jni_CallObjectMethodA(NULL, NULL, m, args);
- return NewLocalRef(env, NULL);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jboolean _Jv_JNI_CallStaticBooleanMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jboolean ret;
+ methodinfo *m;
+ va_list ap;
+ jboolean b;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, ap,
- PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return b;
}
-jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jboolean _Jv_JNI_CallStaticBooleanMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jboolean ret;
+ methodinfo *m;
+ jboolean b;
+
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, args,
- PRIMITIVETYPE_BOOLEAN);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
- return ret;
+ return b;
}
-jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jboolean _Jv_JNI_CallStaticBooleanMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticBooleanMethodA: IMPLEMENT ME!");
}
-jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jbyte _Jv_JNI_CallStaticByteMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jbyte ret;
+ methodinfo *m;
+ va_list ap;
+ jbyte b;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, ap, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return b;
}
-jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jbyte _Jv_JNI_CallStaticByteMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jbyte ret;
+ methodinfo *m;
+ jbyte b;
+
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, args, PRIMITIVETYPE_BYTE);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
- return ret;
+ return b;
}
-jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jbyte _Jv_JNI_CallStaticByteMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticByteMethodA: IMPLEMENT ME!");
}
-jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jchar _Jv_JNI_CallStaticCharMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jchar ret;
+ methodinfo *m;
+ va_list ap;
+ jchar c;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, ap, PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return c;
}
-jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jchar _Jv_JNI_CallStaticCharMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jchar ret;
+ methodinfo *m;
+ jchar c;
+
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, args, PRIMITIVETYPE_CHAR);
+ c = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
- return ret;
+ return c;
}
-jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jchar _Jv_JNI_CallStaticCharMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticCharMethodA: IMPLEMENT ME!");
}
-jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jshort _Jv_JNI_CallStaticShortMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jshort ret;
+ methodinfo *m;
+ va_list ap;
+ jshort s;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, ap, PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return s;
}
-jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jshort _Jv_JNI_CallStaticShortMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jshort ret;
+ methodinfo *m;
+ jshort s;
+
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, args,
- PRIMITIVETYPE_SHORT);
+ s = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
- return ret;
+ return s;
}
-jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jshort _Jv_JNI_CallStaticShortMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticShortMethodA: IMPLEMENT ME!");
}
-jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jint _Jv_JNI_CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
+ ...)
{
- va_list ap;
- jint ret;
+ methodinfo *m;
+ va_list ap;
+ jint i;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, ap, PRIMITIVETYPE_INT);
+ i = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return i;
}
-jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jint _Jv_JNI_CallStaticIntMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jint ret;
+ methodinfo *m;
+ jint i;
- ret = _Jv_jni_CallIntMethod(NULL, NULL, methodID, args, PRIMITIVETYPE_INT);
+ m = (methodinfo *) methodID;
- return ret;
+ i = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
+
+ return i;
}
-jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jint _Jv_JNI_CallStaticIntMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticIntMethodA: IMPLEMENT ME!");
}
-jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jlong _Jv_JNI_CallStaticLongMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jlong ret;
+ methodinfo *m;
+ va_list ap;
+ jlong l;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallLongMethod(NULL, NULL, methodID, ap);
+ l = _Jv_jni_CallLongMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return l;
}
-jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
- va_list args)
+jlong _Jv_JNI_CallStaticLongMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jlong ret;
+ methodinfo *m;
+ jlong l;
- ret = _Jv_jni_CallLongMethod(NULL, NULL, methodID, args);
+ m = (methodinfo *) methodID;
+
+ l = _Jv_jni_CallLongMethod(NULL, NULL, m, args);
- return ret;
+ return l;
}
-jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jlong _Jv_JNI_CallStaticLongMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!");
-jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jfloat _Jv_JNI_CallStaticFloatMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jfloat ret;
+ methodinfo *m;
+ va_list ap;
+ jfloat f;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallFloatMethod(NULL, NULL, methodID, ap);
+ f = _Jv_jni_CallFloatMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return f;
}
-jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jfloat _Jv_JNI_CallStaticFloatMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jfloat ret;
+ methodinfo *m;
+ jfloat f;
+
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallFloatMethod(NULL, NULL, methodID, args);
+ f = _Jv_jni_CallFloatMethod(NULL, NULL, m, args);
- return ret;
+ return f;
}
-jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jfloat _Jv_JNI_CallStaticFloatMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticFloatMethodA: IMPLEMENT ME!");
}
-jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jdouble _Jv_JNI_CallStaticDoubleMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
- jdouble ret;
+ methodinfo *m;
+ va_list ap;
+ jdouble d;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- ret = _Jv_jni_CallDoubleMethod(NULL, NULL, methodID, ap);
+ d = _Jv_jni_CallDoubleMethod(NULL, NULL, m, ap);
va_end(ap);
- return ret;
+ return d;
}
-jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jdouble _Jv_JNI_CallStaticDoubleMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- jdouble ret;
+ methodinfo *m;
+ jdouble d;
+
+ m = (methodinfo *) methodID;
- ret = _Jv_jni_CallDoubleMethod(NULL, NULL, methodID, args);
+ d = _Jv_jni_CallDoubleMethod(NULL, NULL, m, args);
- return ret;
+ return d;
}
-jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jdouble _Jv_JNI_CallStaticDoubleMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticDoubleMethodA: IMPLEMENT ME!");
}
-void CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+void _Jv_JNI_CallStaticVoidMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
- va_list ap;
+ methodinfo *m;
+ va_list ap;
+
+ m = (methodinfo *) methodID;
va_start(ap, methodID);
- _Jv_jni_CallVoidMethod(NULL, NULL, methodID, ap);
+ _Jv_jni_CallVoidMethod(NULL, NULL, m, ap);
va_end(ap);
}
-void CallStaticVoidMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+void _Jv_JNI_CallStaticVoidMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
- _Jv_jni_CallVoidMethod(NULL, NULL, methodID, args);
+ methodinfo *m;
+
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethod(NULL, NULL, m, args);
}
-void CallStaticVoidMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args)
+void _Jv_JNI_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);
}
*******************************************************************************/
-jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
+jfieldID _Jv_JNI_GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
- jfieldID f;
+ classinfo *c;
+ fieldinfo *f;
+ utf *uname;
+ utf *usig;
STATISTICS(jniinvokation());
- f = class_findfield(clazz,
- utf_new_char((char *) name),
- utf_new_char((char *) sig));
+ c = (classinfo *) clazz;
+
+ uname = utf_new_char((char *) name);
+ usig = utf_new_char((char *) sig);
+
+ f = class_findfield(clazz, uname, usig);
- if (!f)
- *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
+ if (f == NULL)
+ exceptions_throw_nosuchfielderror(c, uname);
- return f;
+ return (jfieldID) f;
}
*******************************************************************************/
-jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jobject _Jv_JNI_GetStaticObjectField(JNIEnv *env, jclass clazz,
+ jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return NULL;
- return NewLocalRef(env, fieldID->value.a);
+ return _Jv_JNI_NewLocalRef(env, f->value.a);
}
-jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jboolean _Jv_JNI_GetStaticBooleanField(JNIEnv *env, jclass clazz,
+ jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return false;
- return fieldID->value.i;
+ return f->value.i;
}
-jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jbyte _Jv_JNI_GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return 0;
- return fieldID->value.i;
+ return f->value.i;
}
-jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jchar _Jv_JNI_GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return 0;
- return fieldID->value.i;
+ return f->value.i;
}
-jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jshort _Jv_JNI_GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return 0;
- return fieldID->value.i;
+ return f->value.i;
}
-jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jint _Jv_JNI_GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return 0;
- return fieldID->value.i;
+ return f->value.i;
}
-jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jlong _Jv_JNI_GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return 0;
- return fieldID->value.l;
+ return f->value.l;
}
-jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jfloat _Jv_JNI_GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return 0.0;
- return fieldID->value.f;
+ return f->value.f;
}
-jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jdouble _Jv_JNI_GetStaticDoubleField(JNIEnv *env, jclass clazz,
+ jfieldID fieldID)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return 0.0;
- return fieldID->value.d;
+ return f->value.d;
}
*******************************************************************************/
-void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
+void _Jv_JNI_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jobject value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.a = value;
+ f->value.a = value;
}
-void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
+void _Jv_JNI_SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jboolean value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.i = value;
+ f->value.i = value;
}
-void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
+void _Jv_JNI_SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jbyte value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.i = value;
+ f->value.i = value;
}
-void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
+void _Jv_JNI_SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jchar value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.i = value;
+ f->value.i = value;
}
-void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
+void _Jv_JNI_SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jshort value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.i = value;
+ f->value.i = value;
}
-void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
+void _Jv_JNI_SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jint value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.i = value;
+ f->value.i = value;
}
-void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
+void _Jv_JNI_SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jlong value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.l = value;
+ f->value.l = value;
}
-void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
+void _Jv_JNI_SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jfloat value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.f = value;
+ f->value.f = value;
}
-void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
+void _Jv_JNI_SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jdouble value)
{
+ classinfo *c;
+ fieldinfo *f;
+
STATISTICS(jniinvokation());
- if (!(clazz->state & CLASS_INITIALIZED))
- if (!initialize_class(clazz))
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
return;
- fieldID->value.d = value;
+ f->value.d = value;
}
*******************************************************************************/
-jstring NewString(JNIEnv *env, const jchar *buf, jsize len)
+jstring _Jv_JNI_NewString(JNIEnv *env, const jchar *buf, jsize len)
{
java_lang_String *s;
java_chararray *a;
a = builtin_newarray_char(len);
/* javastring or characterarray could not be created */
- if (!a || !s)
+ if ((a == NULL) || (s == NULL))
return NULL;
/* copy text */
for (i = 0; i < len; i++)
a->data[i] = buf[i];
- s->value = a;
+ s->value = a;
s->offset = 0;
- s->count = len;
+ s->count = len;
- return (jstring) NewLocalRef(env, (jobject) s);
+ return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
}
*******************************************************************************/
-jsize GetStringLength(JNIEnv *env, jstring str)
+jsize _Jv_JNI_GetStringLength(JNIEnv *env, jstring str)
{
return ((java_lang_String *) str)->count;
}
*******************************************************************************/
-const jchar *GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
+const jchar *_Jv_JNI_GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
{
jchar *jc;
*******************************************************************************/
-void ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
+void _Jv_JNI_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jstring NewStringUTF(JNIEnv *env, const char *bytes)
+jstring _Jv_JNI_NewStringUTF(JNIEnv *env, const char *bytes)
{
java_lang_String *s;
STATISTICS(jniinvokation());
- s = javastring_new(utf_new_char(bytes));
+ s = javastring_safe_new_from_utf8(bytes);
- return (jstring) NewLocalRef(env, (jobject) s);
+ return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
}
/****************** returns the utf8 length in bytes of a string *******************/
-jsize GetStringUTFLength (JNIEnv *env, jstring string)
+jsize _Jv_JNI_GetStringUTFLength (JNIEnv *env, jstring string)
{
java_lang_String *s = (java_lang_String*) string;
*******************************************************************************/
-const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
+const char *_Jv_JNI_GetStringUTFChars(JNIEnv *env, jstring string,
+ jboolean *isCopy)
{
utf *u;
STATISTICS(jniinvokation());
- if (!string)
+ if (string == NULL)
return "";
if (isCopy)
u = javastring_toutf((java_lang_String *) string, false);
- if (u)
+ if (u != NULL)
return u->text;
return "";
*******************************************************************************/
-void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
+void _Jv_JNI_ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jsize GetArrayLength(JNIEnv *env, jarray array)
+jsize _Jv_JNI_GetArrayLength(JNIEnv *env, jarray array)
{
+ java_arrayheader *a;
+
STATISTICS(jniinvokation());
- return array->size;
+ a = (java_arrayheader *) array;
+
+ return a->size;
}
*******************************************************************************/
-jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)
+jobjectArray _Jv_JNI_NewObjectArray(JNIEnv *env, jsize length,
+ jclass elementClass, jobject initialElement)
{
java_objectarray *oa;
s4 i;
oa = builtin_anewarray(length, elementClass);
- if (!oa)
+ if (oa == NULL)
return NULL;
/* set all elements to initialElement */
for (i = 0; i < length; i++)
oa->data[i] = initialElement;
- return (jobjectArray) NewLocalRef(env, (jobject) oa);
+ return (jobjectArray) _Jv_JNI_NewLocalRef(env, (jobject) oa);
}
-jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
+jobject _Jv_JNI_GetObjectArrayElement(JNIEnv *env, jobjectArray array,
+ jsize index)
{
- jobject o;
+ java_objectarray *oa;
+ jobject o;
STATISTICS(jniinvokation());
- if (index >= array->header.size) {
+ oa = (java_objectarray *) array;
+
+ if (index >= oa->header.size) {
exceptions_throw_arrayindexoutofboundsexception();
return NULL;
}
- o = array->data[index];
-
- return NewLocalRef(env, o);
+ o = oa->data[index];
+
+ return _Jv_JNI_NewLocalRef(env, o);
}
-void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
+void _Jv_JNI_SetObjectArrayElement(JNIEnv *env, jobjectArray array,
+ jsize index, jobject val)
{
java_objectarray *oa;
java_objectheader *o;
oa = (java_objectarray *) array;
o = (java_objectheader *) val;
- if (index >= array->header.size) {
+ if (index >= oa->header.size) {
exceptions_throw_arrayindexoutofboundsexception();
return;
}
of the array */
if (!builtin_canstore(oa, o)) {
- *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
-
+ exceptions_throw_arraystoreexception();
return;
}
- array->data[index] = val;
+ oa->data[index] = val;
}
-jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
+jbooleanArray _Jv_JNI_NewBooleanArray(JNIEnv *env, jsize len)
{
java_booleanarray *ba;
ba = builtin_newarray_boolean(len);
- return (jbooleanArray) NewLocalRef(env, (jobject) ba);
+ return (jbooleanArray) _Jv_JNI_NewLocalRef(env, (jobject) ba);
}
-jbyteArray NewByteArray(JNIEnv *env, jsize len)
+jbyteArray _Jv_JNI_NewByteArray(JNIEnv *env, jsize len)
{
java_bytearray *ba;
ba = builtin_newarray_byte(len);
- return (jbyteArray) NewLocalRef(env, (jobject) ba);
+ return (jbyteArray) _Jv_JNI_NewLocalRef(env, (jobject) ba);
}
-jcharArray NewCharArray(JNIEnv *env, jsize len)
+jcharArray _Jv_JNI_NewCharArray(JNIEnv *env, jsize len)
{
java_chararray *ca;
ca = builtin_newarray_char(len);
- return (jcharArray) NewLocalRef(env, (jobject) ca);
+ return (jcharArray) _Jv_JNI_NewLocalRef(env, (jobject) ca);
}
-jshortArray NewShortArray(JNIEnv *env, jsize len)
+jshortArray _Jv_JNI_NewShortArray(JNIEnv *env, jsize len)
{
java_shortarray *sa;
sa = builtin_newarray_short(len);
- return (jshortArray) NewLocalRef(env, (jobject) sa);
+ return (jshortArray) _Jv_JNI_NewLocalRef(env, (jobject) sa);
}
-jintArray NewIntArray(JNIEnv *env, jsize len)
+jintArray _Jv_JNI_NewIntArray(JNIEnv *env, jsize len)
{
java_intarray *ia;
ia = builtin_newarray_int(len);
- return (jintArray) NewLocalRef(env, (jobject) ia);
+ return (jintArray) _Jv_JNI_NewLocalRef(env, (jobject) ia);
}
-jlongArray NewLongArray(JNIEnv *env, jsize len)
+jlongArray _Jv_JNI_NewLongArray(JNIEnv *env, jsize len)
{
java_longarray *la;
la = builtin_newarray_long(len);
- return (jlongArray) NewLocalRef(env, (jobject) la);
+ return (jlongArray) _Jv_JNI_NewLocalRef(env, (jobject) la);
}
-jfloatArray NewFloatArray(JNIEnv *env, jsize len)
+jfloatArray _Jv_JNI_NewFloatArray(JNIEnv *env, jsize len)
{
java_floatarray *fa;
fa = builtin_newarray_float(len);
- return (jfloatArray) NewLocalRef(env, (jobject) fa);
+ return (jfloatArray) _Jv_JNI_NewLocalRef(env, (jobject) fa);
}
-jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
+jdoubleArray _Jv_JNI_NewDoubleArray(JNIEnv *env, jsize len)
{
java_doublearray *da;
da = builtin_newarray_double(len);
- return (jdoubleArray) NewLocalRef(env, (jobject) da);
+ return (jdoubleArray) _Jv_JNI_NewLocalRef(env, (jobject) da);
}
*******************************************************************************/
-jboolean *GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
- jboolean *isCopy)
+jboolean *_Jv_JNI_GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
+ jboolean *isCopy)
{
+ java_booleanarray *ba;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ ba = (java_booleanarray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ return ba->data;
}
-jbyte *GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy)
+jbyte *_Jv_JNI_GetByteArrayElements(JNIEnv *env, jbyteArray array,
+ jboolean *isCopy)
{
+ java_bytearray *ba;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ ba = (java_bytearray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ return ba->data;
}
-jchar *GetCharArrayElements(JNIEnv *env, jcharArray array, jboolean *isCopy)
+jchar *_Jv_JNI_GetCharArrayElements(JNIEnv *env, jcharArray array,
+ jboolean *isCopy)
{
+ java_chararray *ca;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ ca = (java_chararray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ return ca->data;
}
-jshort *GetShortArrayElements(JNIEnv *env, jshortArray array, jboolean *isCopy)
+jshort *_Jv_JNI_GetShortArrayElements(JNIEnv *env, jshortArray array,
+ jboolean *isCopy)
{
+ java_shortarray *sa;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ sa = (java_shortarray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ return sa->data;
}
-jint *GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy)
+jint *_Jv_JNI_GetIntArrayElements(JNIEnv *env, jintArray array,
+ jboolean *isCopy)
{
+ java_intarray *ia;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ ia = (java_intarray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ return ia->data;
}
-jlong *GetLongArrayElements(JNIEnv *env, jlongArray array, jboolean *isCopy)
+jlong *_Jv_JNI_GetLongArrayElements(JNIEnv *env, jlongArray array,
+ jboolean *isCopy)
{
+ java_longarray *la;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ la = (java_longarray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ /* We cast this one to prevent a compiler warning on 64-bit
+ systems since GNU Classpath typedef jlong to long long. */
+
+ return (jlong *) la->data;
}
-jfloat *GetFloatArrayElements(JNIEnv *env, jfloatArray array, jboolean *isCopy)
+jfloat *_Jv_JNI_GetFloatArrayElements(JNIEnv *env, jfloatArray array,
+ jboolean *isCopy)
{
+ java_floatarray *fa;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ fa = (java_floatarray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ return fa->data;
}
-jdouble *GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
- jboolean *isCopy)
+jdouble *_Jv_JNI_GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
+ jboolean *isCopy)
{
+ java_doublearray *da;
+
STATISTICS(jniinvokation());
- if (isCopy)
+ da = (java_doublearray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
- return array->data;
+ return da->data;
}
*******************************************************************************/
-void ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array,
- jboolean *elems, jint mode)
+void _Jv_JNI_ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array,
+ jboolean *elems, jint mode)
{
+ java_booleanarray *ba;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ ba = (java_booleanarray *) array;
+
+ if (elems != ba->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ba->data, elems, u1, ba->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ba->data, elems, u1, ba->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
}
-void ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, jbyte *elems,
- jint mode)
+void _Jv_JNI_ReleaseByteArrayElements(JNIEnv *env, jbyteArray array,
+ jbyte *elems, jint mode)
{
+ java_bytearray *ba;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ ba = (java_bytearray *) array;
+
+ if (elems != ba->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ba->data, elems, s1, ba->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ba->data, elems, s1, ba->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
}
-void ReleaseCharArrayElements(JNIEnv *env, jcharArray array, jchar *elems,
- jint mode)
+void _Jv_JNI_ReleaseCharArrayElements(JNIEnv *env, jcharArray array,
+ jchar *elems, jint mode)
{
+ java_chararray *ca;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ ca = (java_chararray *) array;
+
+ if (elems != ca->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ca->data, elems, u2, ca->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ca->data, elems, u2, ca->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
}
-void ReleaseShortArrayElements(JNIEnv *env, jshortArray array, jshort *elems,
- jint mode)
+void _Jv_JNI_ReleaseShortArrayElements(JNIEnv *env, jshortArray array,
+ jshort *elems, jint mode)
{
+ java_shortarray *sa;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ sa = (java_shortarray *) array;
+
+ if (elems != sa->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(sa->data, elems, s2, sa->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(sa->data, elems, s2, sa->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
}
-void ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems,
- jint mode)
+void _Jv_JNI_ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems,
+ jint mode)
{
+ java_intarray *ia;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ ia = (java_intarray *) array;
+
+ if (elems != ia->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ia->data, elems, s4, ia->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(ia->data, elems, s4, ia->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
}
-void ReleaseLongArrayElements(JNIEnv *env, jlongArray array, jlong *elems,
- jint mode)
+void _Jv_JNI_ReleaseLongArrayElements(JNIEnv *env, jlongArray array,
+ jlong *elems, jint mode)
{
+ java_longarray *la;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ la = (java_longarray *) array;
+
+ /* We cast this one to prevent a compiler warning on 64-bit
+ systems since GNU Classpath typedef jlong to long long. */
+
+ if ((s8 *) elems != la->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(la->data, elems, s8, la->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(la->data, elems, s8, la->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
}
-void ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array, jfloat *elems,
- jint mode)
+void _Jv_JNI_ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array,
+ jfloat *elems, jint mode)
{
+ java_floatarray *fa;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ fa = (java_floatarray *) array;
+
+ if (elems != fa->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(fa->data, elems, float, fa->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(fa->data, elems, float, fa->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
}
-void ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array,
- jdouble *elems, jint mode)
+void _Jv_JNI_ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array,
+ jdouble *elems, jint mode)
{
+ java_doublearray *da;
+
STATISTICS(jniinvokation());
- if (elems != array->data) {
+ da = (java_doublearray *) array;
+
+ if (elems != da->data) {
switch (mode) {
case JNI_COMMIT:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(da->data, elems, double, da->header.size);
break;
case 0:
- MCOPY(array->data, elems, jboolean, array->header.size);
+ MCOPY(da->data, elems, double, da->header.size);
/* XXX TWISTI how should it be freed? */
break;
case JNI_ABORT:
*******************************************************************************/
-void GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
- jsize len, jboolean *buf)
+void _Jv_JNI_GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array,
+ jsize start, jsize len, jboolean *buf)
{
+ java_booleanarray *ba;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ba = (java_booleanarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
exceptions_throw_arrayindexoutofboundsexception();
else
- MCOPY(buf, &array->data[start], jboolean, len);
+ MCOPY(buf, &ba->data[start], u1, len);
}
-void GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
- jbyte *buf)
+void _Jv_JNI_GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start,
+ jsize len, jbyte *buf)
{
+ java_bytearray *ba;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ba = (java_bytearray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(buf, &array->data[start], jbyte, len);
+ else
+ MCOPY(buf, &ba->data[start], s1, len);
}
-void GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
- jchar *buf)
+void _Jv_JNI_GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start,
+ jsize len, jchar *buf)
{
+ java_chararray *ca;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ca = (java_chararray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ca->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(buf, &array->data[start], jchar, len);
+ else
+ MCOPY(buf, &ca->data[start], u2, len);
}
-void GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
- jsize len, jshort *buf)
+void _Jv_JNI_GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
+ jsize len, jshort *buf)
{
+ java_shortarray *sa;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ sa = (java_shortarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > sa->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(buf, &array->data[start], jshort, len);
+ else
+ MCOPY(buf, &sa->data[start], s2, len);
}
-void GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
- jint *buf)
+void _Jv_JNI_GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start,
+ jsize len, jint *buf)
{
+ java_intarray *ia;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ia = (java_intarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ia->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(buf, &array->data[start], jint, len);
+ else
+ MCOPY(buf, &ia->data[start], s4, len);
}
-void GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start, jsize len,
- jlong *buf)
+void _Jv_JNI_GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start,
+ jsize len, jlong *buf)
{
+ java_longarray *la;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ la = (java_longarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > la->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(buf, &array->data[start], jlong, len);
+ else
+ MCOPY(buf, &la->data[start], s8, len);
}
-void GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
- jsize len, jfloat *buf)
+void _Jv_JNI_GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
+ jsize len, jfloat *buf)
{
+ java_floatarray *fa;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ fa = (java_floatarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > fa->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(buf, &array->data[start], jfloat, len);
+ else
+ MCOPY(buf, &fa->data[start], float, len);
}
-void GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
- jsize len, jdouble *buf)
+void _Jv_JNI_GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
+ jsize len, jdouble *buf)
{
+ java_doublearray *da;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start+len>array->header.size)
+ da = (java_doublearray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > da->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(buf, &array->data[start], jdouble, len);
+ else
+ MCOPY(buf, &da->data[start], double, len);
}
*******************************************************************************/
-void SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
- jsize len, jboolean *buf)
+void _Jv_JNI_SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array,
+ jsize start, jsize len, jboolean *buf)
{
+ java_booleanarray *ba;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ba = (java_booleanarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jboolean, len);
+ else
+ MCOPY(&ba->data[start], buf, u1, len);
}
-void SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
- jbyte *buf)
+void _Jv_JNI_SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start,
+ jsize len, jbyte *buf)
{
+ java_bytearray *ba;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ba = (java_bytearray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jbyte, len);
+ else
+ MCOPY(&ba->data[start], buf, s1, len);
}
-void SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
- jchar *buf)
+void _Jv_JNI_SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start,
+ jsize len, jchar *buf)
{
+ java_chararray *ca;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ca = (java_chararray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ca->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jchar, len);
+ else
+ MCOPY(&ca->data[start], buf, u2, len);
}
-void SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
- jsize len, jshort *buf)
+void _Jv_JNI_SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
+ jsize len, jshort *buf)
{
+ java_shortarray *sa;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ sa = (java_shortarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > sa->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jshort, len);
+ else
+ MCOPY(&sa->data[start], buf, s2, len);
}
-void SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
- jint *buf)
+void _Jv_JNI_SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start,
+ jsize len, jint *buf)
{
+ java_intarray *ia;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ ia = (java_intarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ia->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jint, len);
+ else
+ MCOPY(&ia->data[start], buf, s4, len);
}
-void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len,
- jlong *buf)
+void _Jv_JNI_SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start,
+ jsize len, jlong *buf)
{
+ java_longarray *la;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ la = (java_longarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > la->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jlong, len);
+ else
+ MCOPY(&la->data[start], buf, s8, len);
}
-void SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
- jsize len, jfloat *buf)
+void _Jv_JNI_SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
+ jsize len, jfloat *buf)
{
+ java_floatarray *fa;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ fa = (java_floatarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > fa->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jfloat, len);
+ else
+ MCOPY(&fa->data[start], buf, float, len);
}
-void SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
- jsize len, jdouble *buf)
+void _Jv_JNI_SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
+ jsize len, jdouble *buf)
{
+ java_doublearray *da;
+
STATISTICS(jniinvokation());
- if (start < 0 || len < 0 || start + len > array->header.size)
+ da = (java_doublearray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > da->header.size))
exceptions_throw_arrayindexoutofboundsexception();
- else
- MCOPY(&array->data[start], buf, jdouble, len);
+ else
+ MCOPY(&da->data[start], buf, double, len);
}
*******************************************************************************/
-jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
- jint nMethods)
+jint _Jv_JNI_RegisterNatives(JNIEnv *env, jclass clazz,
+ const JNINativeMethod *methods, jint nMethods)
{
STATISTICS(jniinvokation());
log_text("JNI-Call: RegisterNatives: IMPLEMENT ME!!!");
+ /* XXX: if implemented this needs a call to jvmti_NativeMethodBind
+ if (jvmti) jvmti_NativeMethodBind(method, address, new_address_ptr);
+ */
return 0;
}
*******************************************************************************/
-jint UnregisterNatives(JNIEnv *env, jclass clazz)
+jint _Jv_JNI_UnregisterNatives(JNIEnv *env, jclass clazz)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jint MonitorEnter(JNIEnv *env, jobject obj)
+jint _Jv_JNI_MonitorEnter(JNIEnv *env, jobject obj)
{
STATISTICS(jniinvokation());
- if (!obj) {
+ if (obj == NULL) {
exceptions_throw_nullpointerexception();
return JNI_ERR;
}
-#if defined(USE_THREADS)
- builtin_monitorenter(obj);
-#endif
+ LOCK_MONITOR_ENTER(obj);
return JNI_OK;
}
*******************************************************************************/
-jint MonitorExit(JNIEnv *env, jobject obj)
+jint _Jv_JNI_MonitorExit(JNIEnv *env, jobject obj)
{
STATISTICS(jniinvokation());
- if (!obj) {
+ if (obj == NULL) {
exceptions_throw_nullpointerexception();
return JNI_ERR;
}
-#if defined(USE_THREADS)
- builtin_monitorexit(obj);
-#endif
+ LOCK_MONITOR_EXIT(obj);
return JNI_OK;
}
*******************************************************************************/
-jint GetJavaVM(JNIEnv *env, JavaVM **vm)
+jint _Jv_JNI_GetJavaVM(JNIEnv *env, JavaVM **vm)
{
STATISTICS(jniinvokation());
- *vm = &ptr_jvm;
+ *vm = (JavaVM *) _Jv_jvm;
return 0;
}
-void GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
+/* GetStringRegion *************************************************************
+
+ Copies len number of Unicode characters beginning at offset start
+ to the given buffer buf.
+
+ Throws StringIndexOutOfBoundsException on index overflow.
+
+*******************************************************************************/
+
+void _Jv_JNI_GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len,
+ jchar *buf)
{
+ java_lang_String *s;
+ java_chararray *ca;
+
STATISTICS(jniinvokation());
- log_text("JNI-Call: GetStringRegion: IMPLEMENT ME!");
+ s = (java_lang_String *) str;
+ ca = s->value;
+
+ if ((start < 0) || (len < 0) || (start > s->count) ||
+ (start + len > s->count)) {
+ exceptions_throw_stringindexoutofboundsexception();
+ return;
+ }
+
+ MCOPY(buf, &ca->data[start], u2, len);
}
-void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
+void _Jv_JNI_GetStringUTFRegion(JNIEnv* env, jstring str, jsize start,
+ jsize len, char *buf)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)
+void *_Jv_JNI_GetPrimitiveArrayCritical(JNIEnv *env, jarray array,
+ jboolean *isCopy)
{
java_bytearray *ba;
jbyte *bp;
/* do the same as Kaffe does */
- bp = GetByteArrayElements(env, ba, isCopy);
+ bp = _Jv_JNI_GetByteArrayElements(env, ba, isCopy);
return (void *) bp;
}
*******************************************************************************/
-void ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray,
- jint mode)
+void _Jv_JNI_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array,
+ void *carray, jint mode)
{
STATISTICS(jniinvokation());
/* do the same as Kaffe does */
- ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray, mode);
+ _Jv_JNI_ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray,
+ mode);
}
*******************************************************************************/
-const jchar *GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)
+const jchar *_Jv_JNI_GetStringCritical(JNIEnv *env, jstring string,
+ jboolean *isCopy)
{
STATISTICS(jniinvokation());
- return GetStringChars(env, string, isCopy);
+ return _Jv_JNI_GetStringChars(env, string, isCopy);
}
-void ReleaseStringCritical(JNIEnv *env, jstring string, const jchar *cstring)
+void _Jv_JNI_ReleaseStringCritical(JNIEnv *env, jstring string,
+ const jchar *cstring)
{
STATISTICS(jniinvokation());
- ReleaseStringChars(env, string, cstring);
+ _Jv_JNI_ReleaseStringChars(env, string, cstring);
}
-jweak NewWeakGlobalRef(JNIEnv* env, jobject obj)
+jweak _Jv_JNI_NewWeakGlobalRef(JNIEnv* env, jobject obj)
{
STATISTICS(jniinvokation());
}
-void DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
+void _Jv_JNI_DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jobject NewGlobalRef(JNIEnv* env, jobject lobj)
+jobject _Jv_JNI_NewGlobalRef(JNIEnv* env, jobject obj)
{
- java_objectheader *o;
- java_lang_Integer *refcount;
- java_objectheader *newval;
+ hashtable_global_ref_entry *gre;
+ u4 key; /* hashkey */
+ u4 slot; /* slot in hashtable */
STATISTICS(jniinvokation());
-#if defined(USE_THREADS)
- builtin_monitorenter(*global_ref_table);
-#endif
+ LOCK_MONITOR_ENTER(hashtable_global_ref->header);
+
+ /* normally addresses are aligned to 4, 8 or 16 bytes */
+
+ key = ((u4) (ptrint) obj) >> 4; /* align to 16-byte boundaries */
+ slot = key & (hashtable_global_ref->size - 1);
+ gre = hashtable_global_ref->ptr[slot];
- ASM_CALLJAVAFUNCTION_ADR(o, getmid, *global_ref_table, lobj, NULL, NULL);
+ /* search external hash chain for the entry */
- refcount = (java_lang_Integer *) o;
+ while (gre) {
+ if (gre->o == obj) {
+ /* global object found, increment the reference */
- if (refcount == NULL) {
- newval = native_new_and_init_int(class_java_lang_Integer, 1);
+ gre->refs++;
- if (newval == NULL) {
-#if defined(USE_THREADS)
- builtin_monitorexit(*global_ref_table);
-#endif
- return NULL;
+ LOCK_MONITOR_EXIT(hashtable_global_ref->header);
+
+ return obj;
}
- ASM_CALLJAVAFUNCTION(putmid, *global_ref_table, lobj, newval, NULL);
+ gre = gre->hashlink; /* next element in external chain */
+ }
+
+ /* global ref not found, create a new one */
- } else {
- /* we can access the object itself, as we are in a
- synchronized section */
+ gre = NEW(hashtable_global_ref_entry);
- refcount->value++;
- }
+ gre->o = obj;
+ gre->refs = 1;
-#if defined(USE_THREADS)
- builtin_monitorexit(*global_ref_table);
-#endif
+ /* insert entry into hashtable */
+
+ gre->hashlink = hashtable_global_ref->ptr[slot];
+
+ hashtable_global_ref->ptr[slot] = gre;
+
+ /* update number of hashtable-entries */
+
+ hashtable_global_ref->entries++;
- return lobj;
+ LOCK_MONITOR_EXIT(hashtable_global_ref->header);
+
+ return obj;
}
*******************************************************************************/
-void DeleteGlobalRef(JNIEnv* env, jobject globalRef)
+void _Jv_JNI_DeleteGlobalRef(JNIEnv* env, jobject globalRef)
{
- java_objectheader *o;
- java_lang_Integer *refcount;
- s4 val;
+ hashtable_global_ref_entry *gre;
+ hashtable_global_ref_entry *prevgre;
+ u4 key; /* hashkey */
+ u4 slot; /* slot in hashtable */
STATISTICS(jniinvokation());
-#if defined(USE_THREADS)
- builtin_monitorenter(*global_ref_table);
-#endif
+ LOCK_MONITOR_ENTER(hashtable_global_ref->header);
- ASM_CALLJAVAFUNCTION_ADR(o, getmid, *global_ref_table, globalRef, NULL,
- NULL);
+ /* normally addresses are aligned to 4, 8 or 16 bytes */
- refcount = (java_lang_Integer *) o;
+ key = ((u4) (ptrint) globalRef) >> 4; /* align to 16-byte boundaries */
+ slot = key & (hashtable_global_ref->size - 1);
+ gre = hashtable_global_ref->ptr[slot];
- if (refcount == NULL) {
- log_text("JNI-DeleteGlobalRef: unable to find global reference");
- return;
- }
+ /* initialize prevgre */
- /* we can access the object itself, as we are in a synchronized
- section */
+ prevgre = NULL;
- val = refcount->value - 1;
+ /* search external hash chain for the entry */
- if (val == 0) {
- ASM_CALLJAVAFUNCTION(removemid, *global_ref_table, refcount, NULL,
- NULL);
+ while (gre) {
+ if (gre->o == globalRef) {
+ /* global object found, decrement the reference count */
- } else {
- /* we do not create a new object, but set the new value into
- the old one */
+ gre->refs--;
+
+ /* if reference count is 0, remove the entry */
+
+ if (gre->refs == 0) {
+ /* special handling if it's the first in the chain */
+
+ if (prevgre == NULL)
+ hashtable_global_ref->ptr[slot] = gre->hashlink;
+ else
+ prevgre->hashlink = gre->hashlink;
+
+ FREE(gre, hashtable_global_ref_entry);
+ }
+
+ LOCK_MONITOR_EXIT(hashtable_global_ref->header);
+
+ return;
+ }
- refcount->value = val;
+ prevgre = gre; /* save current pointer for removal */
+ gre = gre->hashlink; /* next element in external chain */
}
-#if defined(USE_THREADS)
- builtin_monitorexit(*global_ref_table);
-#endif
+ log_println("JNI-DeleteGlobalRef: global reference not found");
+
+ LOCK_MONITOR_EXIT(hashtable_global_ref->header);
}
*******************************************************************************/
-jboolean ExceptionCheck(JNIEnv *env)
+jboolean _Jv_JNI_ExceptionCheck(JNIEnv *env)
{
+ java_objectheader *o;
+
STATISTICS(jniinvokation());
- return *exceptionptr ? JNI_TRUE : JNI_FALSE;
+ o = exceptions_get_exception();
+
+ return (o != NULL) ? JNI_TRUE : JNI_FALSE;
}
*******************************************************************************/
-jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
+jobject _Jv_JNI_NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
{
+#if defined(ENABLE_JAVASE)
java_objectheader *nbuf;
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
gnu_classpath_Pointer64 *paddress;
-#else
+# else
gnu_classpath_Pointer32 *paddress;
-#endif
+# endif
STATISTICS(jniinvokation());
/* alocate a gnu.classpath.Pointer{32,64} object */
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
if (!(paddress = (gnu_classpath_Pointer64 *)
builtin_new(class_gnu_classpath_Pointer64)))
-#else
+# else
if (!(paddress = (gnu_classpath_Pointer32 *)
builtin_new(class_gnu_classpath_Pointer32)))
-#endif
+# endif
return NULL;
/* fill gnu.classpath.Pointer{32,64} with address */
/* create a java.nio.DirectByteBufferImpl$ReadWrite object */
nbuf = (*env)->NewObject(env, class_java_nio_DirectByteBufferImpl_ReadWrite,
- dbbirw_init, NULL, paddress,
+ (jmethodID) dbbirw_init, NULL, paddress,
(jint) capacity, (jint) capacity, (jint) 0);
/* add local reference and return the value */
- return NewLocalRef(env, nbuf);
+ return _Jv_JNI_NewLocalRef(env, nbuf);
+#else
+ vm_abort("_Jv_JNI_NewDirectByteBuffer: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-void *GetDirectBufferAddress(JNIEnv *env, jobject buf)
+void *_Jv_JNI_GetDirectBufferAddress(JNIEnv *env, jobject buf)
{
+#if defined(ENABLE_JAVASE)
java_nio_DirectByteBufferImpl *nbuf;
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
gnu_classpath_Pointer64 *address;
-#else
+# else
gnu_classpath_Pointer32 *address;
-#endif
+# endif
STATISTICS(jniinvokation());
nbuf = (java_nio_DirectByteBufferImpl *) buf;
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
address = (gnu_classpath_Pointer64 *) nbuf->address;
-#else
+# else
address = (gnu_classpath_Pointer32 *) nbuf->address;
-#endif
+# endif
+
+ if (address == NULL)
+ return NULL;
return (void *) address->data;
+#else
+ vm_abort("_Jv_JNI_GetDirectBufferAddress: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
+jlong _Jv_JNI_GetDirectBufferCapacity(JNIEnv* env, jobject buf)
{
+#if defined(ENABLE_JAVASE)
java_nio_Buffer *nbuf;
STATISTICS(jniinvokation());
nbuf = (java_nio_Buffer *) buf;
return (jlong) nbuf->cap;
+#else
+ vm_abort("_Jv_JNI_GetDirectBufferCapacity: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return 0;
+#endif
}
-jint DestroyJavaVM(JavaVM *vm)
+/* DestroyJavaVM ***************************************************************
+
+ Unloads a Java VM and reclaims its resources. Only the main thread
+ can unload the VM. The system waits until the main thread is only
+ remaining user thread before it destroys the VM.
+
+*******************************************************************************/
+
+jint _Jv_JNI_DestroyJavaVM(JavaVM *vm)
{
+ s4 status;
+
STATISTICS(jniinvokation());
- log_text("JNI-Call: DestroyJavaVM: IMPLEMENT ME!");
+ status = vm_destroy(vm);
- return 0;
+ return status;
}
*******************************************************************************/
-jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
+static s4 jni_attach_current_thread(void **p_env, void *thr_args, bool isdaemon)
{
- STATISTICS(jniinvokation());
+ JavaVMAttachArgs *vm_aargs;
- log_text("JNI-Call: AttachCurrentThread: IMPLEMENT ME!");
+#if defined(ENABLE_THREADS)
+ if (threads_get_current_threadobject() == NULL) {
+ vm_aargs = (JavaVMAttachArgs *) thr_args;
-#if !defined(HAVE___THREAD)
-/* cacao_thread_attach();*/
-#else
- #error "No idea how to implement that. Perhaps Stefan knows"
+ if (vm_aargs != NULL) {
+ if ((vm_aargs->version != JNI_VERSION_1_2) &&
+ (vm_aargs->version != JNI_VERSION_1_4))
+ return JNI_EVERSION;
+ }
+
+ if (!threads_attach_current_thread(vm_aargs, false))
+ return JNI_ERR;
+
+ if (!jni_init_localref_table())
+ return JNI_ERR;
+ }
#endif
- *env = &ptr_env;
+ *p_env = _Jv_env;
- return 0;
+ return JNI_OK;
}
-jint DetachCurrentThread(JavaVM *vm)
+jint _Jv_JNI_AttachCurrentThread(JavaVM *vm, void **p_env, void *thr_args)
{
STATISTICS(jniinvokation());
- log_text("JNI-Call: DetachCurrentThread: IMPLEMENT ME!");
+ return jni_attach_current_thread(p_env, thr_args, false);
+}
+
- return 0;
+/* DetachCurrentThread *********************************************************
+
+ Detaches the current thread from a Java VM. All Java monitors held
+ by this thread are released. All Java threads waiting for this
+ thread to die are notified.
+
+ In JDK 1.1, the main thread cannot be detached from the VM. It must
+ call DestroyJavaVM to unload the entire VM.
+
+ In the JDK, the main thread can be detached from the VM.
+
+ The main thread, which is the thread that created the Java VM,
+ cannot be detached from the VM. Instead, the main thread must call
+ JNI_DestroyJavaVM() to unload the entire VM.
+
+*******************************************************************************/
+
+jint _Jv_JNI_DetachCurrentThread(JavaVM *vm)
+{
+#if defined(ENABLE_THREADS)
+ threadobject *thread;
+
+ STATISTICS(jniinvokation());
+
+ thread = threads_get_current_threadobject();
+
+ if (thread == NULL)
+ return JNI_ERR;
+
+ if (!threads_detach_thread(thread))
+ return JNI_ERR;
+#endif
+
+ return JNI_OK;
}
*******************************************************************************/
-jint GetEnv(JavaVM *vm, void **env, jint version)
+jint _Jv_JNI_GetEnv(JavaVM *vm, void **env, jint version)
{
STATISTICS(jniinvokation());
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
- if (thread_getself() == NULL) {
+#if defined(ENABLE_THREADS)
+ if (threads_get_current_threadobject() == NULL) {
*env = NULL;
return JNI_EDETACHED;
}
#endif
- if ((version == JNI_VERSION_1_1) || (version == JNI_VERSION_1_2) ||
- (version == JNI_VERSION_1_4)) {
- *env = &ptr_env;
+ /* check the JNI version */
+ switch (version) {
+ case JNI_VERSION_1_1:
+ case JNI_VERSION_1_2:
+ case JNI_VERSION_1_4:
+ *env = _Jv_env;
return JNI_OK;
+
+ default:
+ ;
}
#if defined(ENABLE_JVMTI)
- if (version == JVMTI_VERSION_1_0) {
- *env = (void *) new_jvmtienv();
+ if ((version & JVMTI_VERSION_MASK_INTERFACE_TYPE)
+ == JVMTI_VERSION_INTERFACE_JVMTI) {
+
+ *env = (void *) jvmti_new_environment();
if (env != NULL)
return JNI_OK;
}
+/* AttachCurrentThreadAsDaemon *************************************************
+
+ Same semantics as AttachCurrentThread, but the newly-created
+ java.lang.Thread instance is a daemon.
-jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
+ If the thread has already been attached via either
+ AttachCurrentThread or AttachCurrentThreadAsDaemon, this routine
+ simply sets the value pointed to by penv to the JNIEnv of the
+ current thread. In this case neither AttachCurrentThread nor this
+ routine have any effect on the daemon status of the thread.
+
+*******************************************************************************/
+
+jint _Jv_JNI_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *args)
{
STATISTICS(jniinvokation());
- log_text("JNI-Call: AttachCurrentThreadAsDaemon: IMPLEMENT ME!");
-
- return 0;
+ return jni_attach_current_thread(penv, args, true);
}
/* JNI invocation table *******************************************************/
-const struct JNIInvokeInterface JNI_JavaVMTable = {
+const struct JNIInvokeInterface _Jv_JNIInvokeInterface = {
NULL,
NULL,
NULL,
- DestroyJavaVM,
- AttachCurrentThread,
- DetachCurrentThread,
- GetEnv,
- AttachCurrentThreadAsDaemon
+ _Jv_JNI_DestroyJavaVM,
+ _Jv_JNI_AttachCurrentThread,
+ _Jv_JNI_DetachCurrentThread,
+ _Jv_JNI_GetEnv,
+ _Jv_JNI_AttachCurrentThreadAsDaemon
};
/* JNI function table *********************************************************/
-struct JNINativeInterface JNI_JNIEnvTable = {
+struct JNINativeInterface _Jv_JNINativeInterface = {
NULL,
NULL,
NULL,
NULL,
- &GetVersion,
-
- &DefineClass,
- &FindClass,
- &FromReflectedMethod,
- &FromReflectedField,
- &ToReflectedMethod,
- &GetSuperclass,
- &IsAssignableFrom,
- &ToReflectedField,
-
- &Throw,
- &ThrowNew,
- &ExceptionOccurred,
- &ExceptionDescribe,
- &ExceptionClear,
- &FatalError,
- &PushLocalFrame,
- &PopLocalFrame,
-
- &NewGlobalRef,
- &DeleteGlobalRef,
- &DeleteLocalRef,
- &IsSameObject,
- &NewLocalRef,
- &EnsureLocalCapacity,
-
- &AllocObject,
- &NewObject,
- &NewObjectV,
- &NewObjectA,
-
- &GetObjectClass,
- &IsInstanceOf,
-
- &GetMethodID,
-
- &CallObjectMethod,
- &CallObjectMethodV,
- &CallObjectMethodA,
- &CallBooleanMethod,
- &CallBooleanMethodV,
- &CallBooleanMethodA,
- &CallByteMethod,
- &CallByteMethodV,
- &CallByteMethodA,
- &CallCharMethod,
- &CallCharMethodV,
- &CallCharMethodA,
- &CallShortMethod,
- &CallShortMethodV,
- &CallShortMethodA,
- &CallIntMethod,
- &CallIntMethodV,
- &CallIntMethodA,
- &CallLongMethod,
- &CallLongMethodV,
- &CallLongMethodA,
- &CallFloatMethod,
- &CallFloatMethodV,
- &CallFloatMethodA,
- &CallDoubleMethod,
- &CallDoubleMethodV,
- &CallDoubleMethodA,
- &CallVoidMethod,
- &CallVoidMethodV,
- &CallVoidMethodA,
-
- &CallNonvirtualObjectMethod,
- &CallNonvirtualObjectMethodV,
- &CallNonvirtualObjectMethodA,
- &CallNonvirtualBooleanMethod,
- &CallNonvirtualBooleanMethodV,
- &CallNonvirtualBooleanMethodA,
- &CallNonvirtualByteMethod,
- &CallNonvirtualByteMethodV,
- &CallNonvirtualByteMethodA,
- &CallNonvirtualCharMethod,
- &CallNonvirtualCharMethodV,
- &CallNonvirtualCharMethodA,
- &CallNonvirtualShortMethod,
- &CallNonvirtualShortMethodV,
- &CallNonvirtualShortMethodA,
- &CallNonvirtualIntMethod,
- &CallNonvirtualIntMethodV,
- &CallNonvirtualIntMethodA,
- &CallNonvirtualLongMethod,
- &CallNonvirtualLongMethodV,
- &CallNonvirtualLongMethodA,
- &CallNonvirtualFloatMethod,
- &CallNonvirtualFloatMethodV,
- &CallNonvirtualFloatMethodA,
- &CallNonvirtualDoubleMethod,
- &CallNonvirtualDoubleMethodV,
- &CallNonvirtualDoubleMethodA,
- &CallNonvirtualVoidMethod,
- &CallNonvirtualVoidMethodV,
- &CallNonvirtualVoidMethodA,
-
- &GetFieldID,
-
- &GetObjectField,
- &GetBooleanField,
- &GetByteField,
- &GetCharField,
- &GetShortField,
- &GetIntField,
- &GetLongField,
- &GetFloatField,
- &GetDoubleField,
- &SetObjectField,
- &SetBooleanField,
- &SetByteField,
- &SetCharField,
- &SetShortField,
- &SetIntField,
- &SetLongField,
- &SetFloatField,
- &SetDoubleField,
-
- &GetStaticMethodID,
-
- &CallStaticObjectMethod,
- &CallStaticObjectMethodV,
- &CallStaticObjectMethodA,
- &CallStaticBooleanMethod,
- &CallStaticBooleanMethodV,
- &CallStaticBooleanMethodA,
- &CallStaticByteMethod,
- &CallStaticByteMethodV,
- &CallStaticByteMethodA,
- &CallStaticCharMethod,
- &CallStaticCharMethodV,
- &CallStaticCharMethodA,
- &CallStaticShortMethod,
- &CallStaticShortMethodV,
- &CallStaticShortMethodA,
- &CallStaticIntMethod,
- &CallStaticIntMethodV,
- &CallStaticIntMethodA,
- &CallStaticLongMethod,
- &CallStaticLongMethodV,
- &CallStaticLongMethodA,
- &CallStaticFloatMethod,
- &CallStaticFloatMethodV,
- &CallStaticFloatMethodA,
- &CallStaticDoubleMethod,
- &CallStaticDoubleMethodV,
- &CallStaticDoubleMethodA,
- &CallStaticVoidMethod,
- &CallStaticVoidMethodV,
- &CallStaticVoidMethodA,
-
- &GetStaticFieldID,
-
- &GetStaticObjectField,
- &GetStaticBooleanField,
- &GetStaticByteField,
- &GetStaticCharField,
- &GetStaticShortField,
- &GetStaticIntField,
- &GetStaticLongField,
- &GetStaticFloatField,
- &GetStaticDoubleField,
- &SetStaticObjectField,
- &SetStaticBooleanField,
- &SetStaticByteField,
- &SetStaticCharField,
- &SetStaticShortField,
- &SetStaticIntField,
- &SetStaticLongField,
- &SetStaticFloatField,
- &SetStaticDoubleField,
-
- &NewString,
- &GetStringLength,
- &GetStringChars,
- &ReleaseStringChars,
-
- &NewStringUTF,
- &GetStringUTFLength,
- &GetStringUTFChars,
- &ReleaseStringUTFChars,
-
- &GetArrayLength,
-
- &NewObjectArray,
- &GetObjectArrayElement,
- &SetObjectArrayElement,
-
- &NewBooleanArray,
- &NewByteArray,
- &NewCharArray,
- &NewShortArray,
- &NewIntArray,
- &NewLongArray,
- &NewFloatArray,
- &NewDoubleArray,
-
- &GetBooleanArrayElements,
- &GetByteArrayElements,
- &GetCharArrayElements,
- &GetShortArrayElements,
- &GetIntArrayElements,
- &GetLongArrayElements,
- &GetFloatArrayElements,
- &GetDoubleArrayElements,
-
- &ReleaseBooleanArrayElements,
- &ReleaseByteArrayElements,
- &ReleaseCharArrayElements,
- &ReleaseShortArrayElements,
- &ReleaseIntArrayElements,
- &ReleaseLongArrayElements,
- &ReleaseFloatArrayElements,
- &ReleaseDoubleArrayElements,
-
- &GetBooleanArrayRegion,
- &GetByteArrayRegion,
- &GetCharArrayRegion,
- &GetShortArrayRegion,
- &GetIntArrayRegion,
- &GetLongArrayRegion,
- &GetFloatArrayRegion,
- &GetDoubleArrayRegion,
- &SetBooleanArrayRegion,
- &SetByteArrayRegion,
- &SetCharArrayRegion,
- &SetShortArrayRegion,
- &SetIntArrayRegion,
- &SetLongArrayRegion,
- &SetFloatArrayRegion,
- &SetDoubleArrayRegion,
-
- &RegisterNatives,
- &UnregisterNatives,
-
- &MonitorEnter,
- &MonitorExit,
-
- &GetJavaVM,
+ _Jv_JNI_GetVersion,
+
+ _Jv_JNI_DefineClass,
+ _Jv_JNI_FindClass,
+ _Jv_JNI_FromReflectedMethod,
+ _Jv_JNI_FromReflectedField,
+ _Jv_JNI_ToReflectedMethod,
+ _Jv_JNI_GetSuperclass,
+ _Jv_JNI_IsAssignableFrom,
+ _Jv_JNI_ToReflectedField,
+
+ _Jv_JNI_Throw,
+ _Jv_JNI_ThrowNew,
+ _Jv_JNI_ExceptionOccurred,
+ _Jv_JNI_ExceptionDescribe,
+ _Jv_JNI_ExceptionClear,
+ _Jv_JNI_FatalError,
+ _Jv_JNI_PushLocalFrame,
+ _Jv_JNI_PopLocalFrame,
+
+ _Jv_JNI_NewGlobalRef,
+ _Jv_JNI_DeleteGlobalRef,
+ _Jv_JNI_DeleteLocalRef,
+ _Jv_JNI_IsSameObject,
+ _Jv_JNI_NewLocalRef,
+ _Jv_JNI_EnsureLocalCapacity,
+
+ _Jv_JNI_AllocObject,
+ _Jv_JNI_NewObject,
+ _Jv_JNI_NewObjectV,
+ _Jv_JNI_NewObjectA,
+
+ _Jv_JNI_GetObjectClass,
+ _Jv_JNI_IsInstanceOf,
+
+ _Jv_JNI_GetMethodID,
+
+ _Jv_JNI_CallObjectMethod,
+ _Jv_JNI_CallObjectMethodV,
+ _Jv_JNI_CallObjectMethodA,
+ _Jv_JNI_CallBooleanMethod,
+ _Jv_JNI_CallBooleanMethodV,
+ _Jv_JNI_CallBooleanMethodA,
+ _Jv_JNI_CallByteMethod,
+ _Jv_JNI_CallByteMethodV,
+ _Jv_JNI_CallByteMethodA,
+ _Jv_JNI_CallCharMethod,
+ _Jv_JNI_CallCharMethodV,
+ _Jv_JNI_CallCharMethodA,
+ _Jv_JNI_CallShortMethod,
+ _Jv_JNI_CallShortMethodV,
+ _Jv_JNI_CallShortMethodA,
+ _Jv_JNI_CallIntMethod,
+ _Jv_JNI_CallIntMethodV,
+ _Jv_JNI_CallIntMethodA,
+ _Jv_JNI_CallLongMethod,
+ _Jv_JNI_CallLongMethodV,
+ _Jv_JNI_CallLongMethodA,
+ _Jv_JNI_CallFloatMethod,
+ _Jv_JNI_CallFloatMethodV,
+ _Jv_JNI_CallFloatMethodA,
+ _Jv_JNI_CallDoubleMethod,
+ _Jv_JNI_CallDoubleMethodV,
+ _Jv_JNI_CallDoubleMethodA,
+ _Jv_JNI_CallVoidMethod,
+ _Jv_JNI_CallVoidMethodV,
+ _Jv_JNI_CallVoidMethodA,
+
+ _Jv_JNI_CallNonvirtualObjectMethod,
+ _Jv_JNI_CallNonvirtualObjectMethodV,
+ _Jv_JNI_CallNonvirtualObjectMethodA,
+ _Jv_JNI_CallNonvirtualBooleanMethod,
+ _Jv_JNI_CallNonvirtualBooleanMethodV,
+ _Jv_JNI_CallNonvirtualBooleanMethodA,
+ _Jv_JNI_CallNonvirtualByteMethod,
+ _Jv_JNI_CallNonvirtualByteMethodV,
+ _Jv_JNI_CallNonvirtualByteMethodA,
+ _Jv_JNI_CallNonvirtualCharMethod,
+ _Jv_JNI_CallNonvirtualCharMethodV,
+ _Jv_JNI_CallNonvirtualCharMethodA,
+ _Jv_JNI_CallNonvirtualShortMethod,
+ _Jv_JNI_CallNonvirtualShortMethodV,
+ _Jv_JNI_CallNonvirtualShortMethodA,
+ _Jv_JNI_CallNonvirtualIntMethod,
+ _Jv_JNI_CallNonvirtualIntMethodV,
+ _Jv_JNI_CallNonvirtualIntMethodA,
+ _Jv_JNI_CallNonvirtualLongMethod,
+ _Jv_JNI_CallNonvirtualLongMethodV,
+ _Jv_JNI_CallNonvirtualLongMethodA,
+ _Jv_JNI_CallNonvirtualFloatMethod,
+ _Jv_JNI_CallNonvirtualFloatMethodV,
+ _Jv_JNI_CallNonvirtualFloatMethodA,
+ _Jv_JNI_CallNonvirtualDoubleMethod,
+ _Jv_JNI_CallNonvirtualDoubleMethodV,
+ _Jv_JNI_CallNonvirtualDoubleMethodA,
+ _Jv_JNI_CallNonvirtualVoidMethod,
+ _Jv_JNI_CallNonvirtualVoidMethodV,
+ _Jv_JNI_CallNonvirtualVoidMethodA,
+
+ _Jv_JNI_GetFieldID,
+
+ _Jv_JNI_GetObjectField,
+ _Jv_JNI_GetBooleanField,
+ _Jv_JNI_GetByteField,
+ _Jv_JNI_GetCharField,
+ _Jv_JNI_GetShortField,
+ _Jv_JNI_GetIntField,
+ _Jv_JNI_GetLongField,
+ _Jv_JNI_GetFloatField,
+ _Jv_JNI_GetDoubleField,
+ _Jv_JNI_SetObjectField,
+ _Jv_JNI_SetBooleanField,
+ _Jv_JNI_SetByteField,
+ _Jv_JNI_SetCharField,
+ _Jv_JNI_SetShortField,
+ _Jv_JNI_SetIntField,
+ _Jv_JNI_SetLongField,
+ _Jv_JNI_SetFloatField,
+ _Jv_JNI_SetDoubleField,
+
+ _Jv_JNI_GetStaticMethodID,
+
+ _Jv_JNI_CallStaticObjectMethod,
+ _Jv_JNI_CallStaticObjectMethodV,
+ _Jv_JNI_CallStaticObjectMethodA,
+ _Jv_JNI_CallStaticBooleanMethod,
+ _Jv_JNI_CallStaticBooleanMethodV,
+ _Jv_JNI_CallStaticBooleanMethodA,
+ _Jv_JNI_CallStaticByteMethod,
+ _Jv_JNI_CallStaticByteMethodV,
+ _Jv_JNI_CallStaticByteMethodA,
+ _Jv_JNI_CallStaticCharMethod,
+ _Jv_JNI_CallStaticCharMethodV,
+ _Jv_JNI_CallStaticCharMethodA,
+ _Jv_JNI_CallStaticShortMethod,
+ _Jv_JNI_CallStaticShortMethodV,
+ _Jv_JNI_CallStaticShortMethodA,
+ _Jv_JNI_CallStaticIntMethod,
+ _Jv_JNI_CallStaticIntMethodV,
+ _Jv_JNI_CallStaticIntMethodA,
+ _Jv_JNI_CallStaticLongMethod,
+ _Jv_JNI_CallStaticLongMethodV,
+ _Jv_JNI_CallStaticLongMethodA,
+ _Jv_JNI_CallStaticFloatMethod,
+ _Jv_JNI_CallStaticFloatMethodV,
+ _Jv_JNI_CallStaticFloatMethodA,
+ _Jv_JNI_CallStaticDoubleMethod,
+ _Jv_JNI_CallStaticDoubleMethodV,
+ _Jv_JNI_CallStaticDoubleMethodA,
+ _Jv_JNI_CallStaticVoidMethod,
+ _Jv_JNI_CallStaticVoidMethodV,
+ _Jv_JNI_CallStaticVoidMethodA,
+
+ _Jv_JNI_GetStaticFieldID,
+
+ _Jv_JNI_GetStaticObjectField,
+ _Jv_JNI_GetStaticBooleanField,
+ _Jv_JNI_GetStaticByteField,
+ _Jv_JNI_GetStaticCharField,
+ _Jv_JNI_GetStaticShortField,
+ _Jv_JNI_GetStaticIntField,
+ _Jv_JNI_GetStaticLongField,
+ _Jv_JNI_GetStaticFloatField,
+ _Jv_JNI_GetStaticDoubleField,
+ _Jv_JNI_SetStaticObjectField,
+ _Jv_JNI_SetStaticBooleanField,
+ _Jv_JNI_SetStaticByteField,
+ _Jv_JNI_SetStaticCharField,
+ _Jv_JNI_SetStaticShortField,
+ _Jv_JNI_SetStaticIntField,
+ _Jv_JNI_SetStaticLongField,
+ _Jv_JNI_SetStaticFloatField,
+ _Jv_JNI_SetStaticDoubleField,
+
+ _Jv_JNI_NewString,
+ _Jv_JNI_GetStringLength,
+ _Jv_JNI_GetStringChars,
+ _Jv_JNI_ReleaseStringChars,
+
+ _Jv_JNI_NewStringUTF,
+ _Jv_JNI_GetStringUTFLength,
+ _Jv_JNI_GetStringUTFChars,
+ _Jv_JNI_ReleaseStringUTFChars,
+
+ _Jv_JNI_GetArrayLength,
+
+ _Jv_JNI_NewObjectArray,
+ _Jv_JNI_GetObjectArrayElement,
+ _Jv_JNI_SetObjectArrayElement,
+
+ _Jv_JNI_NewBooleanArray,
+ _Jv_JNI_NewByteArray,
+ _Jv_JNI_NewCharArray,
+ _Jv_JNI_NewShortArray,
+ _Jv_JNI_NewIntArray,
+ _Jv_JNI_NewLongArray,
+ _Jv_JNI_NewFloatArray,
+ _Jv_JNI_NewDoubleArray,
+
+ _Jv_JNI_GetBooleanArrayElements,
+ _Jv_JNI_GetByteArrayElements,
+ _Jv_JNI_GetCharArrayElements,
+ _Jv_JNI_GetShortArrayElements,
+ _Jv_JNI_GetIntArrayElements,
+ _Jv_JNI_GetLongArrayElements,
+ _Jv_JNI_GetFloatArrayElements,
+ _Jv_JNI_GetDoubleArrayElements,
+
+ _Jv_JNI_ReleaseBooleanArrayElements,
+ _Jv_JNI_ReleaseByteArrayElements,
+ _Jv_JNI_ReleaseCharArrayElements,
+ _Jv_JNI_ReleaseShortArrayElements,
+ _Jv_JNI_ReleaseIntArrayElements,
+ _Jv_JNI_ReleaseLongArrayElements,
+ _Jv_JNI_ReleaseFloatArrayElements,
+ _Jv_JNI_ReleaseDoubleArrayElements,
+
+ _Jv_JNI_GetBooleanArrayRegion,
+ _Jv_JNI_GetByteArrayRegion,
+ _Jv_JNI_GetCharArrayRegion,
+ _Jv_JNI_GetShortArrayRegion,
+ _Jv_JNI_GetIntArrayRegion,
+ _Jv_JNI_GetLongArrayRegion,
+ _Jv_JNI_GetFloatArrayRegion,
+ _Jv_JNI_GetDoubleArrayRegion,
+ _Jv_JNI_SetBooleanArrayRegion,
+ _Jv_JNI_SetByteArrayRegion,
+ _Jv_JNI_SetCharArrayRegion,
+ _Jv_JNI_SetShortArrayRegion,
+ _Jv_JNI_SetIntArrayRegion,
+ _Jv_JNI_SetLongArrayRegion,
+ _Jv_JNI_SetFloatArrayRegion,
+ _Jv_JNI_SetDoubleArrayRegion,
+
+ _Jv_JNI_RegisterNatives,
+ _Jv_JNI_UnregisterNatives,
+
+ _Jv_JNI_MonitorEnter,
+ _Jv_JNI_MonitorExit,
+
+ _Jv_JNI_GetJavaVM,
/* new JNI 1.2 functions */
- &GetStringRegion,
- &GetStringUTFRegion,
+ _Jv_JNI_GetStringRegion,
+ _Jv_JNI_GetStringUTFRegion,
- &GetPrimitiveArrayCritical,
- &ReleasePrimitiveArrayCritical,
+ _Jv_JNI_GetPrimitiveArrayCritical,
+ _Jv_JNI_ReleasePrimitiveArrayCritical,
- &GetStringCritical,
- &ReleaseStringCritical,
+ _Jv_JNI_GetStringCritical,
+ _Jv_JNI_ReleaseStringCritical,
- &NewWeakGlobalRef,
- &DeleteWeakGlobalRef,
+ _Jv_JNI_NewWeakGlobalRef,
+ _Jv_JNI_DeleteWeakGlobalRef,
- &ExceptionCheck,
+ _Jv_JNI_ExceptionCheck,
/* new JNI 1.4 functions */
- &NewDirectByteBuffer,
- &GetDirectBufferAddress,
- &GetDirectBufferCapacity
+ _Jv_JNI_NewDirectByteBuffer,
+ _Jv_JNI_GetDirectBufferAddress,
+ _Jv_JNI_GetDirectBufferCapacity
};
jint JNI_GetDefaultJavaVMInitArgs(void *vm_args)
{
- JDK1_1InitArgs *_vm_args = (JDK1_1InitArgs *) vm_args;
+ JavaVMInitArgs *_vm_args;
+
+ _vm_args = (JavaVMInitArgs *) vm_args;
/* GNU classpath currently supports JNI 1.2 */
- _vm_args->version = JNI_VERSION_1_2;
+ switch (_vm_args->version) {
+ case JNI_VERSION_1_1:
+ _vm_args->version = JNI_VERSION_1_1;
+ break;
+
+ case JNI_VERSION_1_2:
+ case JNI_VERSION_1_4:
+ _vm_args->ignoreUnrecognized = JNI_FALSE;
+ _vm_args->options = NULL;
+ _vm_args->nOptions = 0;
+ break;
+ default:
+ return -1;
+ }
+
return 0;
}
*******************************************************************************/
-jint JNI_CreateJavaVM(JavaVM **p_vm, JNIEnv **p_env, void *vm_args)
+jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args)
{
- const struct JNIInvokeInterface *vm;
- struct JNINativeInterface *env;
+ /* actually create the JVM */
- vm = &JNI_JavaVMTable;
- env = &JNI_JNIEnvTable;
-
- *p_vm = (JavaVM *) vm;
- *p_env = (JNIEnv *) env;
+ if (!vm_createjvm(p_vm, p_env, vm_args))
+ return JNI_ERR;
- return 0;
+ return JNI_OK;
}
projects / cacao.git / blobdiff