X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fnative%2Fjni.c;h=a011a0f0fe38b729ba56b189f2ebd184a4a47fab;hb=c2773616396e371383015b60aa59feb1f6d665b0;hp=b247ef3e7c47f4880981ba9f2294c2ccdf93e764;hpb=11f2993f914ac524770a41465aad8a6810f0a257;p=cacao.git diff --git a/src/native/jni.c b/src/native/jni.c index b247ef3e7..a011a0f0f 100644 --- a/src/native/jni.c +++ b/src/native/jni.c @@ -1,9 +1,9 @@ /* src/native/jni.c - implementation of the Java Native Interface functions - Copyright (C) 1996-2005 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 + 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 This file is part of CACAO. @@ -19,39 +19,36 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. - Contact: cacao@complang.tuwien.ac.at - - Authors: Rainhard Grafl - Roman Obermaisser - - Changes: Joseph Wenninger - Martin Platter - Christian Thalinger - - $Id: jni.c 3549 2005-11-03 20:40:52Z twisti $ + $Id: jni.c 7723 2007-04-16 18:03:08Z michi $ */ +#include "config.h" + #include #include -#include "config.h" +#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" @@ -63,106 +60,107 @@ #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/tables.h" +#include "vm/vm.h" + #include "vm/jit/asmpart.h" #include "vm/jit/jit.h" -#include "vm/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; +#include "vm/jit/stacktrace.h" +#include "vmcore/loader.h" +#include "vmcore/options.h" +#include "vm/resolve.h" +#include "vmcore/statistics.h" -#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 */ -/* 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; +#define HASHTABLE_GLOBAL_REF_SIZE 64 /* initial size of globalref-hash */ +hashtable *hashtable_global_ref; /* hashtable for globalrefs */ -/* direct buffer stuff ********************************************************/ -static utf *utf_java_nio_DirectByteBufferImpl; -#if SIZEOF_VOID_P == 8 -static utf *utf_gnu_classpath_Pointer64; -#else -static utf *utf_gnu_classpath_Pointer32; -#endif +/* direct buffer stuff ********************************************************/ +#if defined(ENABLE_JAVASE) +static classinfo *class_java_nio_Buffer; static classinfo *class_java_nio_DirectByteBufferImpl; -#if SIZEOF_VOID_P == 8 +static classinfo *class_java_nio_DirectByteBufferImpl_ReadWrite; + +# 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 + +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 **********************************/ +/* accessing instance fields macros *******************************************/ -#define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val; -#define getField(obj,typ,var) *((typ*) ((long int) obj + (long int) var->offset)) -#define setfield_critical(clazz,obj,name,sig,jdatatype,val) \ - setField(obj, jdatatype, getFieldID_critical(env,clazz,name,sig), val); +#define SET_FIELD(o,type,f,value) \ + *((type *) ((ptrint) (o) + (ptrint) ((fieldinfo *) (f))->offset)) = (type) (value) + +#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 ******************************************************************** @@ -173,153 +171,135 @@ jobject NewLocalRef(JNIEnv *env, jobject ref); bool jni_init(void) { - /* initalize global reference table */ + /* create global ref hashtable */ - if (!(ihmclass = - load_class_bootstrap(utf_new_char("java/util/IdentityHashMap")))) - return false; + hashtable_global_ref = NEW(hashtable); - global_ref_table = GCNEW(jobject, 1); + hashtable_create(hashtable_global_ref, HASHTABLE_GLOBAL_REF_SIZE); - if (!(*global_ref_table = native_new_and_init(ihmclass))) + +#if defined(ENABLE_JAVASE) + /* direct buffer stuff */ + + if (!(class_java_nio_Buffer = + load_class_bootstrap(utf_new_char("java/nio/Buffer"))) || + !link_class(class_java_nio_Buffer)) return false; - if (!(getmid = class_resolvemethod(ihmclass, utf_get, - utf_java_lang_Object__java_lang_Object))) + if (!(class_java_nio_DirectByteBufferImpl = + load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl"))) || + !link_class(class_java_nio_DirectByteBufferImpl)) return false; - if (!(putmid = class_resolvemethod(ihmclass, utf_put, - utf_new_char("(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;")))) + if (!(class_java_nio_DirectByteBufferImpl_ReadWrite = + load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl$ReadWrite"))) || + !link_class(class_java_nio_DirectByteBufferImpl_ReadWrite)) return false; - if (!(removemid = - class_resolvemethod(ihmclass, utf_remove, - utf_java_lang_Object__java_lang_Object))) + if (!(dbbirw_init = + class_resolvemethod(class_java_nio_DirectByteBufferImpl_ReadWrite, + utf_init, + utf_new_char("(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V")))) return false; +# 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 + 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 /* defined(ENABLE_JAVASE) */ - /* direct buffer stuff */ + return true; +} - utf_java_nio_DirectByteBufferImpl = - utf_new_char("java/nio/DirectByteBufferImpl"); - if (!(class_java_nio_DirectByteBufferImpl = - load_class_bootstrap(utf_java_nio_DirectByteBufferImpl))) - return false; +/* jni_init_localref_table ***************************************************** - if (!link_class(class_java_nio_DirectByteBufferImpl)) - return false; + Initializes the local references table of the current thread. -#if SIZEOF_VOID_P == 8 - utf_gnu_classpath_Pointer64 = utf_new_char("gnu/classpath/Pointer64"); +*******************************************************************************/ - if (!(class_gnu_classpath_Pointer64 = - load_class_bootstrap(utf_gnu_classpath_Pointer64))) - return false; +bool jni_init_localref_table(void) +{ + localref_table *lrt; - if (!link_class(class_gnu_classpath_Pointer64)) - return false; +#if defined(ENABLE_GC_CACAO) + /* XXX this one will never get freed for the main thread; + call jni_free_localref_table() if you want to do it! */ + lrt = NEW(localref_table); #else - utf_gnu_classpath_Pointer32 = utf_new_char("gnu/classpath/Pointer32"); + lrt = GCNEW(localref_table); +#endif - if (!(class_gnu_classpath_Pointer32 = - load_class_bootstrap(utf_gnu_classpath_Pointer32))) + if (lrt == NULL) return false; - if (!link_class(class_gnu_classpath_Pointer32)) - return false; -#endif + lrt->capacity = LOCALREFTABLE_CAPACITY; + lrt->used = 0; + lrt->localframes = 1; + lrt->prev = LOCALREFTABLE; - return true; -} + /* clear the references array (memset is faster then a for-loop) */ + MSET(lrt->refs, 0, java_objectheader*, LOCALREFTABLE_CAPACITY); -static void fill_callblock_from_vargs(void *obj, methoddesc *descr, - jni_callblock blk[], va_list data, - s4 rettype) -{ - typedesc *paramtypes; - s4 i; + LOCALREFTABLE = lrt; - paramtypes = descr->paramtypes; + return true; +} - /* if method is non-static fill first block and skip `this' pointer */ - i = 0; +/* jni_init_localref_table ***************************************************** - if (obj) { - /* the `this' pointer */ - blk[0].itemtype = TYPE_ADR; - blk[0].item = PTR_TO_ITEM(obj); + Frees the local references table of the current thread. - paramtypes++; - i++; - } +*******************************************************************************/ - for (; i < descr->paramcount; i++, paramtypes++) { - switch (paramtypes->decltype) { - /* primitive types */ - case PRIMITIVETYPE_BYTE: - case PRIMITIVETYPE_CHAR: - case PRIMITIVETYPE_SHORT: - case PRIMITIVETYPE_BOOLEAN: - blk[i].itemtype = TYPE_INT; - blk[i].item = (s8) va_arg(data, s4); - break; +bool jni_free_localref_table(void) +{ + localref_table *lrt; - case PRIMITIVETYPE_INT: - blk[i].itemtype = TYPE_INT; - blk[i].item = (s8) va_arg(data, s4); - break; +#if defined(ENABLE_GC_CACAO) + lrt = LOCALREFTABLE; - case PRIMITIVETYPE_LONG: - blk[i].itemtype = TYPE_LNG; - blk[i].item = (s8) va_arg(data, s8); - break; + assert(lrt); + assert(lrt->prev == NULL); - case PRIMITIVETYPE_FLOAT: - blk[i].itemtype = TYPE_FLT; -#if defined(__ALPHA__) - /* this keeps the assembler function much simpler */ + FREE(lrt, localref_table); - *((jdouble *) (&blk[i].item)) = (jdouble) va_arg(data, jdouble); -#else - *((jfloat *) (&blk[i].item)) = (jfloat) va_arg(data, jdouble); + LOCALREFTABLE = NULL; #endif - break; - - case PRIMITIVETYPE_DOUBLE: - blk[i].itemtype = TYPE_DBL; - *((jdouble *) (&blk[i].item)) = (jdouble) va_arg(data, jdouble); - break; - case TYPE_ADR: - blk[i].itemtype = TYPE_ADR; - blk[i].item = PTR_TO_ITEM(va_arg(data, void*)); - break; - } - } + 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; @@ -328,10 +308,10 @@ static bool fill_callblock_from_objectarray(void *obj, methoddesc *descr, 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--; @@ -342,15 +322,16 @@ static bool fill_callblock_from_objectarray(void *obj, methoddesc *descr, 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 */ @@ -359,86 +340,98 @@ static bool fill_callblock_from_objectarray(void *obj, methoddesc *descr, 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_Float *) 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; if (params->data[j] != 0) { if (paramtypes->arraydim > 0) { - if (!builtin_arrayinstanceof(params->data[j], c->vftbl)) + if (!builtin_arrayinstanceof(params->data[j], c)) goto illegal_arg; } else { @@ -446,15 +439,15 @@ static bool fill_callblock_from_objectarray(void *obj, methoddesc *descr, 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; */ @@ -462,422 +455,772 @@ static bool fill_callblock_from_objectarray(void *obj, methoddesc *descr, return true; illegal_arg: - *exceptionptr = new_exception(string_java_lang_IllegalArgumentException); + exceptions_throw_illegalargumentexception(); return false; } -static jmethodID get_virtual(jobject obj, jmethodID methodID) -{ - if (obj->vftbl->class == methodID->class) - return methodID; +/* _Jv_jni_CallObjectMethod **************************************************** - return class_resolvemethod(obj->vftbl->class, methodID->name, - methodID->descriptor); -} + Internal function to call Java Object methods. +*******************************************************************************/ -static jmethodID get_nonvirtual(jclass clazz, jmethodID methodID) +static java_objectheader *_Jv_jni_CallObjectMethod(java_objectheader *o, + vftbl_t *vftbl, + methodinfo *m, va_list ap) { - if (clazz == methodID->class) - return methodID; + methodinfo *resm; + java_objectheader *ro; - /* class_resolvemethod -> classfindmethod? (JOWENN) */ - return class_resolvemethod(clazz, methodID->name, methodID->descriptor); -} + STATISTICS(jniinvokation()); + if (m == NULL) { + exceptions_throw_nullpointerexception(); + return NULL; + } -static jobject callObjectMethod(jobject obj, jmethodID methodID, va_list args) -{ - int argcount; - jni_callblock *blk; - jobject ret; + /* Class initialization is done by the JIT compiler. This is ok + since a static method always belongs to the declaring class. */ - if (methodID == 0) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; - } + if (m->flags & ACC_STATIC) { + /* For static methods we reset the object. */ - if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) || - ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; - } + if (o != NULL) + o = NULL; - if (obj && !builtin_instanceof(obj, methodID->class)) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; + /* for convenience */ + + resm = m; + + } else { + /* For instance methods we make a virtual function table lookup. */ + + resm = method_vftbl_lookup(vftbl, m); } - argcount = methodID->parseddesc->paramcount; + STATISTICS(jnicallXmethodnvokation()); - blk = MNEW(jni_callblock, argcount); + ro = vm_call_method_valist(resm, o, ap); - fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, TYPE_ADR); + return ro; +} - STATS(jnicallXmethodnvokation();) - ret = asm_calljavafunction2(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); +/* _Jv_jni_CallObjectMethodA *************************************************** - MFREE(blk, jni_callblock, argcount); + Internal function to call Java Object methods. - return ret; -} +*******************************************************************************/ +static java_objectheader *_Jv_jni_CallObjectMethodA(java_objectheader *o, + vftbl_t *vftbl, + methodinfo *m, jvalue *args) +{ + methodinfo *resm; + java_objectheader *ro; -/* - core function for integer class methods (bool, byte, short, integer) - This is basically needed for i386 -*/ -static jint callIntegerMethod(jobject obj, jmethodID methodID, int retType, va_list args) -{ - int argcount; - jni_callblock *blk; - jint ret; - - STATS(jniinvokation();) - - /* - log_text("JNI-Call: CallObjectMethodV"); - utf_display(methodID->name); - utf_display(methodID->descriptor); - printf("\nParmaeter count: %d\n",argcount); - utf_display(obj->vftbl->class->name); - printf("\n"); - */ - if (methodID == 0) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; - } - - if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) || - ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; - } + STATISTICS(jniinvokation()); - if (obj && !builtin_instanceof(obj, methodID->class)) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; + if (m == NULL) { + exceptions_throw_nullpointerexception(); + return NULL; } - argcount = methodID->parseddesc->paramcount; + /* 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; - blk = MNEW(jni_callblock, argcount); + /* for convenience */ - fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, retType); + resm = m; - STATS(jnicallXmethodnvokation();) + } else { + /* For instance methods we make a virtual function table lookup. */ + + resm = method_vftbl_lookup(vftbl, m); + } - ret = asm_calljavafunction2int(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); + STATISTICS(jnicallXmethodnvokation()); - MFREE(blk, jni_callblock, argcount); + ro = vm_call_method_jvalue(resm, o, args); - return ret; + return ro; } -/* callLongMethod ************************************************************** +/* _Jv_jni_CallIntMethod ******************************************************* - Core function for long class functions. + Internal function to call Java integer class methods (boolean, + byte, char, short, int). *******************************************************************************/ -static jlong callLongMethod(jobject obj, jmethodID methodID, va_list args) +static jint _Jv_jni_CallIntMethod(java_objectheader *o, vftbl_t *vftbl, + methodinfo *m, va_list ap) { - s4 argcount; - jni_callblock *blk; - jlong ret; + methodinfo *resm; + jint i; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - if (methodID == 0) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); + 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 (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) || - ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; - } + if (m->flags & ACC_STATIC) { + /* For static methods we reset the object. */ - if (obj && !builtin_instanceof(obj, methodID->class)) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return 0; - } + if (o != NULL) + o = NULL; - argcount = methodID->parseddesc->paramcount; + /* for convenience */ - blk = MNEW(jni_callblock, argcount); + resm = m; - fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, TYPE_LNG); + } else { + /* For instance methods we make a virtual function table lookup. */ - STATS(jnicallXmethodnvokation();) + resm = method_vftbl_lookup(vftbl, m); + } - ret = asm_calljavafunction2long(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); + STATISTICS(jnicallXmethodnvokation()); - MFREE(blk, jni_callblock, argcount); + i = vm_call_method_int_valist(resm, o, ap); - return ret; + return i; } -/*core function for float class methods (float,double)*/ -static jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,int retType) -{ - int argcount = methodID->parseddesc->paramcount; - jni_callblock *blk; - jdouble ret; +/* _Jv_jni_CallIntMethodA ****************************************************** - STATS(jniinvokation();) + Internal function to call Java integer class methods (boolean, + byte, char, short, int). - assert(0); +*******************************************************************************/ + +static jint _Jv_jni_CallIntMethodA(java_objectheader *o, vftbl_t *vftbl, + methodinfo *m, jvalue *args) +{ + methodinfo *resm; + jint i; + + STATISTICS(jniinvokation()); - if (argcount > 3) { - *exceptionptr = new_exception(string_java_lang_IllegalArgumentException); - log_text("Too many arguments. CallObjectMethod does not support that"); + 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 */ - blk = MNEW(jni_callblock, /*4 */ argcount+2); + resm = m; - fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, retType); + } else { + /* For instance methods we make a virtual function table lookup. */ + + resm = method_vftbl_lookup(vftbl, m); + } - /* printf("parameter: obj: %p",blk[0].item); */ - STATS(jnicallXmethodnvokation();) - ret = asm_calljavafunction2double(methodID, - argcount + 1, - (argcount + 1) * sizeof(jni_callblock), - blk); + STATISTICS(jnicallXmethodnvokation()); - MFREE(blk, jni_callblock, argcount + 1); - /* printf("(CallObjectMethodV)-->%p\n",ret); */ + i = vm_call_method_int_jvalue(resm, o, args); - return ret; + return i; } -static void cacao_jni_CallVoidMethod(jobject obj, jmethodID m, va_list ap) -{ - s4 paramcount; - jni_callblock *blk; +/* _Jv_jni_CallLongMethod ****************************************************** - if (m == 0) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return; - } + Internal function to call Java long methods. - if (!( ((m->flags & ACC_STATIC) && (obj == 0)) || - ((!(m->flags & ACC_STATIC)) && (obj != 0)) )) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return; - } +*******************************************************************************/ - if (obj && !builtin_instanceof(obj, m->class)) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return; +static jlong _Jv_jni_CallLongMethod(java_objectheader *o, vftbl_t *vftbl, + methodinfo *m, va_list ap) +{ + methodinfo *resm; + jlong l; + + STATISTICS(jniinvokation()); + + if (m == NULL) { + exceptions_throw_nullpointerexception(); + return 0; } - paramcount = m->parseddesc->paramcount; + /* 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)) - paramcount++; + if (m->flags & ACC_STATIC) { + /* For static methods we reset the object. */ + + if (o != NULL) + o = NULL; - blk = MNEW(jni_callblock, paramcount); + /* for convenience */ - fill_callblock_from_vargs(obj, m->parseddesc, blk, ap, TYPE_VOID); + resm = m; - STATS(jnicallXmethodnvokation();) + } else { + /* For instance methods we make a virtual function table lookup. */ + + resm = method_vftbl_lookup(vftbl, m); + } - (void) asm_calljavafunction2(m, - paramcount, - paramcount * sizeof(jni_callblock), - blk); + STATISTICS(jnicallXmethodnvokation()); - MFREE(blk, jni_callblock, paramcount); + l = vm_call_method_long_valist(resm, o, ap); - return; + return l; } -/* GetVersion ****************************************************************** +/* _Jv_jni_CallFloatMethod ***************************************************** - Returns the major version number in the higher 16 bits and the - minor version number in the lower 16 bits. + Internal function to call Java float methods. *******************************************************************************/ -jint GetVersion(JNIEnv *env) +static jfloat _Jv_jni_CallFloatMethod(java_objectheader *o, vftbl_t *vftbl, + methodinfo *m, va_list ap) { - STATS(jniinvokation();) - - /* we support JNI 1.4 */ + methodinfo *resm; + jfloat f; - return JNI_VERSION_1_4; -} + /* 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. */ -/* Class Operations ***********************************************************/ - -/* DefineClass ***************************************************************** + if (o != NULL) + o = NULL; - Loads a class from a buffer of raw class data. The buffer - containing the raw class data is not referenced by the VM after the - DefineClass call returns, and it may be discarded if desired. + /* for convenience */ -*******************************************************************************/ + resm = m; -jclass DefineClass(JNIEnv *env, const char *name, jobject loader, - const jbyte *buf, jsize bufLen) -{ - java_lang_ClassLoader *cl; - java_lang_String *s; - java_bytearray *ba; - jclass c; + } else { + /* For instance methods we make a virtual function table lookup. */ - STATS(jniinvokation();) + resm = method_vftbl_lookup(vftbl, m); + } - cl = (java_lang_ClassLoader *) loader; - s = javastring_new_char(name); - ba = (java_bytearray *) buf; + STATISTICS(jnicallXmethodnvokation()); - c = (jclass) Java_java_lang_VMClassLoader_defineClass(env, NULL, cl, s, ba, - 0, bufLen, NULL); + f = vm_call_method_float_valist(resm, o, ap); - return (jclass) NewLocalRef(env, (jobject) c); + return f; } -/* FindClass ******************************************************************* +/* _Jv_jni_CallDoubleMethod **************************************************** - This function loads a locally-defined class. It searches the - directories and zip files specified by the CLASSPATH environment - variable for the class with the specified name. + Internal function to call Java double methods. *******************************************************************************/ -jclass FindClass(JNIEnv *env, const char *name) +static jdouble _Jv_jni_CallDoubleMethod(java_objectheader *o, vftbl_t *vftbl, + methodinfo *m, va_list ap) { - utf *u; - classinfo *c; - java_objectheader *cl; + methodinfo *resm; + jdouble d; - STATS(jniinvokation();) + /* Class initialization is done by the JIT compiler. This is ok + since a static method always belongs to the declaring class. */ - u = utf_new_char_classname((char *) name); - - /* check stacktrace for classloader, if one found use it, otherwise use */ - /* the system classloader */ + if (m->flags & ACC_STATIC) { + /* For static methods we reset the object. */ -#if defined(__ALPHA__) || defined(__ARM__) || defined(__I386__) || defined(__MIPS__) || defined(__POWERPC__) || defined(__X86_64__) - /* these JITs support stacktraces, and so does the interpreter */ + if (o != NULL) + o = NULL; - cl = cacao_currentClassLoader(); -#else -# if defined(ENABLE_INTRP) - /* the interpreter supports stacktraces, even if the JIT does not */ + /* for convenience */ - if (opt_intrp) - cl = cacao_currentClassLoader(); - else -# endif - cl = NULL; -#endif + resm = m; - if (!(c = load_class_from_classloader(u, cl))) - return NULL; + } else { + /* For instance methods we make a virtual function table lookup. */ - if (!link_class(c)) - return NULL; + resm = method_vftbl_lookup(vftbl, m); + } - if (!use_class_as_object(c)) - return NULL; + d = vm_call_method_double_valist(resm, o, ap); - return (jclass) NewLocalRef(env, (jobject) c); + return d; } - -/* FromReflectedMethod ********************************************************* - Converts java.lang.reflect.Method or java.lang.reflect.Constructor - object to a method ID. - +/* _Jv_jni_CallVoidMethod ****************************************************** + + Internal function to call Java void methods. + *******************************************************************************/ - -jmethodID FromReflectedMethod(JNIEnv *env, jobject method) -{ - methodinfo *mi; - classinfo *c; - s4 slot; - STATS(jniinvokation();) +static void _Jv_jni_CallVoidMethod(java_objectheader *o, vftbl_t *vftbl, + methodinfo *m, va_list ap) +{ + methodinfo *resm; - if (method == NULL) - return NULL; - - if (builtin_instanceof(method, class_java_lang_reflect_Method)) { - java_lang_reflect_Method *rm; + if (m == NULL) { + exceptions_throw_nullpointerexception(); + return; + } - rm = (java_lang_reflect_Method *) method; - c = (classinfo *) (rm->declaringClass); - slot = rm->slot; + /* Class initialization is done by the JIT compiler. This is ok + since a static method always belongs to the declaring class. */ - } else if (builtin_instanceof(method, class_java_lang_reflect_Constructor)) { - java_lang_reflect_Constructor *rc; + if (m->flags & ACC_STATIC) { + /* For static methods we reset the object. */ - rc = (java_lang_reflect_Constructor *) method; - c = (classinfo *) (rc->clazz); - slot = rc->slot; + if (o != NULL) + o = NULL; - } else - return NULL; + /* for convenience */ - 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); + resm = m; + + } else { + /* For instance methods we make a virtual function table lookup. */ + + resm = method_vftbl_lookup(vftbl, m); } - mi = &(c->methods[slot]); + STATISTICS(jnicallXmethodnvokation()); - return mi; + (void) vm_call_method_valist(resm, o, ap); } -/* GetSuperclass *************************************************************** +/* _Jv_jni_CallVoidMethodA ***************************************************** - 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. + Internal function to call Java void methods. *******************************************************************************/ - -jclass GetSuperclass(JNIEnv *env, jclass sub) -{ - classinfo *c; - STATS(jniinvokation();) +static void _Jv_jni_CallVoidMethodA(java_objectheader *o, vftbl_t *vftbl, + methodinfo *m, jvalue *args) +{ + methodinfo *resm; - c = ((classinfo *) sub)->super.cls; + if (m == NULL) { + exceptions_throw_nullpointerexception(); + return; + } - if (!c) + /* Class initialization is done by the JIT compiler. This is ok + since a static method always belongs to the declaring class. */ + + if (m->flags & ACC_STATIC) { + /* For static methods we reset the object. */ + + if (o != NULL) + o = NULL; + + /* for convenience */ + + resm = m; + + } else { + /* For instance methods we make a virtual function table lookup. */ + + resm = method_vftbl_lookup(vftbl, m); + } + + STATISTICS(jnicallXmethodnvokation()); + + (void) vm_call_method_jvalue(resm, o, args); +} + + +/* _Jv_jni_invokeNative ******************************************************** + + Invoke a method on the given object with the given arguments. + + For instance methods OBJ must be != NULL and the method is looked up + in the vftbl of the object. + + For static methods, OBJ is ignored. + +*******************************************************************************/ + +java_objectheader *_Jv_jni_invokeNative(methodinfo *m, java_objectheader *o, + java_objectarray *params) +{ + methodinfo *resm; + vm_arg *vmargs; + java_objectheader *ro; + s4 argcount; + s4 paramcount; + java_objectheader *xptr; + + if (m == NULL) { + exceptions_throw_nullpointerexception(); + return NULL; + } + + argcount = m->parseddesc->paramcount; + paramcount = argcount; + + /* if method is non-static, remove the `this' pointer */ + + 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. */ + + if (!(m->flags & ACC_STATIC) && o && (!builtin_instanceof(o, m->class))) { + exceptions_throw_illegalargumentexception(); + return NULL; + } + + /* check if we got the right number of arguments */ + + if (((params == NULL) && (paramcount != 0)) || + (params && (params->header.size != paramcount))) + { + exceptions_throw_illegalargumentexception(); + return NULL; + } + + /* for instance methods we need an object */ + + 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 object to make subsequent code simpler */ + if (m->flags & ACC_STATIC) + o = NULL; + + if (o != NULL) { + /* for instance methods we must do a vftbl lookup */ + resm = method_vftbl_lookup(o->vftbl, m); + } + else { + /* for static methods, just for convenience */ + resm = m; + } + + vmargs = MNEW(vm_arg, argcount); + + if (!_Jv_jni_vmargs_from_objectarray(o, resm->parseddesc, vmargs, params)) { + MFREE(vmargs, vm_arg, argcount); + return NULL; + } + + switch (resm->parseddesc->returntype.decltype) { + case TYPE_VOID: + (void) vm_call_method_vmarg(resm, argcount, vmargs); + + ro = NULL; + break; + + case PRIMITIVETYPE_BOOLEAN: { + s4 i; + java_lang_Boolean *bo; + + i = vm_call_method_int_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Boolean); + + /* setting the value of the object direct */ + + bo = (java_lang_Boolean *) ro; + bo->value = i; + } + break; + + case PRIMITIVETYPE_BYTE: { + s4 i; + java_lang_Byte *bo; + + i = vm_call_method_int_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Byte); + + /* setting the value of the object direct */ + + bo = (java_lang_Byte *) ro; + bo->value = i; + } + break; + + case PRIMITIVETYPE_CHAR: { + s4 i; + java_lang_Character *co; + + i = vm_call_method_int_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Character); + + /* setting the value of the object direct */ + + co = (java_lang_Character *) ro; + co->value = i; + } + break; + + case PRIMITIVETYPE_SHORT: { + s4 i; + java_lang_Short *so; + + i = vm_call_method_int_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Short); + + /* setting the value of the object direct */ + + so = (java_lang_Short *) ro; + so->value = i; + } + break; + + case PRIMITIVETYPE_INT: { + s4 i; + java_lang_Integer *io; + + i = vm_call_method_int_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Integer); + + /* setting the value of the object direct */ + + io = (java_lang_Integer *) ro; + io->value = i; + } + break; + + case PRIMITIVETYPE_LONG: { + s8 l; + java_lang_Long *lo; + + l = vm_call_method_long_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Long); + + /* setting the value of the object direct */ + + lo = (java_lang_Long *) ro; + lo->value = l; + } + break; + + case PRIMITIVETYPE_FLOAT: { + float f; + java_lang_Float *fo; + + f = vm_call_method_float_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Float); + + /* setting the value of the object direct */ + + fo = (java_lang_Float *) ro; + fo->value = f; + } + break; + + case PRIMITIVETYPE_DOUBLE: { + double d; + java_lang_Double *_do; + + d = vm_call_method_double_vmarg(resm, argcount, vmargs); + + ro = builtin_new(class_java_lang_Double); + + /* setting the value of the object direct */ + + _do = (java_lang_Double *) ro; + _do->value = d; + } + break; + + case TYPE_ADR: + 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(vmargs, vm_arg, argcount); + + return NULL; + } + + MFREE(vmargs, vm_arg, argcount); + + xptr = exceptions_get_exception(); + + if (xptr != NULL) { + /* clear exception pointer, we are calling JIT code again */ + + exceptions_clear_exception(); + + exceptions_throw_invocationtargetexception(xptr); + } + + return ro; +} + + +/* GetVersion ****************************************************************** + + Returns the major version number in the higher 16 bits and the + minor version number in the lower 16 bits. + +*******************************************************************************/ + +jint _Jv_JNI_GetVersion(JNIEnv *env) +{ + STATISTICS(jniinvokation()); + + /* we support JNI 1.4 */ + + return JNI_VERSION_1_4; +} + + +/* Class Operations ***********************************************************/ + +/* DefineClass ***************************************************************** + + Loads a class from a buffer of raw class data. The buffer + containing the raw class data is not referenced by the VM after the + DefineClass call returns, and it may be discarded if desired. + +*******************************************************************************/ + +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; + jclass c; + + STATISTICS(jniinvokation()); + + cl = (java_lang_ClassLoader *) loader; + s = (java_lang_String *) javastring_new_from_utf_string(name); + ba = (java_bytearray *) buf; + + 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 0; +#endif +} + + +/* FindClass ******************************************************************* + + This function loads a locally-defined class. It searches the + directories and zip files specified by the CLASSPATH environment + variable for the class with the specified name. + +*******************************************************************************/ + +jclass _Jv_JNI_FindClass(JNIEnv *env, const char *name) +{ +#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. */ + + /* 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 + c = load_class_from_classloader(u, cc->classloader); + + if (c == NULL) return NULL; - if (!use_class_as_object(c)) + if (!link_class(c)) + return NULL; + + 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 +} + + +/* 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 _Jv_JNI_GetSuperclass(JNIEnv *env, jclass sub) +{ + classinfo *c; + + STATISTICS(jniinvokation()); + + c = ((classinfo *) sub)->super.cls; + + if (!c) return NULL; - return (jclass) NewLocalRef(env, (jobject) c); + return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c); } @@ -887,23 +1230,17 @@ jclass GetSuperclass(JNIEnv *env, jclass sub) *******************************************************************************/ -jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup) +jboolean _Jv_JNI_IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup) { - STATS(jniinvokation();) - return Java_java_lang_VMClass_isAssignableFrom(env, - NULL, - (java_lang_Class *) sup, - (java_lang_Class *) sub); -} + java_lang_Class *csup; + java_lang_Class *csub; + csup = (java_lang_Class *) sup; + csub = (java_lang_Class *) sub; -/***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/ + STATISTICS(jniinvokation()); -jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic) -{ - log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!!!"); - STATS(jniinvokation();) - return NULL; + return _Jv_java_lang_Class_isAssignableFrom(csup, csub); } @@ -913,10 +1250,15 @@ jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isS *******************************************************************************/ -jint Throw(JNIEnv *env, jthrowable obj) +jint _Jv_JNI_Throw(JNIEnv *env, jthrowable obj) { - *exceptionptr = (java_objectheader *) obj; - STATS(jniinvokation();) + java_objectheader *o; + + STATISTICS(jniinvokation()); + + o = (java_objectheader *) obj; + + exceptions_set_exception(o); return JNI_OK; } @@ -930,23 +1272,25 @@ jint Throw(JNIEnv *env, jthrowable obj) *******************************************************************************/ -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; - STATS(jniinvokation();) + classinfo *c; + java_objectheader *o; + java_objectheader *s; - s = (java_lang_String *) javastring_new_char(msg); + STATISTICS(jniinvokation()); + + 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; } @@ -960,15 +1304,15 @@ jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg) *******************************************************************************/ -jthrowable ExceptionOccurred(JNIEnv *env) +jthrowable _Jv_JNI_ExceptionOccurred(JNIEnv *env) { - java_objectheader *e; + java_objectheader *o; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - e = *exceptionptr; + o = exceptions_get_exception(); - return NewLocalRef(env, (jthrowable) e); + return _Jv_JNI_NewLocalRef(env, (jthrowable) o); } @@ -980,34 +1324,35 @@ jthrowable ExceptionOccurred(JNIEnv *env) *******************************************************************************/ -void ExceptionDescribe(JNIEnv *env) +void _Jv_JNI_ExceptionDescribe(JNIEnv *env) { - java_objectheader *e; + java_objectheader *o; methodinfo *m; - STATS(jniinvokation();) - e = *exceptionptr; + STATISTICS(jniinvokation()); - if (e) { + o = exceptions_get_exception(); + + 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); } } @@ -1019,11 +1364,11 @@ void ExceptionDescribe(JNIEnv *env) *******************************************************************************/ -void ExceptionClear(JNIEnv *env) +void _Jv_JNI_ExceptionClear(JNIEnv *env) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - *exceptionptr = NULL; + exceptions_clear_exception(); } @@ -1034,11 +1379,13 @@ void ExceptionClear(JNIEnv *env) *******************************************************************************/ -void FatalError(JNIEnv *env, const char *msg) +void _Jv_JNI_FatalError(JNIEnv *env, const char *msg) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); + + /* this seems to be the best way */ - throw_cacao_exception_exit(string_java_lang_InternalError, msg); + vm_abort(msg); } @@ -1049,17 +1396,54 @@ void FatalError(JNIEnv *env, const char *msg) *******************************************************************************/ -jint PushLocalFrame(JNIEnv* env, jint capacity) +jint _Jv_JNI_PushLocalFrame(JNIEnv* env, jint capacity) { - STATS(jniinvokation();) + s4 additionalrefs; + localref_table *lrt; + localref_table *nlrt; - log_text("JNI-Call: PushLocalFrame: IMPLEMENT ME!"); + STATISTICS(jniinvokation()); - assert(0); + if (capacity <= 0) + return -1; + + /* Allocate new local reference table on Java heap. Calculate the + additional memory we have to allocate. */ + + if (capacity > LOCALREFTABLE_CAPACITY) + additionalrefs = capacity - LOCALREFTABLE_CAPACITY; + else + additionalrefs = 0; + +#if defined(ENABLE_GC_CACAO) + nlrt = MNEW(u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P); +#else + nlrt = GCMNEW(u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P); +#endif + + 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 @@ -1068,17 +1452,65 @@ jint PushLocalFrame(JNIEnv* env, jint capacity) *******************************************************************************/ -jobject PopLocalFrame(JNIEnv* env, jobject result) +jobject _Jv_JNI_PopLocalFrame(JNIEnv* env, jobject result) { - STATS(jniinvokation();) + localref_table *lrt; + localref_table *plrt; + s4 localframes; + s4 additionalrefs; - log_text("JNI-Call: PopLocalFrame: IMPLEMENT ME!"); + STATISTICS(jniinvokation()); - assert(0); + /* get current local reference table from thread */ + + 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; + +#if defined(ENABLE_GC_CACAO) + /* for the exact GC local reference tables are not on the heap, + so we need to free them explicitly here. */ + + if (lrt->capacity > LOCALREFTABLE_CAPACITY) + additionalrefs = lrt->capacity - LOCALREFTABLE_CAPACITY; + else + additionalrefs = 0; + + MFREE(lrt, u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P); +#endif + + /* 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); } @@ -1088,13 +1520,13 @@ jobject PopLocalFrame(JNIEnv* env, jobject result) *******************************************************************************/ -void DeleteLocalRef(JNIEnv *env, jobject localRef) +void _Jv_JNI_DeleteLocalRef(JNIEnv *env, jobject localRef) { java_objectheader *o; localref_table *lrt; s4 i; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); o = (java_objectheader *) localRef; @@ -1102,14 +1534,19 @@ void DeleteLocalRef(JNIEnv *env, jobject localRef) 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; + } } } @@ -1117,7 +1554,7 @@ void DeleteLocalRef(JNIEnv *env, jobject localRef) /* 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"); } @@ -1127,9 +1564,9 @@ void DeleteLocalRef(JNIEnv *env, jobject localRef) *******************************************************************************/ -jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2) +jboolean _Jv_JNI_IsSameObject(JNIEnv *env, jobject ref1, jobject ref2) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (ref1 == ref2) return JNI_TRUE; @@ -1144,12 +1581,12 @@ jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2) *******************************************************************************/ -jobject NewLocalRef(JNIEnv *env, jobject ref) +jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref) { localref_table *lrt; s4 i; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (ref == NULL) return NULL; @@ -1158,1100 +1595,1613 @@ jobject NewLocalRef(JNIEnv *env, jobject ref) 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) { + if (_Jv_JNI_EnsureLocalCapacity(env, 16) != 0) + return NULL; + + /* get the new local reference table */ + + lrt = LOCALREFTABLE; + } + + /* insert the reference */ + + for (i = 0; i < lrt->capacity; i++) { + if (lrt->refs[i] == NULL) { + lrt->refs[i] = (java_objectheader *) ref; + lrt->used++; + + return ref; + } + } + + /* should not happen, just to be sure */ + + assert(0); + + /* keep compiler happy */ + + return NULL; +} + + +/* EnsureLocalCapacity ********************************************************* + + Ensures that at least a given number of local references can be + created in the current thread + +*******************************************************************************/ + +jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity) +{ + localref_table *lrt; + + STATISTICS(jniinvokation()); + + /* get local reference table (thread specific) */ + + lrt = LOCALREFTABLE; + + /* check if capacity elements are available in the local references table */ + + if ((lrt->used + capacity) > lrt->capacity) + return _Jv_JNI_PushLocalFrame(env, capacity); + + return 0; +} + + +/* AllocObject ***************************************************************** + + Allocates a new Java object without invoking any of the + constructors for the object. Returns a reference to the object. + +*******************************************************************************/ + +jobject _Jv_JNI_AllocObject(JNIEnv *env, jclass clazz) +{ + classinfo *c; + java_objectheader *o; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + + if ((c->flags & ACC_INTERFACE) || (c->flags & ACC_ABSTRACT)) { + exceptions_throw_instantiationexception(c); + return NULL; + } + + o = builtin_new(c); + + return _Jv_JNI_NewLocalRef(env, o); +} + + +/* NewObject ******************************************************************* + + Programmers place all arguments that are to be passed to the + constructor immediately following the methodID + argument. NewObject() accepts these arguments and passes them to + the Java method that the programmer wishes to invoke. + +*******************************************************************************/ + +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 == NULL) + return NULL; + + /* call constructor */ + + va_start(ap, methodID); + _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap); + va_end(ap); + + return _Jv_JNI_NewLocalRef(env, o); +} + + +/* NewObjectV ****************************************************************** + + Programmers place all arguments that are to be passed to the + constructor in an args argument of type va_list that immediately + follows the methodID argument. NewObjectV() accepts these + arguments, and, in turn, passes them to the Java method that the + programmer wishes to invoke. + +*******************************************************************************/ + +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 == NULL) + return NULL; + + /* call constructor */ + + _Jv_jni_CallVoidMethod(o, o->vftbl, m, args); + + return _Jv_JNI_NewLocalRef(env, o); +} + + +/* NewObjectA ***************************************************************** + + 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 _Jv_JNI_NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, + jvalue *args) +{ + java_objectheader *o; + methodinfo *m; + + STATISTICS(jniinvokation()); + + m = (methodinfo *) methodID; + + /* create object */ + + 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); +} + + +/* GetObjectClass ************************************************************** + + Returns the class of an object. + +*******************************************************************************/ + +jclass _Jv_JNI_GetObjectClass(JNIEnv *env, jobject obj) +{ + java_objectheader *o; + classinfo *c; + + STATISTICS(jniinvokation()); + + o = (java_objectheader *) obj; + + if ((o == NULL) || (o->vftbl == NULL)) + return NULL; + + c = o->vftbl->class; + + return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c); +} + + +/* IsInstanceOf **************************************************************** + + Tests whether an object is an instance of a class. + +*******************************************************************************/ + +jboolean _Jv_JNI_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz) +{ + java_lang_Class *c; + java_lang_Object *o; + + STATISTICS(jniinvokation()); + + c = (java_lang_Class *) clazz; + o = (java_lang_Object *) obj; + + return _Jv_java_lang_Class_isInstance(c, o); +} + + +/* 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) +{ +#if defined(ENABLE_JAVASE) + 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; + + 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; - if (lrt->used == lrt->capacity) - throw_cacao_exception_exit(string_java_lang_InternalError, - "Too many local references"); + STATISTICS(jniinvokation()); - /* insert the reference */ + rf = (java_lang_reflect_Field *) field; - for (i = 0; i < lrt->capacity; i++) { - if (lrt->refs[i] == NULL) { - lrt->refs[i] = (java_objectheader *) ref; - lrt->used++; + if (rf == NULL) + return NULL; - return ref; - } - } + c = (classinfo *) rf->declaringClass; - /* should not happen, just to be sure */ + f = &(c->fields[rf->slot]); - assert(0); + return (jfieldID) f; +#else + vm_abort("_Jv_JNI_FromReflectedField: not implemented in this configuration"); /* keep compiler happy */ return NULL; +#endif } -/* EnsureLocalCapacity ********************************************************* +/* ToReflectedMethod *********************************************************** - Ensures that at least a given number of local references can be - created in the current thread + Converts a method ID derived from cls to an instance of the + java.lang.reflect.Method class or to an instance of the + java.lang.reflect.Constructor class. *******************************************************************************/ -jint EnsureLocalCapacity(JNIEnv* env, jint capacity) +jobject _Jv_JNI_ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, + jboolean isStatic) { - localref_table *lrt; + STATISTICS(jniinvokation()); - STATS(jniinvokation();) + log_text("JNI-Call: ToReflectedMethod: IMPLEMENT ME!"); - /* get local reference table (thread specific) */ + return NULL; +} - lrt = LOCALREFTABLE; - /* check if capacity elements are available in the local references table */ +/* ToReflectedField ************************************************************ - if ((lrt->used + capacity) > lrt->capacity) { - *exceptionptr = new_exception(string_java_lang_OutOfMemoryError); - return -1; - } + Converts a field ID derived from cls to an instance of the + java.lang.reflect.Field class. - return 0; +*******************************************************************************/ + +jobject _Jv_JNI_ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, + jboolean isStatic) +{ + STATISTICS(jniinvokation()); + + log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!"); + + return NULL; } -/* AllocObject ***************************************************************** +/* Calling Instance Methods ***************************************************/ - Allocates a new Java object without invoking any of the - constructors for the object. Returns a reference to the object. +/* GetMethodID ***************************************************************** + + Returns the method ID for an instance (nonstatic) method of a class + or interface. The method may be defined in one of the clazz's + superclasses and inherited by clazz. The method is determined by + its name and signature. + + GetMethodID() causes an uninitialized class to be initialized. *******************************************************************************/ -jobject AllocObject(JNIEnv *env, jclass clazz) +jmethodID _Jv_JNI_GetMethodID(JNIEnv* env, jclass clazz, const char *name, + const char *sig) { - java_objectheader *o; + classinfo *c; + utf *uname; + utf *udesc; + methodinfo *m; + + STATISTICS(jniinvokation()); - STATS(jniinvokation();) + c = (classinfo *) clazz; - if ((clazz->flags & ACC_INTERFACE) || (clazz->flags & ACC_ABSTRACT)) { - *exceptionptr = - new_exception_utfmessage(string_java_lang_InstantiationException, - clazz->name); + if (!c) return NULL; - } - - o = builtin_new(clazz); - return NewLocalRef(env, o); -} + if (!(c->state & CLASS_INITIALIZED)) + if (!initialize_class(c)) + return NULL; + /* try to get the method of the class or one of it's superclasses */ -/* NewObject ******************************************************************* + uname = utf_new_char((char *) name); + udesc = utf_new_char((char *) sig); - Programmers place all arguments that are to be passed to the - constructor immediately following the methodID - argument. NewObject() accepts these arguments and passes them to - the Java method that the programmer wishes to invoke. + m = class_resolvemethod(clazz, uname, udesc); -*******************************************************************************/ + if ((m == NULL) || (m->flags & ACC_STATIC)) { + exceptions_throw_nosuchmethoderror(c, uname, udesc); -jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...) -{ - java_objectheader *o; - va_list ap; + return NULL; + } - STATS(jniinvokation();) + return (jmethodID) m; +} - /* create object */ - o = builtin_new(clazz); - - if (!o) - return NULL; +/* JNI-functions for calling instance methods *********************************/ - /* call constructor */ +jobject _Jv_JNI_CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, + ...) +{ + java_objectheader *o; + methodinfo *m; + java_objectheader *ret; + va_list ap; + + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; va_start(ap, methodID); - cacao_jni_CallVoidMethod(o, methodID, ap); + ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, ap); va_end(ap); - return NewLocalRef(env, o); + return _Jv_JNI_NewLocalRef(env, ret); } -/*********************************************************************************** +jobject _Jv_JNI_CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) +{ + java_objectheader *o; + methodinfo *m; + java_objectheader *ret; - Constructs a new Java object - arguments that are to be passed to the constructor are placed in va_list args + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; -***********************************************************************************/ + ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, args); -jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) -{ - STATS(jniinvokation();) + return _Jv_JNI_NewLocalRef(env, ret); +} - log_text("JNI-Call: NewObjectV: IMPLEMENT ME!"); - return NewLocalRef(env, NULL); -} +jobject _Jv_JNI_CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) +{ + java_objectheader *o; + methodinfo *m; + java_objectheader *ret; + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; -/*********************************************************************************** + ret = _Jv_jni_CallObjectMethodA(o, o->vftbl, m, args); - Constructs a new Java object - arguments that are to be passed to the constructor are placed in - args array of jvalues + return _Jv_JNI_NewLocalRef(env, ret); +} -***********************************************************************************/ -jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args) +jboolean _Jv_JNI_CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID, + ...) { - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + va_list ap; + jboolean b; + + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - log_text("JNI-Call: NewObjectA: IMPLEMENT ME!"); + va_start(ap, methodID); + b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap); + va_end(ap); - return NewLocalRef(env, NULL); + return b; } -/* GetObjectClass ************************************************************** +jboolean _Jv_JNI_CallBooleanMethodV(JNIEnv *env, jobject obj, + jmethodID methodID, va_list args) +{ + java_objectheader *o; + methodinfo *m; + jboolean b; - Returns the class of an object. + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; -*******************************************************************************/ + b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args); -jclass GetObjectClass(JNIEnv *env, jobject obj) -{ - classinfo *c; + return b; +} - STATS(jniinvokation();) - - if (!obj || !obj->vftbl) - return NULL; - c = obj->vftbl->class; +jboolean _Jv_JNI_CallBooleanMethodA(JNIEnv *env, jobject obj, + jmethodID methodID, jvalue *args) +{ + java_objectheader *o; + methodinfo *m; + jboolean b; + + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - if (!use_class_as_object(c)) - return NULL; + b = _Jv_jni_CallIntMethodA(o, o->vftbl, m, args); - return (jclass) NewLocalRef(env, (jobject) c); + return b; } -/* IsInstanceOf **************************************************************** +jbyte _Jv_JNI_CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +{ + java_objectheader *o; + methodinfo *m; + va_list ap; + jbyte b; - Tests whether an object is an instance of a class. + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; -*******************************************************************************/ + va_start(ap, methodID); + b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap); + va_end(ap); -jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz) -{ - STATS(jniinvokation();) + return b; - return Java_java_lang_VMClass_isInstance(env, - NULL, - (java_lang_Class *) clazz, - (java_lang_Object *) obj); } -/***************** converts a java.lang.reflect.Field to a field ID ***************/ - -jfieldID FromReflectedField(JNIEnv* env, jobject field) +jbyte _Jv_JNI_CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { - java_lang_reflect_Field *f; - classinfo *c; - jfieldID fid; /* the JNI-fieldid of the wrapping object */ - STATS(jniinvokation();) - /*log_text("JNI-Call: FromReflectedField");*/ - - 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); - } - fid=&(c->fields[f->slot]); - return fid; -} + java_objectheader *o; + methodinfo *m; + jbyte b; + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; -/********************************************************************************** + b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args); - converts a method ID to a java.lang.reflect.Method or - java.lang.reflect.Constructor object + return b; +} -**********************************************************************************/ -jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic) +jbyte _Jv_JNI_CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) { - log_text("JNI-Call: ToReflectedMethod"); - STATS(jniinvokation();) + log_text("JNI-Call: CallByteMethodA: IMPLEMENT ME!"); - return NULL; + return 0; } -/* Calling Instance Methods ***************************************************/ +jchar _Jv_JNI_CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +{ + java_objectheader *o; + methodinfo *m; + va_list ap; + jchar c; -/* GetMethodID ***************************************************************** + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - Returns the method ID for an instance (nonstatic) method of a class - or interface. The method may be defined in one of the clazz's - superclasses and inherited by clazz. The method is determined by - its name and signature. + va_start(ap, methodID); + c = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap); + va_end(ap); - GetMethodID() causes an uninitialized class to be initialized. + return c; +} -*******************************************************************************/ -jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, - const char *sig) +jchar _Jv_JNI_CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { - classinfo *c; - methodinfo *m; - - STATS(jniinvokation();) - - c = (classinfo *) clazz; - - if (!c) - return NULL; + java_objectheader *o; + methodinfo *m; + jchar c; - if (!c->initialized) - if (!initialize_class(c)) - return NULL; + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - /* try to get the method of the class or one of it's superclasses */ + c = _Jv_jni_CallIntMethod(o, o->vftbl, m, args); - m = class_resolvemethod(clazz, - utf_new_char((char *) name), - utf_new_char((char *) sig)); + return c; +} - if (!m || (m->flags & ACC_STATIC)) { - *exceptionptr = - new_exception_message(string_java_lang_NoSuchMethodError, name); - return NULL; - } +jchar _Jv_JNI_CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) +{ + log_text("JNI-Call: CallCharMethodA: IMPLEMENT ME!"); - return m; + return 0; } -/******************** JNI-functions for calling instance methods ******************/ - -jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +jshort _Jv_JNI_CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, + ...) { - java_objectheader* ret; - va_list vaargs; + java_objectheader *o; + methodinfo *m; + va_list ap; + jshort s; - STATS(jniinvokation();) + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = callObjectMethod(obj, methodID, vaargs); - va_end(vaargs); + va_start(ap, methodID); + s = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap); + va_end(ap); - return NewLocalRef(env, ret); + return s; } -jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args) +jshort _Jv_JNI_CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { - java_objectheader* ret; + java_objectheader *o; + methodinfo *m; + jshort s; - STATS(jniinvokation();) + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - ret = callObjectMethod(obj, methodID, args); + s = _Jv_jni_CallIntMethod(o, o->vftbl, m, args); - return NewLocalRef(env, ret); + return s; } -jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args) +jshort _Jv_JNI_CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) + log_text("JNI-Call: CallShortMethodA: IMPLEMENT ME!"); - log_text("JNI-Call: CallObjectMethodA: IMPLEMENT ME!"); - - return NewLocalRef(env, NULL); + return 0; } - -jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...) +jint _Jv_JNI_CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) { - jboolean ret; - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + va_list ap; + jint i; -/* log_text("JNI-Call: CallBooleanMethod");*/ + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - va_start(vaargs,methodID); - ret = (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_BOOLEAN,vaargs); - va_end(vaargs); - return ret; + va_start(ap, methodID); + i = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap); + va_end(ap); + return i; } -jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args) + +jint _Jv_JNI_CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + jint i; - return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_BOOLEAN,args); + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; + i = _Jv_jni_CallIntMethod(o, o->vftbl, m, args); + + return i; } -jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args) + +jint _Jv_JNI_CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallBooleanMethodA"); + log_text("JNI-Call: CallIntMethodA: IMPLEMENT ME!"); return 0; } -jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...) + + +jlong _Jv_JNI_CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) { - jbyte ret; - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + va_list ap; + jlong l; -/* log_text("JNI-Call: CallVyteMethod");*/ + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - va_start(vaargs,methodID); - ret = callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_BYTE,vaargs); - va_end(vaargs); - return ret; + va_start(ap, methodID); + l = _Jv_jni_CallLongMethod(o, o->vftbl, m, ap); + va_end(ap); + return l; } -jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args) + +jlong _Jv_JNI_CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { -/* log_text("JNI-Call: CallByteMethodV");*/ - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + jlong l; - return callIntegerMethod(obj,methodID,PRIMITIVETYPE_BYTE,args); + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; + + l = _Jv_jni_CallLongMethod(o, o->vftbl, m, args); + + return l; } -jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args) +jlong _Jv_JNI_CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) { - log_text("JNI-Call: CallByteMethodA"); - STATS(jniinvokation();) + log_text("JNI-Call: CallLongMethodA: IMPLEMENT ME!"); return 0; } -jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) + +jfloat _Jv_JNI_CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, + ...) { - jchar ret; - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + va_list ap; + jfloat f; -/* log_text("JNI-Call: CallCharMethod");*/ + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - va_start(vaargs,methodID); - ret = callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_CHAR, vaargs); - va_end(vaargs); + va_start(ap, methodID); + f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, ap); + va_end(ap); - return ret; + return f; } -jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args) +jfloat _Jv_JNI_CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + jfloat f; + + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; -/* log_text("JNI-Call: CallCharMethodV");*/ - return callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_CHAR,args); + f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, args); + + return f; } -jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args) +jfloat _Jv_JNI_CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - - log_text("JNI-Call: CallCharMethodA"); + log_text("JNI-Call: CallFloatMethodA: IMPLEMENT ME!"); return 0; } -jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) + +jdouble _Jv_JNI_CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, + ...) { - jshort ret; - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + va_list ap; + jdouble d; -/* log_text("JNI-Call: CallShortMethod");*/ + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_SHORT, vaargs); - va_end(vaargs); + va_start(ap, methodID); + d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, ap); + va_end(ap); - return ret; + return d; } -jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args) +jdouble _Jv_JNI_CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { - STATS(jniinvokation();) - return callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_SHORT, args); + java_objectheader *o; + methodinfo *m; + jdouble d; + + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; + + d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, args); + + return d; } -jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args) +jdouble _Jv_JNI_CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallShortMethodA"); + log_text("JNI-Call: CallDoubleMethodA: IMPLEMENT ME!"); return 0; } -jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +void _Jv_JNI_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) { - jint ret; - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + methodinfo *m; + va_list ap; - va_start(vaargs,methodID); - ret = callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_INT, vaargs); - va_end(vaargs); + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; - return ret; + va_start(ap, methodID); + _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap); + va_end(ap); } -jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args) +void _Jv_JNI_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, + va_list args) { - STATS(jniinvokation();) - return callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_INT, args); + java_objectheader *o; + methodinfo *m; + + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; + + _Jv_jni_CallVoidMethod(o, o->vftbl, m, args); } -jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args) +void _Jv_JNI_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallIntMethodA"); + java_objectheader *o; + methodinfo *m; - return 0; + o = (java_objectheader *) obj; + m = (methodinfo *) methodID; + + _Jv_jni_CallVoidMethodA(o, o->vftbl, m, args); } -jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +jobject _Jv_JNI_CallNonvirtualObjectMethod(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + ...) { - jlong ret; - va_list vaargs; - STATS(jniinvokation();) - - va_start(vaargs,methodID); - ret = callLongMethod(obj,get_virtual(obj, methodID),vaargs); - va_end(vaargs); + 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); + r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, ap); + va_end(ap); - return ret; + return _Jv_JNI_NewLocalRef(env, r); } -jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args) +jobject _Jv_JNI_CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + va_list args) { - STATS(jniinvokation();) - return callLongMethod(obj,get_virtual(obj, methodID),args); + java_objectheader *o; + classinfo *c; + methodinfo *m; + java_objectheader *r; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, args); + + return _Jv_JNI_NewLocalRef(env, r); } -jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args) +jobject _Jv_JNI_CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallLongMethodA"); + log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!"); - return 0; + return _Jv_JNI_NewLocalRef(env, NULL); } -jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +jboolean _Jv_JNI_CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + ...) { - jfloat ret; - va_list vaargs; + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jboolean b; - STATS(jniinvokation();) -/* log_text("JNI-Call: CallFloatMethod");*/ + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; - va_start(vaargs,methodID); - ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, PRIMITIVETYPE_FLOAT); - va_end(vaargs); + va_start(ap, methodID); + b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap); + va_end(ap); - return ret; + return b; } -jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args) +jboolean _Jv_JNI_CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + va_list args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallFloatMethodV"); - return callFloatMethod(obj, get_virtual(obj, methodID), args, PRIMITIVETYPE_FLOAT); -} + java_objectheader *o; + classinfo *c; + methodinfo *m; + jboolean b; + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; -jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args) -{ - STATS(jniinvokation();) - log_text("JNI-Call: CallFloatMethodA"); + b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args); - return 0; + return b; } - -jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +jboolean _Jv_JNI_CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + jvalue *args) { - jdouble ret; - va_list vaargs; - STATS(jniinvokation();) - -/* log_text("JNI-Call: CallDoubleMethod");*/ + log_text("JNI-Call: CallNonvirtualBooleanMethodA: IMPLEMENT ME!"); - va_start(vaargs,methodID); - ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, PRIMITIVETYPE_DOUBLE); - va_end(vaargs); - - return ret; + return 0; } -jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args) +jbyte _Jv_JNI_CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, ...) { - STATS(jniinvokation();) - log_text("JNI-Call: CallDoubleMethodV"); - return callFloatMethod(obj, get_virtual(obj, methodID), args, PRIMITIVETYPE_DOUBLE); -} + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jbyte b; + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; -jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args) -{ - STATS(jniinvokation();) - log_text("JNI-Call: CallDoubleMethodA"); - return 0; -} + va_start(ap, methodID); + b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap); + va_end(ap); + return b; +} -void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) +jbyte _Jv_JNI_CallNonvirtualByteMethodV(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, va_list args) { - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + classinfo *c; + methodinfo *m; + jbyte b; - va_start(vaargs,methodID); - (void) callIntegerMethod(obj, get_virtual(obj, methodID),TYPE_VOID, vaargs); - va_end(vaargs); -} + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args); -void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args) -{ - log_text("JNI-Call: CallVoidMethodV"); - STATS(jniinvokation();) - (void)callIntegerMethod(obj,get_virtual(obj,methodID),TYPE_VOID,args); + return b; } -void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args) +jbyte _Jv_JNI_CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallVoidMethodA"); + log_text("JNI-Call: CallNonvirtualByteMethodA: IMPLEMENT ME!"); + + return 0; } -jobject CallNonvirtualObjectMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jchar _Jv_JNI_CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, ...) { - STATS(jniinvokation();) + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jchar ch; - log_text("JNI-Call: CallNonvirtualObjectMethod: IMPLEMENT ME!"); + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + va_start(ap, methodID); + ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap); + va_end(ap); - return NewLocalRef(env, NULL); + return ch; } -jobject CallNonvirtualObjectMethodV(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) { - STATS(jniinvokation();) + java_objectheader *o; + classinfo *c; + methodinfo *m; + jchar ch; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; - log_text("JNI-Call: CallNonvirtualObjectMethodV: IMPLEMENT ME!"); + ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, args); - return NewLocalRef(env, NULL); + return ch; } -jobject CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args) +jchar _Jv_JNI_CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - - log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!"); + log_text("JNI-Call: CallNonvirtualCharMethodA: IMPLEMENT ME!"); - return NewLocalRef(env, NULL); + return 0; } -jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jshort _Jv_JNI_CallNonvirtualShortMethod(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, ...) { - jboolean ret; - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jshort s; -/* log_text("JNI-Call: CallNonvirtualBooleanMethod");*/ + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; - va_start(vaargs,methodID); - ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BOOLEAN,vaargs); - va_end(vaargs); - return ret; + va_start(ap, methodID); + s = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap); + va_end(ap); + return s; } -jboolean CallNonvirtualBooleanMethodV (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) { - STATS(jniinvokation();) -/* log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/ - return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BOOLEAN,args); + java_objectheader *o; + classinfo *c; + methodinfo *m; + jshort s; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + s = _Jv_jni_CallIntMethod(o, c->vftbl, m, args); + + return s; } -jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args) +jshort _Jv_JNI_CallNonvirtualShortMethodA(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualBooleanMethodA"); + log_text("JNI-Call: CallNonvirtualShortMethodA: IMPLEMENT ME!"); return 0; } -jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jint _Jv_JNI_CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, ...) { - jbyte ret; - va_list vaargs; + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jint i; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; - STATS(jniinvokation();) -/* log_text("JNI-Call: CallNonvirutalByteMethod");*/ + va_start(ap, methodID); + i = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap); + va_end(ap); - va_start(vaargs,methodID); - ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BYTE,vaargs); - va_end(vaargs); - return ret; + return i; } -jbyte CallNonvirtualByteMethodV (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) { - STATS(jniinvokation();) - /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */ - return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BYTE,args); + java_objectheader *o; + classinfo *c; + methodinfo *m; + jint i; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + i = _Jv_jni_CallIntMethod(o, c->vftbl, m, args); + return i; } -jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args) +jint _Jv_JNI_CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualByteMethodA"); + log_text("JNI-Call: CallNonvirtualIntMethodA: IMPLEMENT ME!"); return 0; } -jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jlong _Jv_JNI_CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, ...) { - jchar ret; - va_list vaargs; + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jlong l; - STATS(jniinvokation();) -/* log_text("JNI-Call: CallNonVirtualCharMethod");*/ + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + va_start(ap, methodID); + l = _Jv_jni_CallLongMethod(o, c->vftbl, m, ap); + va_end(ap); - va_start(vaargs,methodID); - ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_CHAR,vaargs); - va_end(vaargs); - return ret; + return l; } -jchar CallNonvirtualCharMethodV (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) { - STATS(jniinvokation();) - /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/ - return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_CHAR,args); + java_objectheader *o; + classinfo *c; + methodinfo *m; + jlong l; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + l = _Jv_jni_CallLongMethod(o, c->vftbl, m, args); + + return l; } -jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args) +jlong _Jv_JNI_CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualCharMethodA"); + log_text("JNI-Call: CallNonvirtualLongMethodA: IMPLEMENT ME!"); return 0; } -jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jfloat _Jv_JNI_CallNonvirtualFloatMethod(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, ...) { - jshort ret; - va_list vaargs; - STATS(jniinvokation();) + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jfloat f; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; - /*log_text("JNI-Call: CallNonvirtualShortMethod");*/ + va_start(ap, methodID); + f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, ap); + va_end(ap); - va_start(vaargs,methodID); - ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_SHORT,vaargs); - va_end(vaargs); - return ret; + return f; } -jshort CallNonvirtualShortMethodV (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) { - STATS(jniinvokation();) - /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/ - return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_SHORT,args); + java_objectheader *o; + classinfo *c; + methodinfo *m; + jfloat f; + + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, args); + + return f; } -jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args) +jfloat _Jv_JNI_CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualShortMethodA"); + log_text("JNI-Call: CallNonvirtualFloatMethodA: IMPLEMENT ME!"); return 0; } -jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jdouble _Jv_JNI_CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + ...) { + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; + jdouble d; - jint ret; - va_list vaargs; - STATS(jniinvokation();) + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; - /*log_text("JNI-Call: CallNonvirtualIntMethod");*/ + va_start(ap, methodID); + d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, ap); + va_end(ap); - va_start(vaargs,methodID); - ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_INT,vaargs); - va_end(vaargs); - return ret; + return d; } -jint CallNonvirtualIntMethodV (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) { - STATS(jniinvokation();) - /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/ - return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_INT,args); -} + java_objectheader *o; + classinfo *c; + methodinfo *m; + jdouble d; + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; -jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args) -{ - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualIntMethodA"); + d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, args); - return 0; + return d; } - -jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jdouble _Jv_JNI_CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj, + jclass clazz, jmethodID methodID, + jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualLongMethod"); + log_text("JNI-Call: CallNonvirtualDoubleMethodA: IMPLEMENT ME!"); return 0; } -jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args) + +void _Jv_JNI_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, ...) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualLongMethodV"); + java_objectheader *o; + classinfo *c; + methodinfo *m; + va_list ap; - return 0; + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + va_start(ap, methodID); + _Jv_jni_CallVoidMethod(o, c->vftbl, m, ap); + va_end(ap); } -jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args) +void _Jv_JNI_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, va_list args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualLongMethodA"); + java_objectheader *o; + classinfo *c; + methodinfo *m; - return 0; + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + _Jv_jni_CallVoidMethod(o, c->vftbl, m, args); } +void _Jv_JNI_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) +{ + java_objectheader *o; + classinfo *c; + methodinfo *m; -jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) -{ - jfloat ret; - va_list vaargs; - STATS(jniinvokation();) + o = (java_objectheader *) obj; + c = (classinfo *) clazz; + m = (methodinfo *) methodID; + + _Jv_jni_CallVoidMethodA(o, c->vftbl, m, args); +} - /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/ +/* Accessing Fields of Objects ************************************************/ - va_start(vaargs,methodID); - ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,PRIMITIVETYPE_FLOAT); - va_end(vaargs); - return ret; +/* GetFieldID ****************************************************************** -} + Returns the field ID for an instance (nonstatic) field of a + class. The field is specified by its name and signature. The + GetField and SetField families of accessor functions + use field IDs to retrieve object fields. +*******************************************************************************/ -jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args) +jfieldID _Jv_JNI_GetFieldID(JNIEnv *env, jclass clazz, const char *name, + const char *sig) { - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualFloatMethodV"); - return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,PRIMITIVETYPE_FLOAT); -} + classinfo *c; + fieldinfo *f; + utf *uname; + utf *udesc; + STATISTICS(jniinvokation()); -jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args) -{ - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualFloatMethodA"); + c = (classinfo *) clazz; - return 0; -} + uname = utf_new_char((char *) name); + udesc = utf_new_char((char *) sig); + f = class_findfield(clazz, uname, udesc); + + if (f == NULL) + exceptions_throw_nosuchfielderror(c, uname); + return (jfieldID) f; +} -jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) -{ - jdouble ret; - va_list vaargs; - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualDoubleMethod"); - va_start(vaargs,methodID); - ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,PRIMITIVETYPE_DOUBLE); - va_end(vaargs); - return ret; +/* GetField Routines ***************************************************** -} + This family of accessor routines returns the value of an instance + (nonstatic) field of an object. The field to access is specified by + a field ID obtained by calling GetFieldID(). +*******************************************************************************/ -jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args) +jobject _Jv_JNI_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID) { - STATS(jniinvokation();) -/* log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/ - return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,PRIMITIVETYPE_DOUBLE); -} + java_objectheader *o; + STATISTICS(jniinvokation()); -jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args) -{ - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualDoubleMethodA"); + o = GET_FIELD(obj, java_objectheader*, fieldID); - return 0; + return _Jv_JNI_NewLocalRef(env, o); } - -void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...) +jboolean _Jv_JNI_GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID) { - va_list vaargs; - STATS(jniinvokation();) + s4 i; -/* log_text("JNI-Call: CallNonvirtualVoidMethod");*/ + STATISTICS(jniinvokation()); - va_start(vaargs,methodID); - (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),TYPE_VOID,vaargs); - va_end(vaargs); + i = GET_FIELD(obj, s4, fieldID); + return (jboolean) i; } -void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args) +jbyte _Jv_JNI_GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID) { -/* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/ - STATS(jniinvokation();) - - (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),TYPE_VOID,args); + s4 i; -} + STATISTICS(jniinvokation()); + i = GET_FIELD(obj, s4, fieldID); -void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args) -{ - STATS(jniinvokation();) - log_text("JNI-Call: CallNonvirtualVoidMethodA"); + return (jbyte) i; } -/************************* JNI-functions for accessing fields ************************/ -jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig) +jchar _Jv_JNI_GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID) { - jfieldID f; + s4 i; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - f = class_findfield(clazz, utf_new_char((char *) name), utf_new_char((char *) sig)); - - if (!f) - *exceptionptr = new_exception(string_java_lang_NoSuchFieldError); + i = GET_FIELD(obj, s4, fieldID); - return f; + return (jchar) i; } -/*************************** retrieve fieldid, abort on error ************************/ -jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig) +jshort _Jv_JNI_GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID) { - jfieldID id = GetFieldID(env, clazz, name, sig); - STATS(jniinvokation();) + s4 i; - if (!id) { - log_text("class:"); - utf_display(clazz->name); - log_text("\nfield:"); - log_text(name); - log_text("sig:"); - log_text(sig); + STATISTICS(jniinvokation()); - log_text("setfield_critical failed"); - assert(0); - } - return id; + i = GET_FIELD(obj, s4, fieldID); + + return (jshort) i; } -jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID) + +jint _Jv_JNI_GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID) { java_objectheader *o; + fieldinfo *f; + s4 i; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - o = getField(obj, java_objectheader*, fieldID); + o = (java_objectheader *) obj; + f = (fieldinfo *) fieldID; - return NewLocalRef(env, o); -} + i = GET_FIELD(o, s4, f); -jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID) -{ - STATS(jniinvokation();) - return getField(obj,jboolean,fieldID); + return i; } -jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID) +jlong _Jv_JNI_GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID) { - STATS(jniinvokation();) - return getField(obj,jbyte,fieldID); -} + s8 l; + STATISTICS(jniinvokation()); -jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID) -{ - STATS(jniinvokation();) - return getField(obj,jchar,fieldID); + l = GET_FIELD(obj, s8, fieldID); + + return l; } -jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID) +jfloat _Jv_JNI_GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID) { - STATS(jniinvokation();) - return getField(obj,jshort,fieldID); -} + float f; + STATISTICS(jniinvokation()); -jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID) -{ - STATS(jniinvokation();) - return getField(obj,jint,fieldID); + f = GET_FIELD(obj, float, fieldID); + + return f; } -jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID) +jdouble _Jv_JNI_GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID) { - STATS(jniinvokation();) - return getField(obj,jlong,fieldID); -} + double d; + STATISTICS(jniinvokation()); -jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID) -{ - STATS(jniinvokation();) - return getField(obj,jfloat,fieldID); + d = GET_FIELD(obj, double, fieldID); + + return d; } -jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID) -{ - STATS(jniinvokation();) - return getField(obj,jdouble,fieldID); -} +/* SetField Routines ***************************************************** + + This family of accessor routines sets the value of an instance + (nonstatic) field of an object. The field to access is specified by + a field ID obtained by calling GetFieldID(). -void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val) +*******************************************************************************/ + +void _Jv_JNI_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, + jobject value) { - STATS(jniinvokation();) - setField(obj,jobject,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, java_objectheader*, fieldID, value); } -void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val) +void _Jv_JNI_SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, + jboolean value) { - STATS(jniinvokation();) - setField(obj,jboolean,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, s4, fieldID, value); } -void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val) +void _Jv_JNI_SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, + jbyte value) { - STATS(jniinvokation();) - setField(obj,jbyte,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, s4, fieldID, value); } -void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val) +void _Jv_JNI_SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, + jchar value) { - STATS(jniinvokation();) - setField(obj,jchar,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, s4, fieldID, value); } -void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val) +void _Jv_JNI_SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, + jshort value) { - STATS(jniinvokation();) - setField(obj,jshort,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, s4, fieldID, value); } -void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val) +void _Jv_JNI_SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value) { - STATS(jniinvokation();) - setField(obj,jint,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, s4, fieldID, value); } -void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val) +void _Jv_JNI_SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, + jlong value) { - STATS(jniinvokation();) - setField(obj,jlong,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, s8, fieldID, value); } -void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val) +void _Jv_JNI_SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, + jfloat value) { - STATS(jniinvokation();) - setField(obj,jfloat,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, float, fieldID, value); } -void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val) +void _Jv_JNI_SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, + jdouble value) { - STATS(jniinvokation();) - setField(obj,jdouble,fieldID,val); + STATISTICS(jniinvokation()); + + SET_FIELD(obj, double, fieldID, value); } @@ -2267,369 +3217,441 @@ void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val) *******************************************************************************/ -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; + utf *udesc; methodinfo *m; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); c = (classinfo *) clazz; if (!c) return NULL; - if (!c->initialized) + if (!(c->state & CLASS_INITIALIZED)) if (!initialize_class(c)) return NULL; /* try to get the static method of the class */ - m = class_resolvemethod(clazz, - utf_new_char((char *) name), - utf_new_char((char *) sig)); + uname = utf_new_char((char *) name); + udesc = utf_new_char((char *) sig); + + m = class_resolvemethod(c, uname, udesc); - if (!m || !(m->flags & ACC_STATIC)) { - *exceptionptr = - new_exception_message(string_java_lang_NoSuchMethodError, name); + if ((m == NULL) || !(m->flags & ACC_STATIC)) { + exceptions_throw_nosuchmethoderror(c, uname, udesc); 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; - va_list vaargs; + methodinfo *m; + java_objectheader *o; + va_list ap; - STATS(jniinvokation();) + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = callObjectMethod(0, methodID, vaargs); - va_end(vaargs); + va_start(ap, methodID); + 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; - STATS(jniinvokation();) - - ret = callObjectMethod(0, methodID, args); + m = (methodinfo *) methodID; - return NewLocalRef(env, ret); + o = _Jv_jni_CallObjectMethod(NULL, NULL, m, args); + + 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) { - STATS(jniinvokation();) + methodinfo *m; + java_objectheader *o; + + m = (methodinfo *) methodID; - log_text("JNI-Call: CallStaticObjectMethodA: IMPLEMENT ME!"); + 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, ...) { - jboolean ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jboolean b; + + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = (jboolean) callIntegerMethod(0, methodID, PRIMITIVETYPE_BOOLEAN, vaargs); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) - return (jboolean) callIntegerMethod(0, methodID, PRIMITIVETYPE_BOOLEAN, args); + methodinfo *m; + jboolean b; + + m = (methodinfo *) methodID; + + b = _Jv_jni_CallIntMethod(NULL, NULL, m, args); + + return b; } -jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args) +jboolean _Jv_JNI_CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticBooleanMethodA"); + log_text("JNI-Call: CallStaticBooleanMethodA: IMPLEMENT ME!"); return 0; } -jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) +jbyte _Jv_JNI_CallStaticByteMethod(JNIEnv *env, jclass clazz, + jmethodID methodID, ...) { - jbyte ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jbyte b; - /* log_text("JNI-Call: CallStaticByteMethod");*/ + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = (jbyte) callIntegerMethod(0, methodID, PRIMITIVETYPE_BYTE, vaargs); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) - return (jbyte) callIntegerMethod(0, methodID, PRIMITIVETYPE_BYTE, args); + methodinfo *m; + jbyte b; + + m = (methodinfo *) methodID; + + b = _Jv_jni_CallIntMethod(NULL, NULL, m, args); + + return b; } -jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args) +jbyte _Jv_JNI_CallStaticByteMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticByteMethodA"); + log_text("JNI-Call: CallStaticByteMethodA: IMPLEMENT ME!"); return 0; } -jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) +jchar _Jv_JNI_CallStaticCharMethod(JNIEnv *env, jclass clazz, + jmethodID methodID, ...) { - jchar ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jchar c; - /* log_text("JNI-Call: CallStaticByteMethod");*/ + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = (jchar) callIntegerMethod(0, methodID, PRIMITIVETYPE_CHAR, vaargs); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) - return (jchar) callIntegerMethod(0, methodID, PRIMITIVETYPE_CHAR, args); + methodinfo *m; + jchar c; + + m = (methodinfo *) methodID; + + c = _Jv_jni_CallIntMethod(NULL, NULL, m, args); + + return c; } -jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args) +jchar _Jv_JNI_CallStaticCharMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticCharMethodA"); + log_text("JNI-Call: CallStaticCharMethodA: IMPLEMENT ME!"); return 0; } - -jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) +jshort _Jv_JNI_CallStaticShortMethod(JNIEnv *env, jclass clazz, + jmethodID methodID, ...) { - jshort ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jshort s; - /* log_text("JNI-Call: CallStaticByteMethod");*/ + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = (jshort) callIntegerMethod(0, methodID, PRIMITIVETYPE_SHORT, vaargs); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) - /*log_text("JNI-Call: CallStaticShortMethodV");*/ - return (jshort) callIntegerMethod(0, methodID, PRIMITIVETYPE_SHORT, args); + methodinfo *m; + jshort s; + + m = (methodinfo *) methodID; + + s = _Jv_jni_CallIntMethod(NULL, NULL, m, args); + + return s; } -jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args) +jshort _Jv_JNI_CallStaticShortMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticShortMethodA"); + log_text("JNI-Call: CallStaticShortMethodA: IMPLEMENT ME!"); return 0; } - -jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) +jint _Jv_JNI_CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, + ...) { - jint ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jint i; - /* log_text("JNI-Call: CallStaticIntMethod");*/ + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = callIntegerMethod(0, methodID, PRIMITIVETYPE_INT, vaargs); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticIntMethodV"); + methodinfo *m; + jint i; + + m = (methodinfo *) methodID; - return callIntegerMethod(0, methodID, PRIMITIVETYPE_INT, args); + 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) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticIntMethodA"); + log_text("JNI-Call: CallStaticIntMethodA: IMPLEMENT ME!"); return 0; } - -jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) +jlong _Jv_JNI_CallStaticLongMethod(JNIEnv *env, jclass clazz, + jmethodID methodID, ...) { - jlong ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jlong l; - /* log_text("JNI-Call: CallStaticLongMethod");*/ + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = callLongMethod(0, methodID, vaargs); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) + methodinfo *m; + jlong l; - return callLongMethod(0, methodID, args); + m = (methodinfo *) methodID; + + l = _Jv_jni_CallLongMethod(NULL, NULL, m, args); + + return l; } -jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args) +jlong _Jv_JNI_CallStaticLongMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - - log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!!!"); + log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!"); return 0; } -jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) +jfloat _Jv_JNI_CallStaticFloatMethod(JNIEnv *env, jclass clazz, + jmethodID methodID, ...) { - jfloat ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jfloat f; - /* log_text("JNI-Call: CallStaticLongMethod");*/ + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - ret = callFloatMethod(0, methodID, vaargs, PRIMITIVETYPE_FLOAT); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) + methodinfo *m; + jfloat f; + + m = (methodinfo *) methodID; - return callFloatMethod(0, methodID, args, PRIMITIVETYPE_FLOAT); + f = _Jv_jni_CallFloatMethod(NULL, NULL, m, args); + return f; } -jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args) +jfloat _Jv_JNI_CallStaticFloatMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticFloatMethodA"); + log_text("JNI-Call: CallStaticFloatMethodA: IMPLEMENT ME!"); return 0; } - -jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) +jdouble _Jv_JNI_CallStaticDoubleMethod(JNIEnv *env, jclass clazz, + jmethodID methodID, ...) { - jdouble ret; - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + jdouble d; - /* log_text("JNI-Call: CallStaticDoubleMethod");*/ + m = (methodinfo *) methodID; - va_start(vaargs,methodID); - ret = callFloatMethod(0, methodID, vaargs, PRIMITIVETYPE_DOUBLE); - va_end(vaargs); + va_start(ap, methodID); + 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) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticDoubleMethodV"); + methodinfo *m; + jdouble d; - return callFloatMethod(0, methodID, args, PRIMITIVETYPE_DOUBLE); + m = (methodinfo *) methodID; + + d = _Jv_jni_CallDoubleMethod(NULL, NULL, m, args); + + return d; } -jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args) +jdouble _Jv_JNI_CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue *args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticDoubleMethodA"); + log_text("JNI-Call: CallStaticDoubleMethodA: IMPLEMENT ME!"); return 0; } -void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...) +void _Jv_JNI_CallStaticVoidMethod(JNIEnv *env, jclass clazz, + jmethodID methodID, ...) { - va_list vaargs; - STATS(jniinvokation();) + methodinfo *m; + va_list ap; + + m = (methodinfo *) methodID; - va_start(vaargs, methodID); - (void) callIntegerMethod(0, methodID, TYPE_VOID, vaargs); - va_end(vaargs); + va_start(ap, methodID); + _Jv_jni_CallVoidMethod(NULL, NULL, m, ap); + va_end(ap); } -void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args) +void _Jv_JNI_CallStaticVoidMethodV(JNIEnv *env, jclass clazz, + jmethodID methodID, va_list args) { - log_text("JNI-Call: CallStaticVoidMethodV"); - STATS(jniinvokation();) - (void)callIntegerMethod(0, methodID, TYPE_VOID, args); + methodinfo *m; + + m = (methodinfo *) methodID; + + _Jv_jni_CallVoidMethod(NULL, NULL, m, args); } -void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args) +void _Jv_JNI_CallStaticVoidMethodA(JNIEnv *env, jclass clazz, + jmethodID methodID, jvalue * args) { - STATS(jniinvokation();) - log_text("JNI-Call: CallStaticVoidMethodA"); + methodinfo *m; + + m = (methodinfo *) methodID; + + _Jv_jni_CallVoidMethodA(NULL, NULL, m, args); } @@ -2644,19 +3666,27 @@ void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * *******************************************************************************/ -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; - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + utf *uname; + utf *usig; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; - f = class_findfield(clazz, - utf_new_char((char *) name), - utf_new_char((char *) sig)); + 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; } @@ -2667,111 +3697,168 @@ jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const cha *******************************************************************************/ -jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID) +jobject _Jv_JNI_GetStaticObjectField(JNIEnv *env, jclass clazz, + jfieldID fieldID) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); - if (!clazz->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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; - if (!clazz->initialized) - if (!initialize_class(clazz)) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); - if (!clazz->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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; - if (!clazz->initialized) - if (!initialize_class(clazz)) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); - if (!clazz->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; } @@ -2782,111 +3869,174 @@ jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID) *******************************************************************************/ -void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value) +void _Jv_JNI_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, + jobject value) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; - if (!clazz->initialized) - if (!initialize_class(clazz)) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); - if (!clazz->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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; - if (!clazz->initialized) - if (!initialize_class(clazz)) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; - if (!clazz->initialized) - if (!initialize_class(clazz)) + 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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; + + STATISTICS(jniinvokation()); - if (!clazz->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) { - STATS(jniinvokation();) + classinfo *c; + fieldinfo *f; - if (!clazz->initialized) - if (!initialize_class(clazz)) + STATISTICS(jniinvokation()); + + c = (classinfo *) clazz; + f = (fieldinfo *) fieldID; + + if (!(c->state & CLASS_INITIALIZED)) + if (!initialize_class(c)) return; - fieldID->value.d = value; + f->value.d = value; } @@ -2899,30 +4049,30 @@ void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble v *******************************************************************************/ -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; u4 i; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); s = (java_lang_String *) builtin_new(class_java_lang_String); 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); } @@ -2935,7 +4085,7 @@ static jchar emptyStringJ[]={0,0}; *******************************************************************************/ -jsize GetStringLength(JNIEnv *env, jstring str) +jsize _Jv_JNI_GetStringLength(JNIEnv *env, jstring str) { return ((java_lang_String *) str)->count; } @@ -2950,7 +4100,7 @@ u2 *javastring_tou2(jstring so) u2 *stringbuffer; u4 i; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); s = (java_lang_String *) so; @@ -2982,15 +4132,15 @@ u2 *javastring_tou2(jstring so) /* GetStringChars ************************************************************** Returns a pointer to the array of Unicode characters of the - string. This pointer is valid until ReleaseStringchars() is called. + string. This pointer is valid until ReleaseStringChars() is called. *******************************************************************************/ -const jchar *GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy) +const jchar *_Jv_JNI_GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy) { jchar *jc; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); jc = javastring_tou2(str); @@ -3016,9 +4166,9 @@ const jchar *GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy) *******************************************************************************/ -void ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars) +void _Jv_JNI_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (chars == emptyStringJ) return; @@ -3029,28 +4179,30 @@ void ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars) /* NewStringUTF **************************************************************** - Constructs a new java.lang.String object from an array of UTF-8 characters. + Constructs a new java.lang.String object from an array of UTF-8 + characters. *******************************************************************************/ -jstring NewStringUTF(JNIEnv *env, const char *bytes) +jstring _Jv_JNI_NewStringUTF(JNIEnv *env, const char *bytes) { java_lang_String *s; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - s = javastring_new(utf_new_char(bytes)); + s = (java_lang_String *) 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; - STATS(jniinvokation();) + + STATISTICS(jniinvokation()); return (jsize) u2_utflength(s->value->data, s->count); } @@ -3064,20 +4216,22 @@ jsize GetStringUTFLength (JNIEnv *env, jstring string) *******************************************************************************/ -const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy) +const char *_Jv_JNI_GetStringUTFChars(JNIEnv *env, jstring string, + jboolean *isCopy) { utf *u; - STATS(jniinvokation();) - if (!string) + STATISTICS(jniinvokation()); + + if (string == NULL) return ""; if (isCopy) *isCopy = JNI_TRUE; - u = javastring_toutf((java_lang_String *) string, false); + u = javastring_toutf((java_objectheader *) string, false); - if (u) + if (u != NULL) return u->text; return ""; @@ -3092,9 +4246,9 @@ const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy) *******************************************************************************/ -void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf) +void _Jv_JNI_ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); /* XXX we don't release utf chars right now, perhaps that should be done later. Since there is always one reference the garbage collector will @@ -3110,11 +4264,15 @@ void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf) *******************************************************************************/ -jsize GetArrayLength(JNIEnv *env, jarray array) +jsize _Jv_JNI_GetArrayLength(JNIEnv *env, jarray array) { - STATS(jniinvokation();) + java_arrayheader *a; + + STATISTICS(jniinvokation()); - return array->size; + a = (java_arrayheader *) array; + + return a->size; } @@ -3125,21 +4283,22 @@ jsize GetArrayLength(JNIEnv *env, jarray array) *******************************************************************************/ -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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (length < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } oa = builtin_anewarray(length, elementClass); - if (!oa) + if (oa == NULL) return NULL; /* set all elements to initialElement */ @@ -3147,178 +4306,190 @@ jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobj 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - if (index >= array->header.size) { - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + 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) { - STATS(jniinvokation();) - if (index >= array->header.size) - *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + java_objectarray *oa; + java_objectheader *o; - else { - /* check if the class of value is a subclass of the element class of the array */ - if (!builtin_canstore((java_objectarray *) array, (java_objectheader *) val)) - *exceptionptr = new_exception(string_java_lang_ArrayStoreException); + STATISTICS(jniinvokation()); - else - array->data[index] = val; - } + oa = (java_objectarray *) array; + o = (java_objectheader *) val; + + if (index >= oa->header.size) { + exceptions_throw_arrayindexoutofboundsexception(); + return; + } + + /* check if the class of value is a subclass of the element class + of the array */ + + if (!builtin_canstore(oa, o)) + return; + + oa->data[index] = val; } -jbooleanArray NewBooleanArray(JNIEnv *env, jsize len) +jbooleanArray _Jv_JNI_NewBooleanArray(JNIEnv *env, jsize len) { java_booleanarray *ba; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } 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; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); if (len < 0) { - *exceptionptr = new_negativearraysizeexception(); + exceptions_throw_negativearraysizeexception(); return NULL; } da = builtin_newarray_double(len); - return (jdoubleArray) NewLocalRef(env, (jobject) da); + return (jdoubleArray) _Jv_JNI_NewLocalRef(env, (jobject) da); } @@ -3328,93 +4499,134 @@ jdoubleArray NewDoubleArray(JNIEnv *env, jsize len) *******************************************************************************/ -jboolean *GetBooleanArrayElements(JNIEnv *env, jbooleanArray array, - jboolean *isCopy) +jboolean *_Jv_JNI_GetBooleanArrayElements(JNIEnv *env, jbooleanArray array, + jboolean *isCopy) { - STATS(jniinvokation();) + java_booleanarray *ba; - if (isCopy) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + java_bytearray *ba; - if (isCopy) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + java_chararray *ca; - if (isCopy) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + java_shortarray *sa; - if (isCopy) + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) + 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) { - STATS(jniinvokation();) + 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) { - STATS(jniinvokation();) + java_floatarray *fa; + + STATISTICS(jniinvokation()); + + fa = (java_floatarray *) array; - if (isCopy) + 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) { - STATS(jniinvokation();) + java_doublearray *da; + + STATISTICS(jniinvokation()); + + da = (java_doublearray *) array; - if (isCopy) + if (isCopy) *isCopy = JNI_FALSE; - return array->data; + return da->data; } @@ -3429,18 +4641,22 @@ jdouble *GetDoubleArrayElements(JNIEnv *env, jdoubleArray array, *******************************************************************************/ -void ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array, - jboolean *elems, jint mode) +void _Jv_JNI_ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array, + jboolean *elems, jint mode) { - STATS(jniinvokation();) + java_booleanarray *ba; + + STATISTICS(jniinvokation()); + + ba = (java_booleanarray *) array; - if (elems != array->data) { + 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: @@ -3451,18 +4667,22 @@ void ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array, } -void ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, jbyte *elems, - jint mode) +void _Jv_JNI_ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, + jbyte *elems, jint mode) { - STATS(jniinvokation();) + 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: @@ -3473,18 +4693,22 @@ void ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, jbyte *elems, } -void ReleaseCharArrayElements(JNIEnv *env, jcharArray array, jchar *elems, - jint mode) +void _Jv_JNI_ReleaseCharArrayElements(JNIEnv *env, jcharArray array, + jchar *elems, jint mode) { - STATS(jniinvokation();) + java_chararray *ca; - if (elems != array->data) { + STATISTICS(jniinvokation()); + + 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: @@ -3495,18 +4719,22 @@ void ReleaseCharArrayElements(JNIEnv *env, jcharArray array, jchar *elems, } -void ReleaseShortArrayElements(JNIEnv *env, jshortArray array, jshort *elems, - jint mode) +void _Jv_JNI_ReleaseShortArrayElements(JNIEnv *env, jshortArray array, + jshort *elems, jint mode) { - STATS(jniinvokation();) + 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: @@ -3517,18 +4745,22 @@ void ReleaseShortArrayElements(JNIEnv *env, jshortArray array, jshort *elems, } -void ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems, - jint mode) +void _Jv_JNI_ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems, + jint mode) { - STATS(jniinvokation();) + java_intarray *ia; + + STATISTICS(jniinvokation()); + + ia = (java_intarray *) array; - if (elems != array->data) { + 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: @@ -3539,18 +4771,25 @@ void ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems, } -void ReleaseLongArrayElements(JNIEnv *env, jlongArray array, jlong *elems, - jint mode) +void _Jv_JNI_ReleaseLongArrayElements(JNIEnv *env, jlongArray array, + jlong *elems, jint mode) { - STATS(jniinvokation();) + java_longarray *la; + + STATISTICS(jniinvokation()); + + 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 (elems != array->data) { + 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: @@ -3561,18 +4800,22 @@ void ReleaseLongArrayElements(JNIEnv *env, jlongArray array, jlong *elems, } -void ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array, jfloat *elems, - jint mode) +void _Jv_JNI_ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array, + jfloat *elems, jint mode) { - STATS(jniinvokation();) + 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: @@ -3583,18 +4826,22 @@ void ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array, jfloat *elems, } -void ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array, - jdouble *elems, jint mode) +void _Jv_JNI_ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array, + jdouble *elems, jint mode) { - STATS(jniinvokation();) + java_doublearray *da; - if (elems != array->data) { + STATISTICS(jniinvokation()); + + 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: @@ -3612,115 +4859,131 @@ void ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array, *******************************************************************************/ -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) { - STATS(jniinvokation();) + java_booleanarray *ba; + + STATISTICS(jniinvokation()); - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + 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) { - STATS(jniinvokation();) + java_bytearray *ba; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(buf, &array->data[start], jbyte, len); + ba = (java_bytearray *) array; + + if ((start < 0) || (len < 0) || (start + len > ba->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_chararray *ca; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(buf, &array->data[start], jchar, len); + ca = (java_chararray *) array; + + if ((start < 0) || (len < 0) || (start + len > ca->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_shortarray *sa; + + STATISTICS(jniinvokation()); - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + sa = (java_shortarray *) array; - else - MCOPY(buf, &array->data[start], jshort, len); + if ((start < 0) || (len < 0) || (start + len > sa->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_intarray *ia; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(buf, &array->data[start], jint, len); + ia = (java_intarray *) array; + + if ((start < 0) || (len < 0) || (start + len > ia->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_longarray *la; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(buf, &array->data[start], jlong, len); + la = (java_longarray *) array; + + if ((start < 0) || (len < 0) || (start + len > la->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_floatarray *fa; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(buf, &array->data[start], jfloat, len); + fa = (java_floatarray *) array; + + if ((start < 0) || (len < 0) || (start + len > fa->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_doublearray *da; - if (start < 0 || len < 0 || start+len>array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(buf, &array->data[start], jdouble, len); + da = (java_doublearray *) array; + + if ((start < 0) || (len < 0) || (start + len > da->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + else + MCOPY(buf, &da->data[start], double, len); } @@ -3731,119 +4994,131 @@ void GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start, *******************************************************************************/ -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) { - STATS(jniinvokation();) + java_booleanarray *ba; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jboolean, len); + ba = (java_booleanarray *) array; + + if ((start < 0) || (len < 0) || (start + len > ba->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_bytearray *ba; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jbyte, len); + ba = (java_bytearray *) array; + + if ((start < 0) || (len < 0) || (start + len > ba->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_chararray *ca; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jchar, len); + ca = (java_chararray *) array; + if ((start < 0) || (len < 0) || (start + len > ca->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_shortarray *sa; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jshort, len); + sa = (java_shortarray *) array; + + if ((start < 0) || (len < 0) || (start + len > sa->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_intarray *ia; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jint, len); + ia = (java_intarray *) array; + if ((start < 0) || (len < 0) || (start + len > ia->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_longarray *la; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jlong, len); + la = (java_longarray *) array; + if ((start < 0) || (len < 0) || (start + len > la->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_floatarray *fa; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jfloat, len); + fa = (java_floatarray *) array; + if ((start < 0) || (len < 0) || (start + len > fa->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + 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) { - STATS(jniinvokation();) + java_doublearray *da; - if (start < 0 || len < 0 || start + len > array->header.size) - *exceptionptr = - new_exception(string_java_lang_ArrayIndexOutOfBoundsException); + STATISTICS(jniinvokation()); - else - MCOPY(&array->data[start], buf, jdouble, len); + da = (java_doublearray *) array; + + if ((start < 0) || (len < 0) || (start + len > da->header.size)) + exceptions_throw_arrayindexoutofboundsexception(); + else + MCOPY(&da->data[start], buf, double, len); } @@ -3859,12 +5134,15 @@ void SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start, *******************************************************************************/ -jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, - jint nMethods) +jint _Jv_JNI_RegisterNatives(JNIEnv *env, jclass clazz, + const JNINativeMethod *methods, jint nMethods) { - STATS(jniinvokation();) + 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; } @@ -3882,9 +5160,9 @@ jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, *******************************************************************************/ -jint UnregisterNatives(JNIEnv *env, jclass clazz) +jint _Jv_JNI_UnregisterNatives(JNIEnv *env, jclass clazz) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); /* XXX TWISTI hmm, maybe we should not support that (like kaffe) */ @@ -3903,18 +5181,16 @@ jint UnregisterNatives(JNIEnv *env, jclass clazz) *******************************************************************************/ -jint MonitorEnter(JNIEnv *env, jobject obj) +jint _Jv_JNI_MonitorEnter(JNIEnv *env, jobject obj) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - if (!obj) { - *exceptionptr = new_nullpointerexception(); + if (obj == NULL) { + exceptions_throw_nullpointerexception(); return JNI_ERR; } -#if defined(USE_THREADS) - builtin_monitorenter(obj); -#endif + LOCK_MONITOR_ENTER(obj); return JNI_OK; } @@ -3930,17 +5206,16 @@ jint MonitorEnter(JNIEnv *env, jobject obj) *******************************************************************************/ -jint MonitorExit(JNIEnv *env, jobject obj) +jint _Jv_JNI_MonitorExit(JNIEnv *env, jobject obj) { - STATS(jniinvokation();) - if (!obj) { - *exceptionptr = new_nullpointerexception(); + STATISTICS(jniinvokation()); + + if (obj == NULL) { + exceptions_throw_nullpointerexception(); return JNI_ERR; } -#if defined(USE_THREADS) - builtin_monitorexit(obj); -#endif + LOCK_MONITOR_EXIT(obj); return JNI_OK; } @@ -3956,26 +5231,52 @@ jint MonitorExit(JNIEnv *env, jobject obj) *******************************************************************************/ -jint GetJavaVM(JNIEnv *env, JavaVM **vm) +jint _Jv_JNI_GetJavaVM(JNIEnv *env, JavaVM **vm) { - STATS(jniinvokation();) - *vm = &ptr_jvm; + STATISTICS(jniinvokation()); + + *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) { - STATS(jniinvokation();) - log_text("JNI-Call: GetStringRegion"); + java_lang_String *s; + java_chararray *ca; + + STATISTICS(jniinvokation()); + + 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) { - STATS(jniinvokation();) - log_text("JNI-Call: GetStringUTFRegion"); + STATISTICS(jniinvokation()); + + log_text("JNI-Call: GetStringUTFRegion: IMPLEMENT ME!"); } @@ -3985,11 +5286,19 @@ void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *******************************************************************************/ -void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy) +void *_Jv_JNI_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, + jboolean *isCopy) { + java_bytearray *ba; + jbyte *bp; + + ba = (java_bytearray *) array; + /* do the same as Kaffe does */ - return GetByteArrayElements(env, (jbyteArray) array, isCopy); + bp = _Jv_JNI_GetByteArrayElements(env, ba, isCopy); + + return (void *) bp; } @@ -3999,14 +5308,15 @@ void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy) *******************************************************************************/ -void ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, - jint mode) +void _Jv_JNI_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, + void *carray, jint mode) { - STATS(jniinvokation();) + STATISTICS(jniinvokation()); /* do the same as Kaffe does */ - ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray, mode); + _Jv_JNI_ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray, + mode); } @@ -4017,37 +5327,39 @@ void ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, *******************************************************************************/ -const jchar *GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy) +const jchar *_Jv_JNI_GetStringCritical(JNIEnv *env, jstring string, + jboolean *isCopy) { - STATS(jniinvokation();) + 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) { - STATS(jniinvokation();) + 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) { - STATS(jniinvokation();) - log_text("JNI-Call: NewWeakGlobalRef"); + STATISTICS(jniinvokation()); + + log_text("JNI-Call: NewWeakGlobalRef: IMPLEMENT ME!"); return obj; } -void DeleteWeakGlobalRef (JNIEnv* env, jweak ref) +void _Jv_JNI_DeleteWeakGlobalRef(JNIEnv* env, jweak ref) { - STATS(jniinvokation();) - log_text("JNI-Call: DeleteWeakGlobalRef"); + STATISTICS(jniinvokation()); - /* empty */ + log_text("JNI-Call: DeleteWeakGlobalRef: IMPLEMENT ME"); } @@ -4058,44 +5370,58 @@ void DeleteWeakGlobalRef (JNIEnv* env, jweak ref) *******************************************************************************/ -jobject NewGlobalRef(JNIEnv* env, jobject lobj) +jobject _Jv_JNI_NewGlobalRef(JNIEnv* env, jobject obj) { - java_lang_Integer *refcount; - java_objectheader *newval; + hashtable_global_ref_entry *gre; + u4 key; /* hashkey */ + u4 slot; /* slot in hashtable */ - STATS(jniinvokation();) + 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]; - refcount = (java_lang_Integer *) - asm_calljavafunction(getmid, *global_ref_table, lobj, NULL, NULL); + /* search external hash chain for the entry */ - if (refcount == NULL) { - newval = native_new_and_init_int(class_java_lang_Integer, 1); + while (gre) { + if (gre->o == obj) { + /* global object found, increment the reference */ - if (newval == NULL) { -#if defined(USE_THREADS) - builtin_monitorexit(*global_ref_table); -#endif - return NULL; - } + gre->refs++; - asm_calljavafunction(putmid, *global_ref_table, lobj, newval, NULL); + LOCK_MONITOR_EXIT(hashtable_global_ref->header); - } else { - /* we can access the object itself, as we are in a - synchronized section */ + return obj; + } - refcount->value++; + gre = gre->hashlink; /* next element in external chain */ } -#if defined(USE_THREADS) - builtin_monitorexit(*global_ref_table); -#endif + /* global ref not found, create a new one */ + + gre = NEW(hashtable_global_ref_entry); + + gre->o = obj; + gre->refs = 1; + + /* 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; } @@ -4105,44 +5431,60 @@ jobject NewGlobalRef(JNIEnv* env, jobject lobj) *******************************************************************************/ -void DeleteGlobalRef(JNIEnv* env, jobject globalRef) +void _Jv_JNI_DeleteGlobalRef(JNIEnv* env, jobject globalRef) { - java_lang_Integer *refcount; - s4 val; + hashtable_global_ref_entry *gre; + hashtable_global_ref_entry *prevgre; + u4 key; /* hashkey */ + u4 slot; /* slot in hashtable */ - STATS(jniinvokation();) + STATISTICS(jniinvokation()); -#if defined(USE_THREADS) - builtin_monitorenter(*global_ref_table); -#endif + LOCK_MONITOR_ENTER(hashtable_global_ref->header); - refcount = (java_lang_Integer *) - asm_calljavafunction(getmid, *global_ref_table, globalRef, NULL, NULL); + /* normally addresses are aligned to 4, 8 or 16 bytes */ - if (refcount == NULL) { - log_text("JNI-DeleteGlobalRef: unable to find global reference"); - return; - } + key = ((u4) (ptrint) globalRef) >> 4; /* align to 16-byte boundaries */ + slot = key & (hashtable_global_ref->size - 1); + gre = hashtable_global_ref->ptr[slot]; - /* we can access the object itself, as we are in a synchronized - section */ + /* initialize prevgre */ - val = refcount->value - 1; + prevgre = NULL; - if (val == 0) { - asm_calljavafunction(removemid, *global_ref_table, refcount, NULL, - NULL); + /* search external hash chain for the entry */ - } else { - /* we do not create a new object, but set the new value into - the old one */ + while (gre) { + if (gre->o == globalRef) { + /* global object found, decrement the reference count */ + + 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); } @@ -4153,10 +5495,15 @@ void DeleteGlobalRef(JNIEnv* env, jobject globalRef) *******************************************************************************/ -jboolean ExceptionCheck(JNIEnv *env) +jboolean _Jv_JNI_ExceptionCheck(JNIEnv *env) { - STATS(jniinvokation();) - return *exceptionptr ? JNI_TRUE : JNI_FALSE; + java_objectheader *o; + + STATISTICS(jniinvokation()); + + o = exceptions_get_exception(); + + return (o != NULL) ? JNI_TRUE : JNI_FALSE; } @@ -4170,47 +5517,49 @@ jboolean ExceptionCheck(JNIEnv *env) *******************************************************************************/ -jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity) +jobject _Jv_JNI_NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity) { - java_nio_DirectByteBufferImpl *nbuf; -#if SIZEOF_VOID_P == 8 +#if defined(ENABLE_JAVASE) + java_objectheader *nbuf; +# if SIZEOF_VOID_P == 8 gnu_classpath_Pointer64 *paddress; -#else +# else gnu_classpath_Pointer32 *paddress; -#endif - - STATS(jniinvokation();) - - log_text("JNI-NewDirectByteBuffer: called"); - - /* allocate a java.nio.DirectByteBufferImpl object */ +# endif - if (!(nbuf = (java_nio_DirectByteBufferImpl *) builtin_new(class_java_nio_DirectByteBufferImpl))) - return NULL; + STATISTICS(jniinvokation()); /* alocate a gnu.classpath.Pointer{32,64} object */ -#if SIZEOF_VOID_P == 8 - if (!(paddress = (gnu_classpath_Pointer64 *) builtin_new(class_gnu_classpath_Pointer64))) -#else - if (!(paddress = (gnu_classpath_Pointer32 *) builtin_new(class_gnu_classpath_Pointer32))) -#endif +# if SIZEOF_VOID_P == 8 + if (!(paddress = (gnu_classpath_Pointer64 *) + builtin_new(class_gnu_classpath_Pointer64))) +# else + if (!(paddress = (gnu_classpath_Pointer32 *) + builtin_new(class_gnu_classpath_Pointer32))) +# endif return NULL; /* fill gnu.classpath.Pointer{32,64} with address */ paddress->data = (ptrint) address; - /* fill java.nio.Buffer object */ + /* create a java.nio.DirectByteBufferImpl$ReadWrite object */ - nbuf->cap = (s4) capacity; - nbuf->limit = (s4) capacity; - nbuf->pos = 0; - nbuf->address = (gnu_classpath_Pointer *) paddress; + nbuf = (*env)->NewObject(env, class_java_nio_DirectByteBufferImpl_ReadWrite, + (jmethodID) dbbirw_init, NULL, paddress, + (jint) capacity, (jint) capacity, (jint) 0); /* add local reference and return the value */ - return NewLocalRef(env, (jobject) nbuf); + return _Jv_JNI_NewLocalRef(env, nbuf); +#else + vm_abort("_Jv_JNI_NewDirectByteBuffer: not implemented in this configuration"); + + /* keep compiler happy */ + + return NULL; +#endif } @@ -4221,31 +5570,40 @@ jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity) *******************************************************************************/ -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 - STATS(jniinvokation();) + STATISTICS(jniinvokation()); -#if 0 - if (!builtin_instanceof(buf, class_java_nio_DirectByteBufferImpl)) + if (!builtin_instanceof(buf, class_java_nio_Buffer)) return NULL; -#endif 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 } @@ -4256,27 +5614,46 @@ void *GetDirectBufferAddress(JNIEnv *env, jobject buf) *******************************************************************************/ -jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf) +jlong _Jv_JNI_GetDirectBufferCapacity(JNIEnv* env, jobject buf) { +#if defined(ENABLE_JAVASE) java_nio_Buffer *nbuf; - STATS(jniinvokation();) + STATISTICS(jniinvokation()); - if (buf == NULL) + if (!builtin_instanceof(buf, class_java_nio_DirectByteBufferImpl)) return -1; 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) { - STATS(jniinvokation();) - log_text("DestroyJavaVM called"); + s4 status; - return 0; + STATISTICS(jniinvokation()); + + status = vm_destroy(vm); + + return status; } @@ -4294,30 +5671,79 @@ jint DestroyJavaVM(JavaVM *vm) *******************************************************************************/ -jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args) +static s4 jni_attach_current_thread(void **p_env, void *thr_args, bool isdaemon) { - STATS(jniinvokation();) + JavaVMAttachArgs *vm_aargs; - log_text("AttachCurrentThread called"); +#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) { - STATS(jniinvokation();) - log_text("DetachCurrentThread called"); + STATISTICS(jniinvokation()); - return 0; + return jni_attach_current_thread(p_env, thr_args, false); +} + + +/* 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 (!jni_free_localref_table()) + return JNI_ERR; + + if (!threads_detach_thread(thread)) + return JNI_ERR; +#endif + + return JNI_OK; } @@ -4330,28 +5756,36 @@ jint DetachCurrentThread(JavaVM *vm) *******************************************************************************/ -jint GetEnv(JavaVM *vm, void **env, jint version) +jint _Jv_JNI_GetEnv(JavaVM *vm, void **env, jint version) { - STATS(jniinvokation();) + 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; @@ -4364,301 +5798,312 @@ jint GetEnv(JavaVM *vm, void **env, jint version) } +/* AttachCurrentThreadAsDaemon ************************************************* + + Same semantics as AttachCurrentThread, but the newly-created + java.lang.Thread instance is a daemon. + + 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 AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2) +*******************************************************************************/ + +jint _Jv_JNI_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *args) { - STATS(jniinvokation();) - log_text("AttachCurrentThreadAsDaemon called"); + STATISTICS(jniinvokation()); - 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 }; @@ -4672,12 +6117,28 @@ struct JNINativeInterface JNI_JNIEnvTable = { 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; } @@ -4706,246 +6167,14 @@ jint JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs) *******************************************************************************/ -jint JNI_CreateJavaVM(JavaVM **p_vm, JNIEnv **p_env, void *vm_args) -{ - const struct JNIInvokeInterface *vm; - struct JNINativeInterface *env; - - vm = &JNI_JavaVMTable; - env = &JNI_JNIEnvTable; - - *p_vm = (JavaVM *) vm; - *p_env = (JNIEnv *) env; - - return 0; -} - - -jobject *jni_method_invokeNativeHelper(JNIEnv *env, methodinfo *methodID, - jobject obj, java_objectarray *params) +jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args) { - jni_callblock *blk; - jobject o; - s4 argcount; - s4 paramcount; - - if (methodID == 0) { - *exceptionptr = new_exception(string_java_lang_NoSuchMethodError); - return NULL; - } - - argcount = methodID->parseddesc->paramcount; - paramcount = argcount; - - /* if method is non-static, remove the `this' pointer */ - - if (!(methodID->flags & ACC_STATIC)) - paramcount--; - - /* the method is an instance method the obj has to be an instance of the - class the method belongs to. For static methods the obj parameter - is ignored. */ - - if (!(methodID->flags & ACC_STATIC) && obj && - (!builtin_instanceof((java_objectheader *) obj, methodID->class))) { - *exceptionptr = - new_exception_message(string_java_lang_IllegalArgumentException, - "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative"); - return NULL; - } - - if (((params == NULL) && (paramcount != 0)) || - (params && (params->header.size != paramcount))) { - *exceptionptr = - new_exception(string_java_lang_IllegalArgumentException); - return NULL; - } - + /* actually create the JVM */ - if (!(methodID->flags & ACC_STATIC) && !obj) { - *exceptionptr = - new_exception_message(string_java_lang_NullPointerException, - "Static mismatch in Java_java_lang_reflect_Method_invokeNative"); - return NULL; - } - - if ((methodID->flags & ACC_STATIC) && (obj)) - obj = NULL; - - if (obj) { - if ((methodID->flags & ACC_ABSTRACT) || - (methodID->class->flags & ACC_INTERFACE)) { - methodID = get_virtual(obj, methodID); - } - } - - blk = MNEW(jni_callblock, argcount); - - if (!fill_callblock_from_objectarray(obj, methodID->parseddesc, blk, - params)) - return NULL; - - switch (methodID->parseddesc->returntype.decltype) { - case TYPE_VOID: - (void) asm_calljavafunction2(methodID, argcount, - argcount * sizeof(jni_callblock), - blk); - o = NULL; /*native_new_and_init(loader_load(utf_new_char("java/lang/Void")));*/ - break; - - case PRIMITIVETYPE_INT: { - s4 i; - i = asm_calljavafunction2int(methodID, argcount, - argcount * sizeof(jni_callblock), - blk); - - o = native_new_and_init_int(class_java_lang_Integer, i); - } - break; - - case PRIMITIVETYPE_BYTE: { - s4 i; - i = asm_calljavafunction2int(methodID, argcount, - argcount * sizeof(jni_callblock), - blk); - -/* o = native_new_and_init_int(class_java_lang_Byte, i); */ - o = builtin_new(class_java_lang_Byte); - CallVoidMethod(env, - o, - class_resolvemethod(o->vftbl->class, - utf_init, - utf_byte__void), - i); - } - break; - - case PRIMITIVETYPE_CHAR: { - s4 intVal; - intVal = asm_calljavafunction2int(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); - o = builtin_new(class_java_lang_Character); - CallVoidMethod(env, - o, - class_resolvemethod(o->vftbl->class, - utf_init, - utf_char__void), - intVal); - } - break; - - case PRIMITIVETYPE_SHORT: { - s4 intVal; - intVal = asm_calljavafunction2int(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); - o = builtin_new(class_java_lang_Short); - CallVoidMethod(env, - o, - class_resolvemethod(o->vftbl->class, - utf_init, - utf_short__void), - intVal); - } - break; - - case PRIMITIVETYPE_BOOLEAN: { - s4 intVal; - intVal = asm_calljavafunction2int(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); - o = builtin_new(class_java_lang_Boolean); - CallVoidMethod(env, - o, - class_resolvemethod(o->vftbl->class, - utf_init, - utf_boolean__void), - intVal); - } - break; - - case PRIMITIVETYPE_LONG: { - jlong longVal; - longVal = asm_calljavafunction2long(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); - o = builtin_new(class_java_lang_Long); - CallVoidMethod(env, - o, - class_resolvemethod(o->vftbl->class, - utf_init, - utf_long__void), - longVal); - } - break; - - case PRIMITIVETYPE_FLOAT: { - jdouble floatVal; - floatVal = asm_calljavafunction2float(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); - o = builtin_new(class_java_lang_Float); - CallVoidMethod(env, - o, - class_resolvemethod(o->vftbl->class, - utf_init, - utf_float__void), - floatVal); - } - break; - - case PRIMITIVETYPE_DOUBLE: { - jdouble doubleVal; - doubleVal = asm_calljavafunction2double(methodID, - argcount, - argcount * sizeof(jni_callblock), - blk); - o = builtin_new(class_java_lang_Double); - CallVoidMethod(env, - o, - class_resolvemethod(o->vftbl->class, - utf_init, - utf_double__void), - doubleVal); - } - break; - - case TYPE_ADR: - o = asm_calljavafunction2(methodID, argcount, - argcount * sizeof(jni_callblock), blk); - break; - - default: - /* if this happens the exception has already been set by */ - /* fill_callblock_from_objectarray */ - - MFREE(blk, jni_callblock, argcount); - return (jobject *) 0; - } - - MFREE(blk, jni_callblock, argcount); - - if (*exceptionptr) { - java_objectheader *cause; - - cause = *exceptionptr; - - /* clear exception pointer, we are calling JIT code again */ - - *exceptionptr = NULL; - - *exceptionptr = - new_exception_throwable(string_java_lang_reflect_InvocationTargetException, - (java_lang_Throwable *) cause); - } + if (!vm_createjvm(p_vm, p_env, vm_args)) + return JNI_ERR; - return (jobject *) o; + return JNI_OK; } @@ -4960,4 +6189,5 @@ jobject *jni_method_invokeNativeHelper(JNIEnv *env, methodinfo *methodID, * c-basic-offset: 4 * tab-width: 4 * End: + * vim:noexpandtab:sw=4:ts=4: */