1 /* src/native/jni.c - implementation of the Java Native Interface functions
3 Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
4 C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
5 E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
6 J. Wenninger, Institut f. Computersprachen - TU Wien
8 This file is part of CACAO.
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2, or (at
13 your option) any later version.
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 $Id: jni.c 7441 2007-03-02 23:13:10Z michi $
37 #include "mm/gc-common.h"
38 #include "mm/memory.h"
39 #include "native/jni.h"
40 #include "native/native.h"
42 #if defined(ENABLE_JAVASE)
43 # if defined(WITH_CLASSPATH_GNU)
44 # include "native/include/gnu_classpath_Pointer.h"
46 # if SIZEOF_VOID_P == 8
47 # include "native/include/gnu_classpath_Pointer64.h"
49 # include "native/include/gnu_classpath_Pointer32.h"
54 #include "native/include/java_lang_Object.h"
55 #include "native/include/java_lang_Byte.h"
56 #include "native/include/java_lang_Character.h"
57 #include "native/include/java_lang_Short.h"
58 #include "native/include/java_lang_Integer.h"
59 #include "native/include/java_lang_Boolean.h"
60 #include "native/include/java_lang_Long.h"
61 #include "native/include/java_lang_Float.h"
62 #include "native/include/java_lang_Double.h"
63 #include "native/include/java_lang_String.h"
64 #include "native/include/java_lang_Throwable.h"
66 #if defined(ENABLE_JAVASE)
67 # include "native/include/java_lang_ClassLoader.h"
69 # include "native/include/java_lang_reflect_Constructor.h"
70 # include "native/include/java_lang_reflect_Field.h"
71 # include "native/include/java_lang_reflect_Method.h"
73 # include "native/include/java_nio_Buffer.h"
74 # include "native/include/java_nio_DirectByteBufferImpl.h"
77 #if defined(ENABLE_JVMTI)
78 # include "native/jvmti/cacaodbg.h"
81 #include "native/vm/java_lang_Class.h"
83 #if defined(ENABLE_JAVASE)
84 # include "native/vm/java_lang_ClassLoader.h"
87 #if defined(ENABLE_THREADS)
88 # include "threads/native/lock.h"
89 # include "threads/native/threads.h"
91 # include "threads/none/lock.h"
92 # include "threads/none/threads.h"
95 #include "toolbox/logging.h"
97 #include "vm/builtin.h"
98 #include "vm/exceptions.h"
99 #include "vm/global.h"
100 #include "vm/initialize.h"
101 #include "vm/stringlocal.h"
104 #include "vm/jit/asmpart.h"
105 #include "vm/jit/jit.h"
106 #include "vm/jit/stacktrace.h"
108 #include "vmcore/loader.h"
109 #include "vmcore/options.h"
110 #include "vmcore/resolve.h"
111 #include "vmcore/statistics.h"
114 /* global variables ***********************************************************/
116 /* global reference table *****************************************************/
118 /* hashsize must be power of 2 */
120 #define HASHTABLE_GLOBAL_REF_SIZE 64 /* initial size of globalref-hash */
122 hashtable *hashtable_global_ref; /* hashtable for globalrefs */
125 /* direct buffer stuff ********************************************************/
127 #if defined(ENABLE_JAVASE)
128 static classinfo *class_java_nio_Buffer;
129 static classinfo *class_java_nio_DirectByteBufferImpl;
130 static classinfo *class_java_nio_DirectByteBufferImpl_ReadWrite;
132 # if defined(WITH_CLASSPATH_GNU)
133 # if SIZEOF_VOID_P == 8
134 static classinfo *class_gnu_classpath_Pointer64;
136 static classinfo *class_gnu_classpath_Pointer32;
140 static methodinfo *dbbirw_init;
144 /* local reference table ******************************************************/
146 #if !defined(ENABLE_THREADS)
147 localref_table *_no_threads_localref_table;
151 /* accessing instance fields macros *******************************************/
153 #define SET_FIELD(o,type,f,value) \
154 *((type *) ((ptrint) (o) + (ptrint) ((fieldinfo *) (f))->offset)) = (type) (value)
156 #define GET_FIELD(o,type,f) \
157 *((type *) ((ptrint) (o) + (ptrint) ((fieldinfo *) (f))->offset))
160 /* some forward declarations **************************************************/
162 jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref);
163 jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity);
166 /* jni_init ********************************************************************
168 Initialize the JNI subsystem.
170 *******************************************************************************/
174 /* create global ref hashtable */
176 hashtable_global_ref = NEW(hashtable);
178 hashtable_create(hashtable_global_ref, HASHTABLE_GLOBAL_REF_SIZE);
181 #if defined(ENABLE_JAVASE)
182 /* direct buffer stuff */
184 if (!(class_java_nio_Buffer =
185 load_class_bootstrap(utf_new_char("java/nio/Buffer"))) ||
186 !link_class(class_java_nio_Buffer))
189 if (!(class_java_nio_DirectByteBufferImpl =
190 load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl"))) ||
191 !link_class(class_java_nio_DirectByteBufferImpl))
194 if (!(class_java_nio_DirectByteBufferImpl_ReadWrite =
195 load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl$ReadWrite"))) ||
196 !link_class(class_java_nio_DirectByteBufferImpl_ReadWrite))
200 class_resolvemethod(class_java_nio_DirectByteBufferImpl_ReadWrite,
202 utf_new_char("(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V"))))
205 # if defined(WITH_CLASSPATH_GNU)
206 # if SIZEOF_VOID_P == 8
207 if (!(class_gnu_classpath_Pointer64 =
208 load_class_bootstrap(utf_new_char("gnu/classpath/Pointer64"))) ||
209 !link_class(class_gnu_classpath_Pointer64))
212 if (!(class_gnu_classpath_Pointer32 =
213 load_class_bootstrap(utf_new_char("gnu/classpath/Pointer32"))) ||
214 !link_class(class_gnu_classpath_Pointer32))
218 #endif /* defined(ENABLE_JAVASE) */
224 /* jni_init_localref_table *****************************************************
226 Initializes the local references table of the current thread.
228 *******************************************************************************/
230 bool jni_init_localref_table(void)
234 #if defined(ENABLE_GC_CACAO)
235 /* XXX this one will never get freed for the main thread;
236 call jni_free_localref_table() if you want to do it! */
237 lrt = NEW(localref_table);
239 lrt = GCNEW(localref_table);
245 lrt->capacity = LOCALREFTABLE_CAPACITY;
247 lrt->localframes = 1;
248 lrt->prev = LOCALREFTABLE;
250 /* clear the references array (memset is faster then a for-loop) */
252 MSET(lrt->refs, 0, java_objectheader*, LOCALREFTABLE_CAPACITY);
260 /* jni_init_localref_table *****************************************************
262 Frees the local references table of the current thread.
264 *******************************************************************************/
266 bool jni_free_localref_table(void)
270 #if defined(ENABLE_GC_CACAO)
274 assert(lrt->prev == NULL);
276 FREE(lrt, localref_table);
278 LOCALREFTABLE = NULL;
285 /* _Jv_jni_vmargs_from_objectarray *********************************************
289 *******************************************************************************/
291 static bool _Jv_jni_vmargs_from_objectarray(java_objectheader *o,
294 java_objectarray *params)
296 java_objectheader *param;
298 typedesc *paramtypes;
304 paramcount = descr->paramcount;
305 paramtypes = descr->paramtypes;
307 /* if method is non-static fill first block and skip `this' pointer */
313 vmargs[0].type = TYPE_ADR;
314 vmargs[0].data.l = (u8) (ptrint) o;
321 for (j = 0; j < paramcount; i++, j++, paramtypes++) {
322 switch (paramtypes->type) {
323 /* primitive types */
328 param = params->data[j];
333 /* internally used data type */
334 vmargs[i].type = paramtypes->type;
336 /* convert the value according to its declared type */
338 c = param->vftbl->class;
340 switch (paramtypes->decltype) {
341 case PRIMITIVETYPE_BOOLEAN:
342 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
343 value = (s8) ((java_lang_Boolean *) param)->value;
347 vmargs[i].data.l = value;
350 case PRIMITIVETYPE_BYTE:
351 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
352 value = (s8) ((java_lang_Byte *) param)->value;
356 vmargs[i].data.l = value;
359 case PRIMITIVETYPE_CHAR:
360 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
361 value = (s8) ((java_lang_Character *) param)->value;
365 vmargs[i].data.l = value;
368 case PRIMITIVETYPE_SHORT:
369 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
370 value = (s8) ((java_lang_Short *) param)->value;
371 else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
372 value = (s8) ((java_lang_Byte *) param)->value;
376 vmargs[i].data.l = value;
379 case PRIMITIVETYPE_INT:
380 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
381 value = (s8) ((java_lang_Integer *) param)->value;
382 else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
383 value = (s8) ((java_lang_Short *) param)->value;
384 else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
385 value = (s8) ((java_lang_Byte *) param)->value;
389 vmargs[i].data.l = value;
392 case PRIMITIVETYPE_LONG:
393 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
394 value = (s8) ((java_lang_Long *) param)->value;
395 else if (c == primitivetype_table[PRIMITIVETYPE_INT].class_wrap)
396 value = (s8) ((java_lang_Integer *) param)->value;
397 else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
398 value = (s8) ((java_lang_Short *) param)->value;
399 else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
400 value = (s8) ((java_lang_Byte *) param)->value;
404 vmargs[i].data.l = value;
407 case PRIMITIVETYPE_FLOAT:
408 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
409 vmargs[i].data.f = (jfloat) ((java_lang_Float *) param)->value;
414 case PRIMITIVETYPE_DOUBLE:
415 if (c == primitivetype_table[paramtypes->decltype].class_wrap)
416 vmargs[i].data.d = (jdouble) ((java_lang_Double *) param)->value;
417 else if (c == primitivetype_table[PRIMITIVETYPE_FLOAT].class_wrap)
418 vmargs[i].data.f = (jfloat) ((java_lang_Float *) param)->value;
429 if (!resolve_class_from_typedesc(paramtypes, true, true, &c))
432 if (params->data[j] != 0) {
433 if (paramtypes->arraydim > 0) {
434 if (!builtin_arrayinstanceof(params->data[j], c))
438 if (!builtin_instanceof(params->data[j], c))
443 vmargs[i].type = TYPE_ADR;
444 vmargs[i].data.l = (u8) (ptrint) params->data[j];
453 /* *rettype = descr->returntype.decltype; */
458 exceptions_throw_illegalargumentexception();
463 /* _Jv_jni_CallObjectMethod ****************************************************
465 Internal function to call Java Object methods.
467 *******************************************************************************/
469 static java_objectheader *_Jv_jni_CallObjectMethod(java_objectheader *o,
471 methodinfo *m, va_list ap)
474 java_objectheader *ro;
476 STATISTICS(jniinvokation());
479 exceptions_throw_nullpointerexception();
483 /* Class initialization is done by the JIT compiler. This is ok
484 since a static method always belongs to the declaring class. */
486 if (m->flags & ACC_STATIC) {
487 /* For static methods we reset the object. */
492 /* for convenience */
497 /* For instance methods we make a virtual function table lookup. */
499 resm = method_vftbl_lookup(vftbl, m);
502 STATISTICS(jnicallXmethodnvokation());
504 ro = vm_call_method_valist(resm, o, ap);
510 /* _Jv_jni_CallObjectMethodA ***************************************************
512 Internal function to call Java Object methods.
514 *******************************************************************************/
516 static java_objectheader *_Jv_jni_CallObjectMethodA(java_objectheader *o,
518 methodinfo *m, jvalue *args)
521 java_objectheader *ro;
523 STATISTICS(jniinvokation());
526 exceptions_throw_nullpointerexception();
530 /* Class initialization is done by the JIT compiler. This is ok
531 since a static method always belongs to the declaring class. */
533 if (m->flags & ACC_STATIC) {
534 /* For static methods we reset the object. */
539 /* for convenience */
544 /* For instance methods we make a virtual function table lookup. */
546 resm = method_vftbl_lookup(vftbl, m);
549 STATISTICS(jnicallXmethodnvokation());
551 ro = vm_call_method_jvalue(resm, o, args);
557 /* _Jv_jni_CallIntMethod *******************************************************
559 Internal function to call Java integer class methods (boolean,
560 byte, char, short, int).
562 *******************************************************************************/
564 static jint _Jv_jni_CallIntMethod(java_objectheader *o, vftbl_t *vftbl,
565 methodinfo *m, va_list ap)
570 STATISTICS(jniinvokation());
573 exceptions_throw_nullpointerexception();
577 /* Class initialization is done by the JIT compiler. This is ok
578 since a static method always belongs to the declaring class. */
580 if (m->flags & ACC_STATIC) {
581 /* For static methods we reset the object. */
586 /* for convenience */
591 /* For instance methods we make a virtual function table lookup. */
593 resm = method_vftbl_lookup(vftbl, m);
596 STATISTICS(jnicallXmethodnvokation());
598 i = vm_call_method_int_valist(resm, o, ap);
604 /* _Jv_jni_CallIntMethodA ******************************************************
606 Internal function to call Java integer class methods (boolean,
607 byte, char, short, int).
609 *******************************************************************************/
611 static jint _Jv_jni_CallIntMethodA(java_objectheader *o, vftbl_t *vftbl,
612 methodinfo *m, jvalue *args)
617 STATISTICS(jniinvokation());
620 exceptions_throw_nullpointerexception();
624 /* Class initialization is done by the JIT compiler. This is ok
625 since a static method always belongs to the declaring class. */
627 if (m->flags & ACC_STATIC) {
628 /* For static methods we reset the object. */
633 /* for convenience */
638 /* For instance methods we make a virtual function table lookup. */
640 resm = method_vftbl_lookup(vftbl, m);
643 STATISTICS(jnicallXmethodnvokation());
645 i = vm_call_method_int_jvalue(resm, o, args);
651 /* _Jv_jni_CallLongMethod ******************************************************
653 Internal function to call Java long methods.
655 *******************************************************************************/
657 static jlong _Jv_jni_CallLongMethod(java_objectheader *o, vftbl_t *vftbl,
658 methodinfo *m, va_list ap)
663 STATISTICS(jniinvokation());
666 exceptions_throw_nullpointerexception();
670 /* Class initialization is done by the JIT compiler. This is ok
671 since a static method always belongs to the declaring class. */
673 if (m->flags & ACC_STATIC) {
674 /* For static methods we reset the object. */
679 /* for convenience */
684 /* For instance methods we make a virtual function table lookup. */
686 resm = method_vftbl_lookup(vftbl, m);
689 STATISTICS(jnicallXmethodnvokation());
691 l = vm_call_method_long_valist(resm, o, ap);
697 /* _Jv_jni_CallFloatMethod *****************************************************
699 Internal function to call Java float methods.
701 *******************************************************************************/
703 static jfloat _Jv_jni_CallFloatMethod(java_objectheader *o, vftbl_t *vftbl,
704 methodinfo *m, va_list ap)
709 /* Class initialization is done by the JIT compiler. This is ok
710 since a static method always belongs to the declaring class. */
712 if (m->flags & ACC_STATIC) {
713 /* For static methods we reset the object. */
718 /* for convenience */
723 /* For instance methods we make a virtual function table lookup. */
725 resm = method_vftbl_lookup(vftbl, m);
728 STATISTICS(jnicallXmethodnvokation());
730 f = vm_call_method_float_valist(resm, o, ap);
736 /* _Jv_jni_CallDoubleMethod ****************************************************
738 Internal function to call Java double methods.
740 *******************************************************************************/
742 static jdouble _Jv_jni_CallDoubleMethod(java_objectheader *o, vftbl_t *vftbl,
743 methodinfo *m, va_list ap)
748 /* Class initialization is done by the JIT compiler. This is ok
749 since a static method always belongs to the declaring class. */
751 if (m->flags & ACC_STATIC) {
752 /* For static methods we reset the object. */
757 /* for convenience */
762 /* For instance methods we make a virtual function table lookup. */
764 resm = method_vftbl_lookup(vftbl, m);
767 d = vm_call_method_double_valist(resm, o, ap);
773 /* _Jv_jni_CallVoidMethod ******************************************************
775 Internal function to call Java void methods.
777 *******************************************************************************/
779 static void _Jv_jni_CallVoidMethod(java_objectheader *o, vftbl_t *vftbl,
780 methodinfo *m, va_list ap)
785 exceptions_throw_nullpointerexception();
789 /* Class initialization is done by the JIT compiler. This is ok
790 since a static method always belongs to the declaring class. */
792 if (m->flags & ACC_STATIC) {
793 /* For static methods we reset the object. */
798 /* for convenience */
803 /* For instance methods we make a virtual function table lookup. */
805 resm = method_vftbl_lookup(vftbl, m);
808 STATISTICS(jnicallXmethodnvokation());
810 (void) vm_call_method_valist(resm, o, ap);
814 /* _Jv_jni_CallVoidMethodA *****************************************************
816 Internal function to call Java void methods.
818 *******************************************************************************/
820 static void _Jv_jni_CallVoidMethodA(java_objectheader *o, vftbl_t *vftbl,
821 methodinfo *m, jvalue *args)
826 exceptions_throw_nullpointerexception();
830 /* Class initialization is done by the JIT compiler. This is ok
831 since a static method always belongs to the declaring class. */
833 if (m->flags & ACC_STATIC) {
834 /* For static methods we reset the object. */
839 /* for convenience */
844 /* For instance methods we make a virtual function table lookup. */
846 resm = method_vftbl_lookup(vftbl, m);
849 STATISTICS(jnicallXmethodnvokation());
851 (void) vm_call_method_jvalue(resm, o, args);
855 /* _Jv_jni_invokeNative ********************************************************
857 Invoke a method on the given object with the given arguments.
859 For instance methods OBJ must be != NULL and the method is looked up
860 in the vftbl of the object.
862 For static methods, OBJ is ignored.
864 *******************************************************************************/
866 java_objectheader *_Jv_jni_invokeNative(methodinfo *m, java_objectheader *o,
867 java_objectarray *params)
871 java_objectheader *ro;
874 java_objectheader *xptr;
877 exceptions_throw_nullpointerexception();
881 argcount = m->parseddesc->paramcount;
882 paramcount = argcount;
884 /* if method is non-static, remove the `this' pointer */
886 if (!(m->flags & ACC_STATIC))
889 /* For instance methods the object has to be an instance of the
890 class the method belongs to. For static methods the obj
891 parameter is ignored. */
893 if (!(m->flags & ACC_STATIC) && o && (!builtin_instanceof(o, m->class))) {
894 exceptions_throw_illegalargumentexception();
898 /* check if we got the right number of arguments */
900 if (((params == NULL) && (paramcount != 0)) ||
901 (params && (params->header.size != paramcount)))
903 exceptions_throw_illegalargumentexception();
907 /* for instance methods we need an object */
909 if (!(m->flags & ACC_STATIC) && (o == NULL)) {
910 /* XXX not sure if that is the correct exception */
911 exceptions_throw_nullpointerexception();
915 /* for static methods, zero object to make subsequent code simpler */
916 if (m->flags & ACC_STATIC)
920 /* for instance methods we must do a vftbl lookup */
921 resm = method_vftbl_lookup(o->vftbl, m);
924 /* for static methods, just for convenience */
928 vmargs = MNEW(vm_arg, argcount);
930 if (!_Jv_jni_vmargs_from_objectarray(o, resm->parseddesc, vmargs, params))
933 switch (resm->parseddesc->returntype.decltype) {
935 (void) vm_call_method_vmarg(resm, argcount, vmargs);
940 case PRIMITIVETYPE_BOOLEAN: {
942 java_lang_Boolean *bo;
944 i = vm_call_method_int_vmarg(resm, argcount, vmargs);
946 ro = builtin_new(class_java_lang_Boolean);
948 /* setting the value of the object direct */
950 bo = (java_lang_Boolean *) ro;
955 case PRIMITIVETYPE_BYTE: {
959 i = vm_call_method_int_vmarg(resm, argcount, vmargs);
961 ro = builtin_new(class_java_lang_Byte);
963 /* setting the value of the object direct */
965 bo = (java_lang_Byte *) ro;
970 case PRIMITIVETYPE_CHAR: {
972 java_lang_Character *co;
974 i = vm_call_method_int_vmarg(resm, argcount, vmargs);
976 ro = builtin_new(class_java_lang_Character);
978 /* setting the value of the object direct */
980 co = (java_lang_Character *) ro;
985 case PRIMITIVETYPE_SHORT: {
989 i = vm_call_method_int_vmarg(resm, argcount, vmargs);
991 ro = builtin_new(class_java_lang_Short);
993 /* setting the value of the object direct */
995 so = (java_lang_Short *) ro;
1000 case PRIMITIVETYPE_INT: {
1002 java_lang_Integer *io;
1004 i = vm_call_method_int_vmarg(resm, argcount, vmargs);
1006 ro = builtin_new(class_java_lang_Integer);
1008 /* setting the value of the object direct */
1010 io = (java_lang_Integer *) ro;
1015 case PRIMITIVETYPE_LONG: {
1019 l = vm_call_method_long_vmarg(resm, argcount, vmargs);
1021 ro = builtin_new(class_java_lang_Long);
1023 /* setting the value of the object direct */
1025 lo = (java_lang_Long *) ro;
1030 case PRIMITIVETYPE_FLOAT: {
1032 java_lang_Float *fo;
1034 f = vm_call_method_float_vmarg(resm, argcount, vmargs);
1036 ro = builtin_new(class_java_lang_Float);
1038 /* setting the value of the object direct */
1040 fo = (java_lang_Float *) ro;
1045 case PRIMITIVETYPE_DOUBLE: {
1047 java_lang_Double *_do;
1049 d = vm_call_method_double_vmarg(resm, argcount, vmargs);
1051 ro = builtin_new(class_java_lang_Double);
1053 /* setting the value of the object direct */
1055 _do = (java_lang_Double *) ro;
1061 ro = vm_call_method_vmarg(resm, argcount, vmargs);
1065 /* if this happens the exception has already been set by
1066 fill_callblock_from_objectarray */
1068 MFREE(vmargs, vm_arg, argcount);
1073 MFREE(vmargs, vm_arg, argcount);
1075 xptr = exceptions_get_exception();
1078 /* clear exception pointer, we are calling JIT code again */
1080 exceptions_clear_exception();
1082 exceptions_throw_invocationtargetexception(xptr);
1089 /* GetVersion ******************************************************************
1091 Returns the major version number in the higher 16 bits and the
1092 minor version number in the lower 16 bits.
1094 *******************************************************************************/
1096 jint _Jv_JNI_GetVersion(JNIEnv *env)
1098 STATISTICS(jniinvokation());
1100 /* we support JNI 1.4 */
1102 return JNI_VERSION_1_4;
1106 /* Class Operations ***********************************************************/
1108 /* DefineClass *****************************************************************
1110 Loads a class from a buffer of raw class data. The buffer
1111 containing the raw class data is not referenced by the VM after the
1112 DefineClass call returns, and it may be discarded if desired.
1114 *******************************************************************************/
1116 jclass _Jv_JNI_DefineClass(JNIEnv *env, const char *name, jobject loader,
1117 const jbyte *buf, jsize bufLen)
1119 #if defined(ENABLE_JAVASE)
1120 java_lang_ClassLoader *cl;
1121 java_lang_String *s;
1125 STATISTICS(jniinvokation());
1127 cl = (java_lang_ClassLoader *) loader;
1128 s = javastring_new_from_utf_string(name);
1129 ba = (java_bytearray *) buf;
1131 c = (jclass) _Jv_java_lang_ClassLoader_defineClass(cl, s, ba, 0, bufLen,
1134 return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
1136 vm_abort("_Jv_JNI_DefineClass: not implemented in this configuration");
1138 /* keep compiler happy */
1145 /* FindClass *******************************************************************
1147 This function loads a locally-defined class. It searches the
1148 directories and zip files specified by the CLASSPATH environment
1149 variable for the class with the specified name.
1151 *******************************************************************************/
1153 jclass _Jv_JNI_FindClass(JNIEnv *env, const char *name)
1155 #if defined(ENABLE_JAVASE)
1160 STATISTICS(jniinvokation());
1162 u = utf_new_char_classname((char *) name);
1164 /* Check stacktrace for classloader, if one found use it,
1165 otherwise use the system classloader. */
1167 /* Quote from the JNI documentation:
1169 In the Java 2 Platform, FindClass locates the class loader
1170 associated with the current native method. If the native code
1171 belongs to a system class, no class loader will be
1172 involved. Otherwise, the proper class loader will be invoked to
1173 load and link the named class. When FindClass is called through
1174 the Invocation Interface, there is no current native method or
1175 its associated class loader. In that case, the result of
1176 ClassLoader.getBaseClassLoader is used." */
1178 cc = stacktrace_getCurrentClass();
1181 c = load_class_from_sysloader(u);
1183 c = load_class_from_classloader(u, cc->classloader);
1191 return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
1193 vm_abort("_Jv_JNI_FindClass: not implemented in this configuration");
1195 /* keep compiler happy */
1202 /* GetSuperclass ***************************************************************
1204 If clazz represents any class other than the class Object, then
1205 this function returns the object that represents the superclass of
1206 the class specified by clazz.
1208 *******************************************************************************/
1210 jclass _Jv_JNI_GetSuperclass(JNIEnv *env, jclass sub)
1214 STATISTICS(jniinvokation());
1216 c = ((classinfo *) sub)->super.cls;
1221 return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
1225 /* IsAssignableFrom ************************************************************
1227 Determines whether an object of sub can be safely cast to sup.
1229 *******************************************************************************/
1231 jboolean _Jv_JNI_IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
1233 java_lang_Class *csup;
1234 java_lang_Class *csub;
1236 csup = (java_lang_Class *) sup;
1237 csub = (java_lang_Class *) sub;
1239 STATISTICS(jniinvokation());
1241 return _Jv_java_lang_Class_isAssignableFrom(csup, csub);
1245 /* Throw ***********************************************************************
1247 Causes a java.lang.Throwable object to be thrown.
1249 *******************************************************************************/
1251 jint _Jv_JNI_Throw(JNIEnv *env, jthrowable obj)
1253 java_objectheader *o;
1255 STATISTICS(jniinvokation());
1257 o = (java_objectheader *) obj;
1259 exceptions_set_exception(o);
1265 /* ThrowNew ********************************************************************
1267 Constructs an exception object from the specified class with the
1268 message specified by message and causes that exception to be
1271 *******************************************************************************/
1273 jint _Jv_JNI_ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
1276 java_objectheader *o;
1277 java_objectheader *s;
1279 STATISTICS(jniinvokation());
1281 c = (classinfo *) clazz;
1282 s = javastring_new_from_utf_string(msg);
1284 /* instantiate exception object */
1286 o = native_new_and_init_string(c, s);
1291 exceptions_set_exception(o);
1297 /* ExceptionOccurred ***********************************************************
1299 Determines if an exception is being thrown. The exception stays
1300 being thrown until either the native code calls ExceptionClear(),
1301 or the Java code handles the exception.
1303 *******************************************************************************/
1305 jthrowable _Jv_JNI_ExceptionOccurred(JNIEnv *env)
1307 java_objectheader *o;
1309 STATISTICS(jniinvokation());
1311 o = exceptions_get_exception();
1313 return _Jv_JNI_NewLocalRef(env, (jthrowable) o);
1317 /* ExceptionDescribe ***********************************************************
1319 Prints an exception and a backtrace of the stack to a system
1320 error-reporting channel, such as stderr. This is a convenience
1321 routine provided for debugging.
1323 *******************************************************************************/
1325 void _Jv_JNI_ExceptionDescribe(JNIEnv *env)
1327 java_objectheader *o;
1330 STATISTICS(jniinvokation());
1332 o = exceptions_get_exception();
1335 /* clear exception, because we are calling jit code again */
1337 exceptions_clear_exception();
1339 /* get printStackTrace method from exception class */
1341 m = class_resolveclassmethod(o->vftbl->class,
1342 utf_printStackTrace,
1348 /* XXX what should we do? */
1351 /* print the stacktrace */
1353 (void) vm_call_method(m, o);
1358 /* ExceptionClear **************************************************************
1360 Clears any exception that is currently being thrown. If no
1361 exception is currently being thrown, this routine has no effect.
1363 *******************************************************************************/
1365 void _Jv_JNI_ExceptionClear(JNIEnv *env)
1367 STATISTICS(jniinvokation());
1369 exceptions_clear_exception();
1373 /* FatalError ******************************************************************
1375 Raises a fatal error and does not expect the VM to recover. This
1376 function does not return.
1378 *******************************************************************************/
1380 void _Jv_JNI_FatalError(JNIEnv *env, const char *msg)
1382 STATISTICS(jniinvokation());
1384 /* this seems to be the best way */
1390 /* PushLocalFrame **************************************************************
1392 Creates a new local reference frame, in which at least a given
1393 number of local references can be created.
1395 *******************************************************************************/
1397 jint _Jv_JNI_PushLocalFrame(JNIEnv* env, jint capacity)
1400 localref_table *lrt;
1401 localref_table *nlrt;
1403 STATISTICS(jniinvokation());
1408 /* Allocate new local reference table on Java heap. Calculate the
1409 additional memory we have to allocate. */
1411 if (capacity > LOCALREFTABLE_CAPACITY)
1412 additionalrefs = capacity - LOCALREFTABLE_CAPACITY;
1416 #if defined(ENABLE_GC_CACAO)
1417 nlrt = MNEW(u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P);
1419 nlrt = GCMNEW(u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P);
1425 /* get current local reference table from thread */
1427 lrt = LOCALREFTABLE;
1429 /* Set up the new local reference table and add it to the local
1432 nlrt->capacity = capacity;
1434 nlrt->localframes = lrt->localframes + 1;
1437 /* store new local reference table in thread */
1439 LOCALREFTABLE = nlrt;
1445 /* PopLocalFrame ***************************************************************
1447 Pops off the current local reference frame, frees all the local
1448 references, and returns a local reference in the previous local
1449 reference frame for the given result object.
1451 *******************************************************************************/
1453 jobject _Jv_JNI_PopLocalFrame(JNIEnv* env, jobject result)
1455 localref_table *lrt;
1456 localref_table *plrt;
1460 STATISTICS(jniinvokation());
1462 /* get current local reference table from thread */
1464 lrt = LOCALREFTABLE;
1466 localframes = lrt->localframes;
1468 /* Don't delete the top local frame, as this one is allocated in
1469 the native stub on the stack and is freed automagically on
1472 if (localframes == 1)
1473 return _Jv_JNI_NewLocalRef(env, result);
1475 /* release all current local frames */
1477 for (; localframes >= 1; localframes--) {
1478 /* get previous frame */
1482 /* clear all reference entries */
1484 MSET(&lrt->refs[0], 0, java_objectheader*, lrt->capacity);
1488 #if defined(ENABLE_GC_CACAO)
1489 /* for the exact GC local reference tables are not on the heap,
1490 so we need to free them explicitly here. */
1492 if (lrt->capacity > LOCALREFTABLE_CAPACITY)
1493 additionalrefs = lrt->capacity - LOCALREFTABLE_CAPACITY;
1497 MFREE(lrt, u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P);
1500 /* set new local references table */
1505 /* store new local reference table in thread */
1507 LOCALREFTABLE = lrt;
1509 /* add local reference and return the value */
1511 return _Jv_JNI_NewLocalRef(env, result);
1515 /* DeleteLocalRef **************************************************************
1517 Deletes the local reference pointed to by localRef.
1519 *******************************************************************************/
1521 void _Jv_JNI_DeleteLocalRef(JNIEnv *env, jobject localRef)
1523 java_objectheader *o;
1524 localref_table *lrt;
1527 STATISTICS(jniinvokation());
1529 o = (java_objectheader *) localRef;
1531 /* get local reference table (thread specific) */
1533 lrt = LOCALREFTABLE;
1535 /* go through all local frames */
1537 for (; lrt != NULL; lrt = lrt->prev) {
1539 /* and try to remove the reference */
1541 for (i = 0; i < lrt->capacity; i++) {
1542 if (lrt->refs[i] == o) {
1543 lrt->refs[i] = NULL;
1551 /* this should not happen */
1553 /* if (opt_checkjni) */
1554 /* FatalError(env, "Bad global or local ref passed to JNI"); */
1555 log_text("JNI-DeleteLocalRef: Local ref passed to JNI not found");
1559 /* IsSameObject ****************************************************************
1561 Tests whether two references refer to the same Java object.
1563 *******************************************************************************/
1565 jboolean _Jv_JNI_IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
1567 STATISTICS(jniinvokation());
1576 /* NewLocalRef *****************************************************************
1578 Creates a new local reference that refers to the same object as ref.
1580 *******************************************************************************/
1582 jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref)
1584 localref_table *lrt;
1587 STATISTICS(jniinvokation());
1592 /* get local reference table (thread specific) */
1594 lrt = LOCALREFTABLE;
1596 /* Check if we have space for the requested reference? No,
1597 allocate a new frame. This is actually not what the spec says,
1598 but for compatibility reasons... */
1600 if (lrt->used == lrt->capacity) {
1601 if (_Jv_JNI_EnsureLocalCapacity(env, 16) != 0)
1604 /* get the new local reference table */
1606 lrt = LOCALREFTABLE;
1609 /* insert the reference */
1611 for (i = 0; i < lrt->capacity; i++) {
1612 if (lrt->refs[i] == NULL) {
1613 lrt->refs[i] = (java_objectheader *) ref;
1620 /* should not happen, just to be sure */
1624 /* keep compiler happy */
1630 /* EnsureLocalCapacity *********************************************************
1632 Ensures that at least a given number of local references can be
1633 created in the current thread
1635 *******************************************************************************/
1637 jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity)
1639 localref_table *lrt;
1641 STATISTICS(jniinvokation());
1643 /* get local reference table (thread specific) */
1645 lrt = LOCALREFTABLE;
1647 /* check if capacity elements are available in the local references table */
1649 if ((lrt->used + capacity) > lrt->capacity)
1650 return _Jv_JNI_PushLocalFrame(env, capacity);
1656 /* AllocObject *****************************************************************
1658 Allocates a new Java object without invoking any of the
1659 constructors for the object. Returns a reference to the object.
1661 *******************************************************************************/
1663 jobject _Jv_JNI_AllocObject(JNIEnv *env, jclass clazz)
1666 java_objectheader *o;
1668 STATISTICS(jniinvokation());
1670 c = (classinfo *) clazz;
1672 if ((c->flags & ACC_INTERFACE) || (c->flags & ACC_ABSTRACT)) {
1673 exceptions_throw_instantiationexception(c);
1679 return _Jv_JNI_NewLocalRef(env, o);
1683 /* NewObject *******************************************************************
1685 Programmers place all arguments that are to be passed to the
1686 constructor immediately following the methodID
1687 argument. NewObject() accepts these arguments and passes them to
1688 the Java method that the programmer wishes to invoke.
1690 *******************************************************************************/
1692 jobject _Jv_JNI_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1694 java_objectheader *o;
1698 STATISTICS(jniinvokation());
1700 m = (methodinfo *) methodID;
1704 o = builtin_new(clazz);
1709 /* call constructor */
1711 va_start(ap, methodID);
1712 _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap);
1715 return _Jv_JNI_NewLocalRef(env, o);
1719 /* NewObjectV ******************************************************************
1721 Programmers place all arguments that are to be passed to the
1722 constructor in an args argument of type va_list that immediately
1723 follows the methodID argument. NewObjectV() accepts these
1724 arguments, and, in turn, passes them to the Java method that the
1725 programmer wishes to invoke.
1727 *******************************************************************************/
1729 jobject _Jv_JNI_NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID,
1732 java_objectheader *o;
1735 STATISTICS(jniinvokation());
1737 m = (methodinfo *) methodID;
1741 o = builtin_new(clazz);
1746 /* call constructor */
1748 _Jv_jni_CallVoidMethod(o, o->vftbl, m, args);
1750 return _Jv_JNI_NewLocalRef(env, o);
1754 /* NewObjectA *****************************************************************
1756 Programmers place all arguments that are to be passed to the
1757 constructor in an args array of jvalues that immediately follows
1758 the methodID argument. NewObjectA() accepts the arguments in this
1759 array, and, in turn, passes them to the Java method that the
1760 programmer wishes to invoke.
1762 *******************************************************************************/
1764 jobject _Jv_JNI_NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID,
1767 java_objectheader *o;
1770 STATISTICS(jniinvokation());
1772 m = (methodinfo *) methodID;
1776 o = builtin_new(clazz);
1781 /* call constructor */
1783 _Jv_jni_CallVoidMethodA(o, o->vftbl, m, args);
1785 return _Jv_JNI_NewLocalRef(env, o);
1789 /* GetObjectClass **************************************************************
1791 Returns the class of an object.
1793 *******************************************************************************/
1795 jclass _Jv_JNI_GetObjectClass(JNIEnv *env, jobject obj)
1797 java_objectheader *o;
1800 STATISTICS(jniinvokation());
1802 o = (java_objectheader *) obj;
1804 if ((o == NULL) || (o->vftbl == NULL))
1807 c = o->vftbl->class;
1809 return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
1813 /* IsInstanceOf ****************************************************************
1815 Tests whether an object is an instance of a class.
1817 *******************************************************************************/
1819 jboolean _Jv_JNI_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
1822 java_lang_Object *o;
1824 STATISTICS(jniinvokation());
1826 c = (java_lang_Class *) clazz;
1827 o = (java_lang_Object *) obj;
1829 return _Jv_java_lang_Class_isInstance(c, o);
1833 /* Reflection Support *********************************************************/
1835 /* FromReflectedMethod *********************************************************
1837 Converts java.lang.reflect.Method or java.lang.reflect.Constructor
1838 object to a method ID.
1840 *******************************************************************************/
1842 jmethodID _Jv_JNI_FromReflectedMethod(JNIEnv *env, jobject method)
1844 #if defined(ENABLE_JAVASE)
1849 STATISTICS(jniinvokation());
1854 if (builtin_instanceof(method, class_java_lang_reflect_Method)) {
1855 java_lang_reflect_Method *rm;
1857 rm = (java_lang_reflect_Method *) method;
1858 c = (classinfo *) (rm->declaringClass);
1861 else if (builtin_instanceof(method, class_java_lang_reflect_Constructor)) {
1862 java_lang_reflect_Constructor *rc;
1864 rc = (java_lang_reflect_Constructor *) method;
1865 c = (classinfo *) (rc->clazz);
1871 mi = &(c->methods[slot]);
1873 return (jmethodID) mi;
1875 vm_abort("_Jv_JNI_FromReflectedMethod: not implemented in this configuration");
1877 /* keep compiler happy */
1884 /* FromReflectedField **********************************************************
1886 Converts a java.lang.reflect.Field to a field ID.
1888 *******************************************************************************/
1890 jfieldID _Jv_JNI_FromReflectedField(JNIEnv* env, jobject field)
1892 #if defined(ENABLE_JAVASE)
1893 java_lang_reflect_Field *rf;
1897 STATISTICS(jniinvokation());
1899 rf = (java_lang_reflect_Field *) field;
1904 c = (classinfo *) rf->declaringClass;
1906 f = &(c->fields[rf->slot]);
1908 return (jfieldID) f;
1910 vm_abort("_Jv_JNI_FromReflectedField: not implemented in this configuration");
1912 /* keep compiler happy */
1919 /* ToReflectedMethod ***********************************************************
1921 Converts a method ID derived from cls to an instance of the
1922 java.lang.reflect.Method class or to an instance of the
1923 java.lang.reflect.Constructor class.
1925 *******************************************************************************/
1927 jobject _Jv_JNI_ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID,
1930 STATISTICS(jniinvokation());
1932 log_text("JNI-Call: ToReflectedMethod: IMPLEMENT ME!");
1938 /* ToReflectedField ************************************************************
1940 Converts a field ID derived from cls to an instance of the
1941 java.lang.reflect.Field class.
1943 *******************************************************************************/
1945 jobject _Jv_JNI_ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
1948 STATISTICS(jniinvokation());
1950 log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!");
1956 /* Calling Instance Methods ***************************************************/
1958 /* GetMethodID *****************************************************************
1960 Returns the method ID for an instance (nonstatic) method of a class
1961 or interface. The method may be defined in one of the clazz's
1962 superclasses and inherited by clazz. The method is determined by
1963 its name and signature.
1965 GetMethodID() causes an uninitialized class to be initialized.
1967 *******************************************************************************/
1969 jmethodID _Jv_JNI_GetMethodID(JNIEnv* env, jclass clazz, const char *name,
1977 STATISTICS(jniinvokation());
1979 c = (classinfo *) clazz;
1984 if (!(c->state & CLASS_INITIALIZED))
1985 if (!initialize_class(c))
1988 /* try to get the method of the class or one of it's superclasses */
1990 uname = utf_new_char((char *) name);
1991 udesc = utf_new_char((char *) sig);
1993 m = class_resolvemethod(clazz, uname, udesc);
1995 if ((m == NULL) || (m->flags & ACC_STATIC)) {
1996 exceptions_throw_nosuchmethoderror(c, uname, udesc);
2001 return (jmethodID) m;
2005 /* JNI-functions for calling instance methods *********************************/
2007 jobject _Jv_JNI_CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID,
2010 java_objectheader *o;
2012 java_objectheader *ret;
2015 o = (java_objectheader *) obj;
2016 m = (methodinfo *) methodID;
2018 va_start(ap, methodID);
2019 ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, ap);
2022 return _Jv_JNI_NewLocalRef(env, ret);
2026 jobject _Jv_JNI_CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2029 java_objectheader *o;
2031 java_objectheader *ret;
2033 o = (java_objectheader *) obj;
2034 m = (methodinfo *) methodID;
2036 ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, args);
2038 return _Jv_JNI_NewLocalRef(env, ret);
2042 jobject _Jv_JNI_CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2045 java_objectheader *o;
2047 java_objectheader *ret;
2049 o = (java_objectheader *) obj;
2050 m = (methodinfo *) methodID;
2052 ret = _Jv_jni_CallObjectMethodA(o, o->vftbl, m, args);
2054 return _Jv_JNI_NewLocalRef(env, ret);
2058 jboolean _Jv_JNI_CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID,
2061 java_objectheader *o;
2066 o = (java_objectheader *) obj;
2067 m = (methodinfo *) methodID;
2069 va_start(ap, methodID);
2070 b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
2077 jboolean _Jv_JNI_CallBooleanMethodV(JNIEnv *env, jobject obj,
2078 jmethodID methodID, va_list args)
2080 java_objectheader *o;
2084 o = (java_objectheader *) obj;
2085 m = (methodinfo *) methodID;
2087 b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
2093 jboolean _Jv_JNI_CallBooleanMethodA(JNIEnv *env, jobject obj,
2094 jmethodID methodID, jvalue *args)
2096 java_objectheader *o;
2100 o = (java_objectheader *) obj;
2101 m = (methodinfo *) methodID;
2103 b = _Jv_jni_CallIntMethodA(o, o->vftbl, m, args);
2109 jbyte _Jv_JNI_CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
2111 java_objectheader *o;
2116 o = (java_objectheader *) obj;
2117 m = (methodinfo *) methodID;
2119 va_start(ap, methodID);
2120 b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
2128 jbyte _Jv_JNI_CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2131 java_objectheader *o;
2135 o = (java_objectheader *) obj;
2136 m = (methodinfo *) methodID;
2138 b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
2144 jbyte _Jv_JNI_CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2147 log_text("JNI-Call: CallByteMethodA: IMPLEMENT ME!");
2153 jchar _Jv_JNI_CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
2155 java_objectheader *o;
2160 o = (java_objectheader *) obj;
2161 m = (methodinfo *) methodID;
2163 va_start(ap, methodID);
2164 c = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
2171 jchar _Jv_JNI_CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2174 java_objectheader *o;
2178 o = (java_objectheader *) obj;
2179 m = (methodinfo *) methodID;
2181 c = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
2187 jchar _Jv_JNI_CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2190 log_text("JNI-Call: CallCharMethodA: IMPLEMENT ME!");
2196 jshort _Jv_JNI_CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID,
2199 java_objectheader *o;
2204 o = (java_objectheader *) obj;
2205 m = (methodinfo *) methodID;
2207 va_start(ap, methodID);
2208 s = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
2215 jshort _Jv_JNI_CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2218 java_objectheader *o;
2222 o = (java_objectheader *) obj;
2223 m = (methodinfo *) methodID;
2225 s = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
2231 jshort _Jv_JNI_CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2234 log_text("JNI-Call: CallShortMethodA: IMPLEMENT ME!");
2241 jint _Jv_JNI_CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
2243 java_objectheader *o;
2248 o = (java_objectheader *) obj;
2249 m = (methodinfo *) methodID;
2251 va_start(ap, methodID);
2252 i = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
2259 jint _Jv_JNI_CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2262 java_objectheader *o;
2266 o = (java_objectheader *) obj;
2267 m = (methodinfo *) methodID;
2269 i = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
2275 jint _Jv_JNI_CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2278 log_text("JNI-Call: CallIntMethodA: IMPLEMENT ME!");
2285 jlong _Jv_JNI_CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
2287 java_objectheader *o;
2292 o = (java_objectheader *) obj;
2293 m = (methodinfo *) methodID;
2295 va_start(ap, methodID);
2296 l = _Jv_jni_CallLongMethod(o, o->vftbl, m, ap);
2303 jlong _Jv_JNI_CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2306 java_objectheader *o;
2310 o = (java_objectheader *) obj;
2311 m = (methodinfo *) methodID;
2313 l = _Jv_jni_CallLongMethod(o, o->vftbl, m, args);
2319 jlong _Jv_JNI_CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2322 log_text("JNI-Call: CallLongMethodA: IMPLEMENT ME!");
2329 jfloat _Jv_JNI_CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID,
2332 java_objectheader *o;
2337 o = (java_objectheader *) obj;
2338 m = (methodinfo *) methodID;
2340 va_start(ap, methodID);
2341 f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, ap);
2348 jfloat _Jv_JNI_CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2351 java_objectheader *o;
2355 o = (java_objectheader *) obj;
2356 m = (methodinfo *) methodID;
2358 f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, args);
2364 jfloat _Jv_JNI_CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2367 log_text("JNI-Call: CallFloatMethodA: IMPLEMENT ME!");
2374 jdouble _Jv_JNI_CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID,
2377 java_objectheader *o;
2382 o = (java_objectheader *) obj;
2383 m = (methodinfo *) methodID;
2385 va_start(ap, methodID);
2386 d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, ap);
2393 jdouble _Jv_JNI_CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2396 java_objectheader *o;
2400 o = (java_objectheader *) obj;
2401 m = (methodinfo *) methodID;
2403 d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, args);
2409 jdouble _Jv_JNI_CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2412 log_text("JNI-Call: CallDoubleMethodA: IMPLEMENT ME!");
2419 void _Jv_JNI_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
2421 java_objectheader *o;
2425 o = (java_objectheader *) obj;
2426 m = (methodinfo *) methodID;
2428 va_start(ap, methodID);
2429 _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap);
2434 void _Jv_JNI_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
2437 java_objectheader *o;
2440 o = (java_objectheader *) obj;
2441 m = (methodinfo *) methodID;
2443 _Jv_jni_CallVoidMethod(o, o->vftbl, m, args);
2447 void _Jv_JNI_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
2450 java_objectheader *o;
2453 o = (java_objectheader *) obj;
2454 m = (methodinfo *) methodID;
2456 _Jv_jni_CallVoidMethodA(o, o->vftbl, m, args);
2461 jobject _Jv_JNI_CallNonvirtualObjectMethod(JNIEnv *env, jobject obj,
2462 jclass clazz, jmethodID methodID,
2465 java_objectheader *o;
2468 java_objectheader *r;
2471 o = (java_objectheader *) obj;
2472 c = (classinfo *) clazz;
2473 m = (methodinfo *) methodID;
2475 va_start(ap, methodID);
2476 r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, ap);
2479 return _Jv_JNI_NewLocalRef(env, r);
2483 jobject _Jv_JNI_CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj,
2484 jclass clazz, jmethodID methodID,
2487 java_objectheader *o;
2490 java_objectheader *r;
2492 o = (java_objectheader *) obj;
2493 c = (classinfo *) clazz;
2494 m = (methodinfo *) methodID;
2496 r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, args);
2498 return _Jv_JNI_NewLocalRef(env, r);
2502 jobject _Jv_JNI_CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj,
2503 jclass clazz, jmethodID methodID,
2506 log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!");
2508 return _Jv_JNI_NewLocalRef(env, NULL);
2513 jboolean _Jv_JNI_CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj,
2514 jclass clazz, jmethodID methodID,
2517 java_objectheader *o;
2523 o = (java_objectheader *) obj;
2524 c = (classinfo *) clazz;
2525 m = (methodinfo *) methodID;
2527 va_start(ap, methodID);
2528 b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
2535 jboolean _Jv_JNI_CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj,
2536 jclass clazz, jmethodID methodID,
2539 java_objectheader *o;
2544 o = (java_objectheader *) obj;
2545 c = (classinfo *) clazz;
2546 m = (methodinfo *) methodID;
2548 b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
2554 jboolean _Jv_JNI_CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj,
2555 jclass clazz, jmethodID methodID,
2558 log_text("JNI-Call: CallNonvirtualBooleanMethodA: IMPLEMENT ME!");
2564 jbyte _Jv_JNI_CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz,
2565 jmethodID methodID, ...)
2567 java_objectheader *o;
2573 o = (java_objectheader *) obj;
2574 c = (classinfo *) clazz;
2575 m = (methodinfo *) methodID;
2577 va_start(ap, methodID);
2578 b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
2585 jbyte _Jv_JNI_CallNonvirtualByteMethodV(JNIEnv *env, jobject obj, jclass clazz,
2586 jmethodID methodID, va_list args)
2588 java_objectheader *o;
2593 o = (java_objectheader *) obj;
2594 c = (classinfo *) clazz;
2595 m = (methodinfo *) methodID;
2597 b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
2603 jbyte _Jv_JNI_CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz,
2604 jmethodID methodID, jvalue *args)
2606 log_text("JNI-Call: CallNonvirtualByteMethodA: IMPLEMENT ME!");
2613 jchar _Jv_JNI_CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz,
2614 jmethodID methodID, ...)
2616 java_objectheader *o;
2622 o = (java_objectheader *) obj;
2623 c = (classinfo *) clazz;
2624 m = (methodinfo *) methodID;
2626 va_start(ap, methodID);
2627 ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
2634 jchar _Jv_JNI_CallNonvirtualCharMethodV(JNIEnv *env, jobject obj, jclass clazz,
2635 jmethodID methodID, va_list args)
2637 java_objectheader *o;
2642 o = (java_objectheader *) obj;
2643 c = (classinfo *) clazz;
2644 m = (methodinfo *) methodID;
2646 ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
2652 jchar _Jv_JNI_CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz,
2653 jmethodID methodID, jvalue *args)
2655 log_text("JNI-Call: CallNonvirtualCharMethodA: IMPLEMENT ME!");
2662 jshort _Jv_JNI_CallNonvirtualShortMethod(JNIEnv *env, jobject obj,
2663 jclass clazz, jmethodID methodID, ...)
2665 java_objectheader *o;
2671 o = (java_objectheader *) obj;
2672 c = (classinfo *) clazz;
2673 m = (methodinfo *) methodID;
2675 va_start(ap, methodID);
2676 s = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
2683 jshort _Jv_JNI_CallNonvirtualShortMethodV(JNIEnv *env, jobject obj,
2684 jclass clazz, jmethodID methodID,
2687 java_objectheader *o;
2692 o = (java_objectheader *) obj;
2693 c = (classinfo *) clazz;
2694 m = (methodinfo *) methodID;
2696 s = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
2702 jshort _Jv_JNI_CallNonvirtualShortMethodA(JNIEnv *env, jobject obj,
2703 jclass clazz, jmethodID methodID,
2706 log_text("JNI-Call: CallNonvirtualShortMethodA: IMPLEMENT ME!");
2713 jint _Jv_JNI_CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz,
2714 jmethodID methodID, ...)
2716 java_objectheader *o;
2722 o = (java_objectheader *) obj;
2723 c = (classinfo *) clazz;
2724 m = (methodinfo *) methodID;
2726 va_start(ap, methodID);
2727 i = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
2734 jint _Jv_JNI_CallNonvirtualIntMethodV(JNIEnv *env, jobject obj, jclass clazz,
2735 jmethodID methodID, va_list args)
2737 java_objectheader *o;
2742 o = (java_objectheader *) obj;
2743 c = (classinfo *) clazz;
2744 m = (methodinfo *) methodID;
2746 i = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
2752 jint _Jv_JNI_CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz,
2753 jmethodID methodID, jvalue *args)
2755 log_text("JNI-Call: CallNonvirtualIntMethodA: IMPLEMENT ME!");
2762 jlong _Jv_JNI_CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz,
2763 jmethodID methodID, ...)
2765 java_objectheader *o;
2771 o = (java_objectheader *) obj;
2772 c = (classinfo *) clazz;
2773 m = (methodinfo *) methodID;
2775 va_start(ap, methodID);
2776 l = _Jv_jni_CallLongMethod(o, c->vftbl, m, ap);
2783 jlong _Jv_JNI_CallNonvirtualLongMethodV(JNIEnv *env, jobject obj, jclass clazz,
2784 jmethodID methodID, va_list args)
2786 java_objectheader *o;
2791 o = (java_objectheader *) obj;
2792 c = (classinfo *) clazz;
2793 m = (methodinfo *) methodID;
2795 l = _Jv_jni_CallLongMethod(o, c->vftbl, m, args);
2801 jlong _Jv_JNI_CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz,
2802 jmethodID methodID, jvalue *args)
2804 log_text("JNI-Call: CallNonvirtualLongMethodA: IMPLEMENT ME!");
2811 jfloat _Jv_JNI_CallNonvirtualFloatMethod(JNIEnv *env, jobject obj,
2812 jclass clazz, jmethodID methodID, ...)
2814 java_objectheader *o;
2820 o = (java_objectheader *) obj;
2821 c = (classinfo *) clazz;
2822 m = (methodinfo *) methodID;
2824 va_start(ap, methodID);
2825 f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, ap);
2832 jfloat _Jv_JNI_CallNonvirtualFloatMethodV(JNIEnv *env, jobject obj,
2833 jclass clazz, jmethodID methodID,
2836 java_objectheader *o;
2841 o = (java_objectheader *) obj;
2842 c = (classinfo *) clazz;
2843 m = (methodinfo *) methodID;
2845 f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, args);
2851 jfloat _Jv_JNI_CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj,
2852 jclass clazz, jmethodID methodID,
2855 log_text("JNI-Call: CallNonvirtualFloatMethodA: IMPLEMENT ME!");
2862 jdouble _Jv_JNI_CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj,
2863 jclass clazz, jmethodID methodID,
2866 java_objectheader *o;
2872 o = (java_objectheader *) obj;
2873 c = (classinfo *) clazz;
2874 m = (methodinfo *) methodID;
2876 va_start(ap, methodID);
2877 d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, ap);
2884 jdouble _Jv_JNI_CallNonvirtualDoubleMethodV(JNIEnv *env, jobject obj,
2885 jclass clazz, jmethodID methodID,
2888 java_objectheader *o;
2893 o = (java_objectheader *) obj;
2894 c = (classinfo *) clazz;
2895 m = (methodinfo *) methodID;
2897 d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, args);
2903 jdouble _Jv_JNI_CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj,
2904 jclass clazz, jmethodID methodID,
2907 log_text("JNI-Call: CallNonvirtualDoubleMethodA: IMPLEMENT ME!");
2914 void _Jv_JNI_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz,
2915 jmethodID methodID, ...)
2917 java_objectheader *o;
2922 o = (java_objectheader *) obj;
2923 c = (classinfo *) clazz;
2924 m = (methodinfo *) methodID;
2926 va_start(ap, methodID);
2927 _Jv_jni_CallVoidMethod(o, c->vftbl, m, ap);
2932 void _Jv_JNI_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz,
2933 jmethodID methodID, va_list args)
2935 java_objectheader *o;
2939 o = (java_objectheader *) obj;
2940 c = (classinfo *) clazz;
2941 m = (methodinfo *) methodID;
2943 _Jv_jni_CallVoidMethod(o, c->vftbl, m, args);
2947 void _Jv_JNI_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz,
2948 jmethodID methodID, jvalue * args)
2950 java_objectheader *o;
2954 o = (java_objectheader *) obj;
2955 c = (classinfo *) clazz;
2956 m = (methodinfo *) methodID;
2958 _Jv_jni_CallVoidMethodA(o, c->vftbl, m, args);
2962 /* Accessing Fields of Objects ************************************************/
2964 /* GetFieldID ******************************************************************
2966 Returns the field ID for an instance (nonstatic) field of a
2967 class. The field is specified by its name and signature. The
2968 Get<type>Field and Set<type>Field families of accessor functions
2969 use field IDs to retrieve object fields.
2971 *******************************************************************************/
2973 jfieldID _Jv_JNI_GetFieldID(JNIEnv *env, jclass clazz, const char *name,
2981 STATISTICS(jniinvokation());
2983 c = (classinfo *) clazz;
2985 uname = utf_new_char((char *) name);
2986 udesc = utf_new_char((char *) sig);
2988 f = class_findfield(clazz, uname, udesc);
2991 exceptions_throw_nosuchfielderror(c, uname);
2993 return (jfieldID) f;
2997 /* Get<type>Field Routines *****************************************************
2999 This family of accessor routines returns the value of an instance
3000 (nonstatic) field of an object. The field to access is specified by
3001 a field ID obtained by calling GetFieldID().
3003 *******************************************************************************/
3005 jobject _Jv_JNI_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
3007 java_objectheader *o;
3009 STATISTICS(jniinvokation());
3011 o = GET_FIELD(obj, java_objectheader*, fieldID);
3013 return _Jv_JNI_NewLocalRef(env, o);
3017 jboolean _Jv_JNI_GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID)
3021 STATISTICS(jniinvokation());
3023 i = GET_FIELD(obj, s4, fieldID);
3025 return (jboolean) i;
3029 jbyte _Jv_JNI_GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID)
3033 STATISTICS(jniinvokation());
3035 i = GET_FIELD(obj, s4, fieldID);
3041 jchar _Jv_JNI_GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID)
3045 STATISTICS(jniinvokation());
3047 i = GET_FIELD(obj, s4, fieldID);
3053 jshort _Jv_JNI_GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID)
3057 STATISTICS(jniinvokation());
3059 i = GET_FIELD(obj, s4, fieldID);
3065 jint _Jv_JNI_GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID)
3067 java_objectheader *o;
3071 STATISTICS(jniinvokation());
3073 o = (java_objectheader *) obj;
3074 f = (fieldinfo *) fieldID;
3076 i = GET_FIELD(o, s4, f);
3082 jlong _Jv_JNI_GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID)
3086 STATISTICS(jniinvokation());
3088 l = GET_FIELD(obj, s8, fieldID);
3094 jfloat _Jv_JNI_GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID)
3098 STATISTICS(jniinvokation());
3100 f = GET_FIELD(obj, float, fieldID);
3106 jdouble _Jv_JNI_GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID)
3110 STATISTICS(jniinvokation());
3112 d = GET_FIELD(obj, double, fieldID);
3118 /* Set<type>Field Routines *****************************************************
3120 This family of accessor routines sets the value of an instance
3121 (nonstatic) field of an object. The field to access is specified by
3122 a field ID obtained by calling GetFieldID().
3124 *******************************************************************************/
3126 void _Jv_JNI_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID,
3129 STATISTICS(jniinvokation());
3131 SET_FIELD(obj, java_objectheader*, fieldID, value);
3135 void _Jv_JNI_SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID,
3138 STATISTICS(jniinvokation());
3140 SET_FIELD(obj, s4, fieldID, value);
3144 void _Jv_JNI_SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID,
3147 STATISTICS(jniinvokation());
3149 SET_FIELD(obj, s4, fieldID, value);
3153 void _Jv_JNI_SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID,
3156 STATISTICS(jniinvokation());
3158 SET_FIELD(obj, s4, fieldID, value);
3162 void _Jv_JNI_SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID,
3165 STATISTICS(jniinvokation());
3167 SET_FIELD(obj, s4, fieldID, value);
3171 void _Jv_JNI_SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value)
3173 STATISTICS(jniinvokation());
3175 SET_FIELD(obj, s4, fieldID, value);
3179 void _Jv_JNI_SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID,
3182 STATISTICS(jniinvokation());
3184 SET_FIELD(obj, s8, fieldID, value);
3188 void _Jv_JNI_SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID,
3191 STATISTICS(jniinvokation());
3193 SET_FIELD(obj, float, fieldID, value);
3197 void _Jv_JNI_SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID,
3200 STATISTICS(jniinvokation());
3202 SET_FIELD(obj, double, fieldID, value);
3206 /* Calling Static Methods *****************************************************/
3208 /* GetStaticMethodID ***********************************************************
3210 Returns the method ID for a static method of a class. The method is
3211 specified by its name and signature.
3213 GetStaticMethodID() causes an uninitialized class to be
3216 *******************************************************************************/
3218 jmethodID _Jv_JNI_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
3226 STATISTICS(jniinvokation());
3228 c = (classinfo *) clazz;
3233 if (!(c->state & CLASS_INITIALIZED))
3234 if (!initialize_class(c))
3237 /* try to get the static method of the class */
3239 uname = utf_new_char((char *) name);
3240 udesc = utf_new_char((char *) sig);
3242 m = class_resolvemethod(c, uname, udesc);
3244 if ((m == NULL) || !(m->flags & ACC_STATIC)) {
3245 exceptions_throw_nosuchmethoderror(c, uname, udesc);
3250 return (jmethodID) m;
3254 jobject _Jv_JNI_CallStaticObjectMethod(JNIEnv *env, jclass clazz,
3255 jmethodID methodID, ...)
3258 java_objectheader *o;
3261 m = (methodinfo *) methodID;
3263 va_start(ap, methodID);
3264 o = _Jv_jni_CallObjectMethod(NULL, NULL, m, ap);
3267 return _Jv_JNI_NewLocalRef(env, o);
3271 jobject _Jv_JNI_CallStaticObjectMethodV(JNIEnv *env, jclass clazz,
3272 jmethodID methodID, va_list args)
3275 java_objectheader *o;
3277 m = (methodinfo *) methodID;
3279 o = _Jv_jni_CallObjectMethod(NULL, NULL, m, args);
3281 return _Jv_JNI_NewLocalRef(env, o);
3285 jobject _Jv_JNI_CallStaticObjectMethodA(JNIEnv *env, jclass clazz,
3286 jmethodID methodID, jvalue *args)
3289 java_objectheader *o;
3291 m = (methodinfo *) methodID;
3293 o = _Jv_jni_CallObjectMethodA(NULL, NULL, m, args);
3295 return _Jv_JNI_NewLocalRef(env, o);
3299 jboolean _Jv_JNI_CallStaticBooleanMethod(JNIEnv *env, jclass clazz,
3300 jmethodID methodID, ...)
3306 m = (methodinfo *) methodID;
3308 va_start(ap, methodID);
3309 b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
3316 jboolean _Jv_JNI_CallStaticBooleanMethodV(JNIEnv *env, jclass clazz,
3317 jmethodID methodID, va_list args)
3322 m = (methodinfo *) methodID;
3324 b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
3330 jboolean _Jv_JNI_CallStaticBooleanMethodA(JNIEnv *env, jclass clazz,
3331 jmethodID methodID, jvalue *args)
3333 log_text("JNI-Call: CallStaticBooleanMethodA: IMPLEMENT ME!");
3339 jbyte _Jv_JNI_CallStaticByteMethod(JNIEnv *env, jclass clazz,
3340 jmethodID methodID, ...)
3346 m = (methodinfo *) methodID;
3348 va_start(ap, methodID);
3349 b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
3356 jbyte _Jv_JNI_CallStaticByteMethodV(JNIEnv *env, jclass clazz,
3357 jmethodID methodID, va_list args)
3362 m = (methodinfo *) methodID;
3364 b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
3370 jbyte _Jv_JNI_CallStaticByteMethodA(JNIEnv *env, jclass clazz,
3371 jmethodID methodID, jvalue *args)
3373 log_text("JNI-Call: CallStaticByteMethodA: IMPLEMENT ME!");
3379 jchar _Jv_JNI_CallStaticCharMethod(JNIEnv *env, jclass clazz,
3380 jmethodID methodID, ...)
3386 m = (methodinfo *) methodID;
3388 va_start(ap, methodID);
3389 c = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
3396 jchar _Jv_JNI_CallStaticCharMethodV(JNIEnv *env, jclass clazz,
3397 jmethodID methodID, va_list args)
3402 m = (methodinfo *) methodID;
3404 c = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
3410 jchar _Jv_JNI_CallStaticCharMethodA(JNIEnv *env, jclass clazz,
3411 jmethodID methodID, jvalue *args)
3413 log_text("JNI-Call: CallStaticCharMethodA: IMPLEMENT ME!");
3419 jshort _Jv_JNI_CallStaticShortMethod(JNIEnv *env, jclass clazz,
3420 jmethodID methodID, ...)
3426 m = (methodinfo *) methodID;
3428 va_start(ap, methodID);
3429 s = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
3436 jshort _Jv_JNI_CallStaticShortMethodV(JNIEnv *env, jclass clazz,
3437 jmethodID methodID, va_list args)
3442 m = (methodinfo *) methodID;
3444 s = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
3450 jshort _Jv_JNI_CallStaticShortMethodA(JNIEnv *env, jclass clazz,
3451 jmethodID methodID, jvalue *args)
3453 log_text("JNI-Call: CallStaticShortMethodA: IMPLEMENT ME!");
3459 jint _Jv_JNI_CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
3466 m = (methodinfo *) methodID;
3468 va_start(ap, methodID);
3469 i = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
3476 jint _Jv_JNI_CallStaticIntMethodV(JNIEnv *env, jclass clazz,
3477 jmethodID methodID, va_list args)
3482 m = (methodinfo *) methodID;
3484 i = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
3490 jint _Jv_JNI_CallStaticIntMethodA(JNIEnv *env, jclass clazz,
3491 jmethodID methodID, jvalue *args)
3493 log_text("JNI-Call: CallStaticIntMethodA: IMPLEMENT ME!");
3499 jlong _Jv_JNI_CallStaticLongMethod(JNIEnv *env, jclass clazz,
3500 jmethodID methodID, ...)
3506 m = (methodinfo *) methodID;
3508 va_start(ap, methodID);
3509 l = _Jv_jni_CallLongMethod(NULL, NULL, m, ap);
3516 jlong _Jv_JNI_CallStaticLongMethodV(JNIEnv *env, jclass clazz,
3517 jmethodID methodID, va_list args)
3522 m = (methodinfo *) methodID;
3524 l = _Jv_jni_CallLongMethod(NULL, NULL, m, args);
3530 jlong _Jv_JNI_CallStaticLongMethodA(JNIEnv *env, jclass clazz,
3531 jmethodID methodID, jvalue *args)
3533 log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!");
3540 jfloat _Jv_JNI_CallStaticFloatMethod(JNIEnv *env, jclass clazz,
3541 jmethodID methodID, ...)
3547 m = (methodinfo *) methodID;
3549 va_start(ap, methodID);
3550 f = _Jv_jni_CallFloatMethod(NULL, NULL, m, ap);
3557 jfloat _Jv_JNI_CallStaticFloatMethodV(JNIEnv *env, jclass clazz,
3558 jmethodID methodID, va_list args)
3563 m = (methodinfo *) methodID;
3565 f = _Jv_jni_CallFloatMethod(NULL, NULL, m, args);
3571 jfloat _Jv_JNI_CallStaticFloatMethodA(JNIEnv *env, jclass clazz,
3572 jmethodID methodID, jvalue *args)
3574 log_text("JNI-Call: CallStaticFloatMethodA: IMPLEMENT ME!");
3580 jdouble _Jv_JNI_CallStaticDoubleMethod(JNIEnv *env, jclass clazz,
3581 jmethodID methodID, ...)
3587 m = (methodinfo *) methodID;
3589 va_start(ap, methodID);
3590 d = _Jv_jni_CallDoubleMethod(NULL, NULL, m, ap);
3597 jdouble _Jv_JNI_CallStaticDoubleMethodV(JNIEnv *env, jclass clazz,
3598 jmethodID methodID, va_list args)
3603 m = (methodinfo *) methodID;
3605 d = _Jv_jni_CallDoubleMethod(NULL, NULL, m, args);
3611 jdouble _Jv_JNI_CallStaticDoubleMethodA(JNIEnv *env, jclass clazz,
3612 jmethodID methodID, jvalue *args)
3614 log_text("JNI-Call: CallStaticDoubleMethodA: IMPLEMENT ME!");
3620 void _Jv_JNI_CallStaticVoidMethod(JNIEnv *env, jclass clazz,
3621 jmethodID methodID, ...)
3626 m = (methodinfo *) methodID;
3628 va_start(ap, methodID);
3629 _Jv_jni_CallVoidMethod(NULL, NULL, m, ap);
3634 void _Jv_JNI_CallStaticVoidMethodV(JNIEnv *env, jclass clazz,
3635 jmethodID methodID, va_list args)
3639 m = (methodinfo *) methodID;
3641 _Jv_jni_CallVoidMethod(NULL, NULL, m, args);
3645 void _Jv_JNI_CallStaticVoidMethodA(JNIEnv *env, jclass clazz,
3646 jmethodID methodID, jvalue * args)
3650 m = (methodinfo *) methodID;
3652 _Jv_jni_CallVoidMethodA(NULL, NULL, m, args);
3656 /* Accessing Static Fields ****************************************************/
3658 /* GetStaticFieldID ************************************************************
3660 Returns the field ID for a static field of a class. The field is
3661 specified by its name and signature. The GetStatic<type>Field and
3662 SetStatic<type>Field families of accessor functions use field IDs
3663 to retrieve static fields.
3665 *******************************************************************************/
3667 jfieldID _Jv_JNI_GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name,
3675 STATISTICS(jniinvokation());
3677 c = (classinfo *) clazz;
3679 uname = utf_new_char((char *) name);
3680 usig = utf_new_char((char *) sig);
3682 f = class_findfield(clazz, uname, usig);
3685 exceptions_throw_nosuchfielderror(c, uname);
3687 return (jfieldID) f;
3691 /* GetStatic<type>Field ********************************************************
3693 This family of accessor routines returns the value of a static
3696 *******************************************************************************/
3698 jobject _Jv_JNI_GetStaticObjectField(JNIEnv *env, jclass clazz,
3704 STATISTICS(jniinvokation());
3706 c = (classinfo *) clazz;
3707 f = (fieldinfo *) fieldID;
3709 if (!(c->state & CLASS_INITIALIZED))
3710 if (!initialize_class(c))
3713 return _Jv_JNI_NewLocalRef(env, f->value.a);
3717 jboolean _Jv_JNI_GetStaticBooleanField(JNIEnv *env, jclass clazz,
3723 STATISTICS(jniinvokation());
3725 c = (classinfo *) clazz;
3726 f = (fieldinfo *) fieldID;
3728 if (!(c->state & CLASS_INITIALIZED))
3729 if (!initialize_class(c))
3736 jbyte _Jv_JNI_GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
3741 STATISTICS(jniinvokation());
3743 c = (classinfo *) clazz;
3744 f = (fieldinfo *) fieldID;
3746 if (!(c->state & CLASS_INITIALIZED))
3747 if (!initialize_class(c))
3754 jchar _Jv_JNI_GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
3759 STATISTICS(jniinvokation());
3761 c = (classinfo *) clazz;
3762 f = (fieldinfo *) fieldID;
3764 if (!(c->state & CLASS_INITIALIZED))
3765 if (!initialize_class(c))
3772 jshort _Jv_JNI_GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
3777 STATISTICS(jniinvokation());
3779 c = (classinfo *) clazz;
3780 f = (fieldinfo *) fieldID;
3782 if (!(c->state & CLASS_INITIALIZED))
3783 if (!initialize_class(c))
3790 jint _Jv_JNI_GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
3795 STATISTICS(jniinvokation());
3797 c = (classinfo *) clazz;
3798 f = (fieldinfo *) fieldID;
3800 if (!(c->state & CLASS_INITIALIZED))
3801 if (!initialize_class(c))
3808 jlong _Jv_JNI_GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
3813 STATISTICS(jniinvokation());
3815 c = (classinfo *) clazz;
3816 f = (fieldinfo *) fieldID;
3818 if (!(c->state & CLASS_INITIALIZED))
3819 if (!initialize_class(c))
3826 jfloat _Jv_JNI_GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
3831 STATISTICS(jniinvokation());
3833 c = (classinfo *) clazz;
3834 f = (fieldinfo *) fieldID;
3836 if (!(c->state & CLASS_INITIALIZED))
3837 if (!initialize_class(c))
3844 jdouble _Jv_JNI_GetStaticDoubleField(JNIEnv *env, jclass clazz,
3850 STATISTICS(jniinvokation());
3852 c = (classinfo *) clazz;
3853 f = (fieldinfo *) fieldID;
3855 if (!(c->state & CLASS_INITIALIZED))
3856 if (!initialize_class(c))
3863 /* SetStatic<type>Field *******************************************************
3865 This family of accessor routines sets the value of a static field
3868 *******************************************************************************/
3870 void _Jv_JNI_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID,
3876 STATISTICS(jniinvokation());
3878 c = (classinfo *) clazz;
3879 f = (fieldinfo *) fieldID;
3881 if (!(c->state & CLASS_INITIALIZED))
3882 if (!initialize_class(c))
3889 void _Jv_JNI_SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID,
3895 STATISTICS(jniinvokation());
3897 c = (classinfo *) clazz;
3898 f = (fieldinfo *) fieldID;
3900 if (!(c->state & CLASS_INITIALIZED))
3901 if (!initialize_class(c))
3908 void _Jv_JNI_SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID,
3914 STATISTICS(jniinvokation());
3916 c = (classinfo *) clazz;
3917 f = (fieldinfo *) fieldID;
3919 if (!(c->state & CLASS_INITIALIZED))
3920 if (!initialize_class(c))
3927 void _Jv_JNI_SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID,
3933 STATISTICS(jniinvokation());
3935 c = (classinfo *) clazz;
3936 f = (fieldinfo *) fieldID;
3938 if (!(c->state & CLASS_INITIALIZED))
3939 if (!initialize_class(c))
3946 void _Jv_JNI_SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID,
3952 STATISTICS(jniinvokation());
3954 c = (classinfo *) clazz;
3955 f = (fieldinfo *) fieldID;
3957 if (!(c->state & CLASS_INITIALIZED))
3958 if (!initialize_class(c))
3965 void _Jv_JNI_SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID,
3971 STATISTICS(jniinvokation());
3973 c = (classinfo *) clazz;
3974 f = (fieldinfo *) fieldID;
3976 if (!(c->state & CLASS_INITIALIZED))
3977 if (!initialize_class(c))
3984 void _Jv_JNI_SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID,
3990 STATISTICS(jniinvokation());
3992 c = (classinfo *) clazz;
3993 f = (fieldinfo *) fieldID;
3995 if (!(c->state & CLASS_INITIALIZED))
3996 if (!initialize_class(c))
4003 void _Jv_JNI_SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID,
4009 STATISTICS(jniinvokation());
4011 c = (classinfo *) clazz;
4012 f = (fieldinfo *) fieldID;
4014 if (!(c->state & CLASS_INITIALIZED))
4015 if (!initialize_class(c))
4022 void _Jv_JNI_SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID,
4028 STATISTICS(jniinvokation());
4030 c = (classinfo *) clazz;
4031 f = (fieldinfo *) fieldID;
4033 if (!(c->state & CLASS_INITIALIZED))
4034 if (!initialize_class(c))
4041 /* String Operations **********************************************************/
4043 /* NewString *******************************************************************
4045 Create new java.lang.String object from an array of Unicode
4048 *******************************************************************************/
4050 jstring _Jv_JNI_NewString(JNIEnv *env, const jchar *buf, jsize len)
4052 java_lang_String *s;
4056 STATISTICS(jniinvokation());
4058 s = (java_lang_String *) builtin_new(class_java_lang_String);
4059 a = builtin_newarray_char(len);
4061 /* javastring or characterarray could not be created */
4062 if ((a == NULL) || (s == NULL))
4066 for (i = 0; i < len; i++)
4067 a->data[i] = buf[i];
4073 return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
4077 static jchar emptyStringJ[]={0,0};
4079 /* GetStringLength *************************************************************
4081 Returns the length (the count of Unicode characters) of a Java
4084 *******************************************************************************/
4086 jsize _Jv_JNI_GetStringLength(JNIEnv *env, jstring str)
4088 return ((java_lang_String *) str)->count;
4092 /******************** convertes javastring to u2-array ****************************/
4094 u2 *javastring_tou2(jstring so)
4096 java_lang_String *s;
4101 STATISTICS(jniinvokation());
4103 s = (java_lang_String *) so;
4113 /* allocate memory */
4115 stringbuffer = MNEW(u2, s->count + 1);
4119 for (i = 0; i < s->count; i++)
4120 stringbuffer[i] = a->data[s->offset + i];
4122 /* terminate string */
4124 stringbuffer[i] = '\0';
4126 return stringbuffer;
4130 /* GetStringChars **************************************************************
4132 Returns a pointer to the array of Unicode characters of the
4133 string. This pointer is valid until ReleaseStringchars() is called.
4135 *******************************************************************************/
4137 const jchar *_Jv_JNI_GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
4141 STATISTICS(jniinvokation());
4143 jc = javastring_tou2(str);
4155 return emptyStringJ;
4159 /* ReleaseStringChars **********************************************************
4161 Informs the VM that the native code no longer needs access to
4162 chars. The chars argument is a pointer obtained from string using
4165 *******************************************************************************/
4167 void _Jv_JNI_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
4169 STATISTICS(jniinvokation());
4171 if (chars == emptyStringJ)
4174 MFREE(((jchar *) chars), jchar, ((java_lang_String *) str)->count + 1);
4178 /* NewStringUTF ****************************************************************
4180 Constructs a new java.lang.String object from an array of UTF-8 characters.
4182 *******************************************************************************/
4184 jstring _Jv_JNI_NewStringUTF(JNIEnv *env, const char *bytes)
4186 java_lang_String *s;
4188 STATISTICS(jniinvokation());
4190 s = javastring_safe_new_from_utf8(bytes);
4192 return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
4196 /****************** returns the utf8 length in bytes of a string *******************/
4198 jsize _Jv_JNI_GetStringUTFLength (JNIEnv *env, jstring string)
4200 java_lang_String *s = (java_lang_String*) string;
4202 STATISTICS(jniinvokation());
4204 return (jsize) u2_utflength(s->value->data, s->count);
4208 /* GetStringUTFChars ***********************************************************
4210 Returns a pointer to an array of UTF-8 characters of the
4211 string. This array is valid until it is released by
4212 ReleaseStringUTFChars().
4214 *******************************************************************************/
4216 const char *_Jv_JNI_GetStringUTFChars(JNIEnv *env, jstring string,
4221 STATISTICS(jniinvokation());
4229 u = javastring_toutf((java_lang_String *) string, false);
4238 /* ReleaseStringUTFChars *******************************************************
4240 Informs the VM that the native code no longer needs access to
4241 utf. The utf argument is a pointer derived from string using
4242 GetStringUTFChars().
4244 *******************************************************************************/
4246 void _Jv_JNI_ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
4248 STATISTICS(jniinvokation());
4250 /* XXX we don't release utf chars right now, perhaps that should be done
4251 later. Since there is always one reference the garbage collector will
4256 /* Array Operations ***********************************************************/
4258 /* GetArrayLength **************************************************************
4260 Returns the number of elements in the array.
4262 *******************************************************************************/
4264 jsize _Jv_JNI_GetArrayLength(JNIEnv *env, jarray array)
4266 java_arrayheader *a;
4268 STATISTICS(jniinvokation());
4270 a = (java_arrayheader *) array;
4276 /* NewObjectArray **************************************************************
4278 Constructs a new array holding objects in class elementClass. All
4279 elements are initially set to initialElement.
4281 *******************************************************************************/
4283 jobjectArray _Jv_JNI_NewObjectArray(JNIEnv *env, jsize length,
4284 jclass elementClass, jobject initialElement)
4286 java_objectarray *oa;
4289 STATISTICS(jniinvokation());
4292 exceptions_throw_negativearraysizeexception();
4296 oa = builtin_anewarray(length, elementClass);
4301 /* set all elements to initialElement */
4303 for (i = 0; i < length; i++)
4304 oa->data[i] = initialElement;
4306 return (jobjectArray) _Jv_JNI_NewLocalRef(env, (jobject) oa);
4310 jobject _Jv_JNI_GetObjectArrayElement(JNIEnv *env, jobjectArray array,
4313 java_objectarray *oa;
4316 STATISTICS(jniinvokation());
4318 oa = (java_objectarray *) array;
4320 if (index >= oa->header.size) {
4321 exceptions_throw_arrayindexoutofboundsexception();
4325 o = oa->data[index];
4327 return _Jv_JNI_NewLocalRef(env, o);
4331 void _Jv_JNI_SetObjectArrayElement(JNIEnv *env, jobjectArray array,
4332 jsize index, jobject val)
4334 java_objectarray *oa;
4335 java_objectheader *o;
4337 STATISTICS(jniinvokation());
4339 oa = (java_objectarray *) array;
4340 o = (java_objectheader *) val;
4342 if (index >= oa->header.size) {
4343 exceptions_throw_arrayindexoutofboundsexception();
4347 /* check if the class of value is a subclass of the element class
4350 if (!builtin_canstore(oa, o)) {
4351 exceptions_throw_arraystoreexception();
4355 oa->data[index] = val;
4359 jbooleanArray _Jv_JNI_NewBooleanArray(JNIEnv *env, jsize len)
4361 java_booleanarray *ba;
4363 STATISTICS(jniinvokation());
4366 exceptions_throw_negativearraysizeexception();
4370 ba = builtin_newarray_boolean(len);
4372 return (jbooleanArray) _Jv_JNI_NewLocalRef(env, (jobject) ba);
4376 jbyteArray _Jv_JNI_NewByteArray(JNIEnv *env, jsize len)
4380 STATISTICS(jniinvokation());
4383 exceptions_throw_negativearraysizeexception();
4387 ba = builtin_newarray_byte(len);
4389 return (jbyteArray) _Jv_JNI_NewLocalRef(env, (jobject) ba);
4393 jcharArray _Jv_JNI_NewCharArray(JNIEnv *env, jsize len)
4397 STATISTICS(jniinvokation());
4400 exceptions_throw_negativearraysizeexception();
4404 ca = builtin_newarray_char(len);
4406 return (jcharArray) _Jv_JNI_NewLocalRef(env, (jobject) ca);
4410 jshortArray _Jv_JNI_NewShortArray(JNIEnv *env, jsize len)
4412 java_shortarray *sa;
4414 STATISTICS(jniinvokation());
4417 exceptions_throw_negativearraysizeexception();
4421 sa = builtin_newarray_short(len);
4423 return (jshortArray) _Jv_JNI_NewLocalRef(env, (jobject) sa);
4427 jintArray _Jv_JNI_NewIntArray(JNIEnv *env, jsize len)
4431 STATISTICS(jniinvokation());
4434 exceptions_throw_negativearraysizeexception();
4438 ia = builtin_newarray_int(len);
4440 return (jintArray) _Jv_JNI_NewLocalRef(env, (jobject) ia);
4444 jlongArray _Jv_JNI_NewLongArray(JNIEnv *env, jsize len)
4448 STATISTICS(jniinvokation());
4451 exceptions_throw_negativearraysizeexception();
4455 la = builtin_newarray_long(len);
4457 return (jlongArray) _Jv_JNI_NewLocalRef(env, (jobject) la);
4461 jfloatArray _Jv_JNI_NewFloatArray(JNIEnv *env, jsize len)
4463 java_floatarray *fa;
4465 STATISTICS(jniinvokation());
4468 exceptions_throw_negativearraysizeexception();
4472 fa = builtin_newarray_float(len);
4474 return (jfloatArray) _Jv_JNI_NewLocalRef(env, (jobject) fa);
4478 jdoubleArray _Jv_JNI_NewDoubleArray(JNIEnv *env, jsize len)
4480 java_doublearray *da;
4482 STATISTICS(jniinvokation());
4485 exceptions_throw_negativearraysizeexception();
4489 da = builtin_newarray_double(len);
4491 return (jdoubleArray) _Jv_JNI_NewLocalRef(env, (jobject) da);
4495 /* Get<PrimitiveType>ArrayElements *********************************************
4497 A family of functions that returns the body of the primitive array.
4499 *******************************************************************************/
4501 jboolean *_Jv_JNI_GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
4504 java_booleanarray *ba;
4506 STATISTICS(jniinvokation());
4508 ba = (java_booleanarray *) array;
4511 *isCopy = JNI_FALSE;
4517 jbyte *_Jv_JNI_GetByteArrayElements(JNIEnv *env, jbyteArray array,
4522 STATISTICS(jniinvokation());
4524 ba = (java_bytearray *) array;
4527 *isCopy = JNI_FALSE;
4533 jchar *_Jv_JNI_GetCharArrayElements(JNIEnv *env, jcharArray array,
4538 STATISTICS(jniinvokation());
4540 ca = (java_chararray *) array;
4543 *isCopy = JNI_FALSE;
4549 jshort *_Jv_JNI_GetShortArrayElements(JNIEnv *env, jshortArray array,
4552 java_shortarray *sa;
4554 STATISTICS(jniinvokation());
4556 sa = (java_shortarray *) array;
4559 *isCopy = JNI_FALSE;
4565 jint *_Jv_JNI_GetIntArrayElements(JNIEnv *env, jintArray array,
4570 STATISTICS(jniinvokation());
4572 ia = (java_intarray *) array;
4575 *isCopy = JNI_FALSE;
4581 jlong *_Jv_JNI_GetLongArrayElements(JNIEnv *env, jlongArray array,
4586 STATISTICS(jniinvokation());
4588 la = (java_longarray *) array;
4591 *isCopy = JNI_FALSE;
4593 /* We cast this one to prevent a compiler warning on 64-bit
4594 systems since GNU Classpath typedef jlong to long long. */
4596 return (jlong *) la->data;
4600 jfloat *_Jv_JNI_GetFloatArrayElements(JNIEnv *env, jfloatArray array,
4603 java_floatarray *fa;
4605 STATISTICS(jniinvokation());
4607 fa = (java_floatarray *) array;
4610 *isCopy = JNI_FALSE;
4616 jdouble *_Jv_JNI_GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
4619 java_doublearray *da;
4621 STATISTICS(jniinvokation());
4623 da = (java_doublearray *) array;
4626 *isCopy = JNI_FALSE;
4632 /* Release<PrimitiveType>ArrayElements *****************************************
4634 A family of functions that informs the VM that the native code no
4635 longer needs access to elems. The elems argument is a pointer
4636 derived from array using the corresponding
4637 Get<PrimitiveType>ArrayElements() function. If necessary, this
4638 function copies back all changes made to elems to the original
4641 *******************************************************************************/
4643 void _Jv_JNI_ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array,
4644 jboolean *elems, jint mode)
4646 java_booleanarray *ba;
4648 STATISTICS(jniinvokation());
4650 ba = (java_booleanarray *) array;
4652 if (elems != ba->data) {
4655 MCOPY(ba->data, elems, u1, ba->header.size);
4658 MCOPY(ba->data, elems, u1, ba->header.size);
4659 /* XXX TWISTI how should it be freed? */
4662 /* XXX TWISTI how should it be freed? */
4669 void _Jv_JNI_ReleaseByteArrayElements(JNIEnv *env, jbyteArray array,
4670 jbyte *elems, jint mode)
4674 STATISTICS(jniinvokation());
4676 ba = (java_bytearray *) array;
4678 if (elems != ba->data) {
4681 MCOPY(ba->data, elems, s1, ba->header.size);
4684 MCOPY(ba->data, elems, s1, ba->header.size);
4685 /* XXX TWISTI how should it be freed? */
4688 /* XXX TWISTI how should it be freed? */
4695 void _Jv_JNI_ReleaseCharArrayElements(JNIEnv *env, jcharArray array,
4696 jchar *elems, jint mode)
4700 STATISTICS(jniinvokation());
4702 ca = (java_chararray *) array;
4704 if (elems != ca->data) {
4707 MCOPY(ca->data, elems, u2, ca->header.size);
4710 MCOPY(ca->data, elems, u2, ca->header.size);
4711 /* XXX TWISTI how should it be freed? */
4714 /* XXX TWISTI how should it be freed? */
4721 void _Jv_JNI_ReleaseShortArrayElements(JNIEnv *env, jshortArray array,
4722 jshort *elems, jint mode)
4724 java_shortarray *sa;
4726 STATISTICS(jniinvokation());
4728 sa = (java_shortarray *) array;
4730 if (elems != sa->data) {
4733 MCOPY(sa->data, elems, s2, sa->header.size);
4736 MCOPY(sa->data, elems, s2, sa->header.size);
4737 /* XXX TWISTI how should it be freed? */
4740 /* XXX TWISTI how should it be freed? */
4747 void _Jv_JNI_ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems,
4752 STATISTICS(jniinvokation());
4754 ia = (java_intarray *) array;
4756 if (elems != ia->data) {
4759 MCOPY(ia->data, elems, s4, ia->header.size);
4762 MCOPY(ia->data, elems, s4, ia->header.size);
4763 /* XXX TWISTI how should it be freed? */
4766 /* XXX TWISTI how should it be freed? */
4773 void _Jv_JNI_ReleaseLongArrayElements(JNIEnv *env, jlongArray array,
4774 jlong *elems, jint mode)
4778 STATISTICS(jniinvokation());
4780 la = (java_longarray *) array;
4782 /* We cast this one to prevent a compiler warning on 64-bit
4783 systems since GNU Classpath typedef jlong to long long. */
4785 if ((s8 *) elems != la->data) {
4788 MCOPY(la->data, elems, s8, la->header.size);
4791 MCOPY(la->data, elems, s8, la->header.size);
4792 /* XXX TWISTI how should it be freed? */
4795 /* XXX TWISTI how should it be freed? */
4802 void _Jv_JNI_ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array,
4803 jfloat *elems, jint mode)
4805 java_floatarray *fa;
4807 STATISTICS(jniinvokation());
4809 fa = (java_floatarray *) array;
4811 if (elems != fa->data) {
4814 MCOPY(fa->data, elems, float, fa->header.size);
4817 MCOPY(fa->data, elems, float, fa->header.size);
4818 /* XXX TWISTI how should it be freed? */
4821 /* XXX TWISTI how should it be freed? */
4828 void _Jv_JNI_ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array,
4829 jdouble *elems, jint mode)
4831 java_doublearray *da;
4833 STATISTICS(jniinvokation());
4835 da = (java_doublearray *) array;
4837 if (elems != da->data) {
4840 MCOPY(da->data, elems, double, da->header.size);
4843 MCOPY(da->data, elems, double, da->header.size);
4844 /* XXX TWISTI how should it be freed? */
4847 /* XXX TWISTI how should it be freed? */
4854 /* Get<PrimitiveType>ArrayRegion **********************************************
4856 A family of functions that copies a region of a primitive array
4859 *******************************************************************************/
4861 void _Jv_JNI_GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array,
4862 jsize start, jsize len, jboolean *buf)
4864 java_booleanarray *ba;
4866 STATISTICS(jniinvokation());
4868 ba = (java_booleanarray *) array;
4870 if ((start < 0) || (len < 0) || (start + len > ba->header.size))
4871 exceptions_throw_arrayindexoutofboundsexception();
4873 MCOPY(buf, &ba->data[start], u1, len);
4877 void _Jv_JNI_GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start,
4878 jsize len, jbyte *buf)
4882 STATISTICS(jniinvokation());
4884 ba = (java_bytearray *) array;
4886 if ((start < 0) || (len < 0) || (start + len > ba->header.size))
4887 exceptions_throw_arrayindexoutofboundsexception();
4889 MCOPY(buf, &ba->data[start], s1, len);
4893 void _Jv_JNI_GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start,
4894 jsize len, jchar *buf)
4898 STATISTICS(jniinvokation());
4900 ca = (java_chararray *) array;
4902 if ((start < 0) || (len < 0) || (start + len > ca->header.size))
4903 exceptions_throw_arrayindexoutofboundsexception();
4905 MCOPY(buf, &ca->data[start], u2, len);
4909 void _Jv_JNI_GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
4910 jsize len, jshort *buf)
4912 java_shortarray *sa;
4914 STATISTICS(jniinvokation());
4916 sa = (java_shortarray *) array;
4918 if ((start < 0) || (len < 0) || (start + len > sa->header.size))
4919 exceptions_throw_arrayindexoutofboundsexception();
4921 MCOPY(buf, &sa->data[start], s2, len);
4925 void _Jv_JNI_GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start,
4926 jsize len, jint *buf)
4930 STATISTICS(jniinvokation());
4932 ia = (java_intarray *) array;
4934 if ((start < 0) || (len < 0) || (start + len > ia->header.size))
4935 exceptions_throw_arrayindexoutofboundsexception();
4937 MCOPY(buf, &ia->data[start], s4, len);
4941 void _Jv_JNI_GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start,
4942 jsize len, jlong *buf)
4946 STATISTICS(jniinvokation());
4948 la = (java_longarray *) array;
4950 if ((start < 0) || (len < 0) || (start + len > la->header.size))
4951 exceptions_throw_arrayindexoutofboundsexception();
4953 MCOPY(buf, &la->data[start], s8, len);
4957 void _Jv_JNI_GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
4958 jsize len, jfloat *buf)
4960 java_floatarray *fa;
4962 STATISTICS(jniinvokation());
4964 fa = (java_floatarray *) array;
4966 if ((start < 0) || (len < 0) || (start + len > fa->header.size))
4967 exceptions_throw_arrayindexoutofboundsexception();
4969 MCOPY(buf, &fa->data[start], float, len);
4973 void _Jv_JNI_GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
4974 jsize len, jdouble *buf)
4976 java_doublearray *da;
4978 STATISTICS(jniinvokation());
4980 da = (java_doublearray *) array;
4982 if ((start < 0) || (len < 0) || (start + len > da->header.size))
4983 exceptions_throw_arrayindexoutofboundsexception();
4985 MCOPY(buf, &da->data[start], double, len);
4989 /* Set<PrimitiveType>ArrayRegion **********************************************
4991 A family of functions that copies back a region of a primitive
4992 array from a buffer.
4994 *******************************************************************************/
4996 void _Jv_JNI_SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array,
4997 jsize start, jsize len, jboolean *buf)
4999 java_booleanarray *ba;
5001 STATISTICS(jniinvokation());
5003 ba = (java_booleanarray *) array;
5005 if ((start < 0) || (len < 0) || (start + len > ba->header.size))
5006 exceptions_throw_arrayindexoutofboundsexception();
5008 MCOPY(&ba->data[start], buf, u1, len);
5012 void _Jv_JNI_SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start,
5013 jsize len, jbyte *buf)
5017 STATISTICS(jniinvokation());
5019 ba = (java_bytearray *) array;
5021 if ((start < 0) || (len < 0) || (start + len > ba->header.size))
5022 exceptions_throw_arrayindexoutofboundsexception();
5024 MCOPY(&ba->data[start], buf, s1, len);
5028 void _Jv_JNI_SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start,
5029 jsize len, jchar *buf)
5033 STATISTICS(jniinvokation());
5035 ca = (java_chararray *) array;
5037 if ((start < 0) || (len < 0) || (start + len > ca->header.size))
5038 exceptions_throw_arrayindexoutofboundsexception();
5040 MCOPY(&ca->data[start], buf, u2, len);
5044 void _Jv_JNI_SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
5045 jsize len, jshort *buf)
5047 java_shortarray *sa;
5049 STATISTICS(jniinvokation());
5051 sa = (java_shortarray *) array;
5053 if ((start < 0) || (len < 0) || (start + len > sa->header.size))
5054 exceptions_throw_arrayindexoutofboundsexception();
5056 MCOPY(&sa->data[start], buf, s2, len);
5060 void _Jv_JNI_SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start,
5061 jsize len, jint *buf)
5065 STATISTICS(jniinvokation());
5067 ia = (java_intarray *) array;
5069 if ((start < 0) || (len < 0) || (start + len > ia->header.size))
5070 exceptions_throw_arrayindexoutofboundsexception();
5072 MCOPY(&ia->data[start], buf, s4, len);
5076 void _Jv_JNI_SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start,
5077 jsize len, jlong *buf)
5081 STATISTICS(jniinvokation());
5083 la = (java_longarray *) array;
5085 if ((start < 0) || (len < 0) || (start + len > la->header.size))
5086 exceptions_throw_arrayindexoutofboundsexception();
5088 MCOPY(&la->data[start], buf, s8, len);
5092 void _Jv_JNI_SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
5093 jsize len, jfloat *buf)
5095 java_floatarray *fa;
5097 STATISTICS(jniinvokation());
5099 fa = (java_floatarray *) array;
5101 if ((start < 0) || (len < 0) || (start + len > fa->header.size))
5102 exceptions_throw_arrayindexoutofboundsexception();
5104 MCOPY(&fa->data[start], buf, float, len);
5108 void _Jv_JNI_SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
5109 jsize len, jdouble *buf)
5111 java_doublearray *da;
5113 STATISTICS(jniinvokation());
5115 da = (java_doublearray *) array;
5117 if ((start < 0) || (len < 0) || (start + len > da->header.size))
5118 exceptions_throw_arrayindexoutofboundsexception();
5120 MCOPY(&da->data[start], buf, double, len);
5124 /* Registering Native Methods *************************************************/
5126 /* RegisterNatives *************************************************************
5128 Registers native methods with the class specified by the clazz
5129 argument. The methods parameter specifies an array of
5130 JNINativeMethod structures that contain the names, signatures, and
5131 function pointers of the native methods. The nMethods parameter
5132 specifies the number of native methods in the array.
5134 *******************************************************************************/
5136 jint _Jv_JNI_RegisterNatives(JNIEnv *env, jclass clazz,
5137 const JNINativeMethod *methods, jint nMethods)
5139 STATISTICS(jniinvokation());
5141 log_text("JNI-Call: RegisterNatives: IMPLEMENT ME!!!");
5142 /* XXX: if implemented this needs a call to jvmti_NativeMethodBind
5143 if (jvmti) jvmti_NativeMethodBind(method, address, new_address_ptr);
5150 /* UnregisterNatives ***********************************************************
5152 Unregisters native methods of a class. The class goes back to the
5153 state before it was linked or registered with its native method
5156 This function should not be used in normal native code. Instead, it
5157 provides special programs a way to reload and relink native
5160 *******************************************************************************/
5162 jint _Jv_JNI_UnregisterNatives(JNIEnv *env, jclass clazz)
5164 STATISTICS(jniinvokation());
5166 /* XXX TWISTI hmm, maybe we should not support that (like kaffe) */
5168 log_text("JNI-Call: UnregisterNatives: IMPLEMENT ME!!!");
5174 /* Monitor Operations *********************************************************/
5176 /* MonitorEnter ****************************************************************
5178 Enters the monitor associated with the underlying Java object
5181 *******************************************************************************/
5183 jint _Jv_JNI_MonitorEnter(JNIEnv *env, jobject obj)
5185 STATISTICS(jniinvokation());
5188 exceptions_throw_nullpointerexception();
5192 LOCK_MONITOR_ENTER(obj);
5198 /* MonitorExit *****************************************************************
5200 The current thread must be the owner of the monitor associated with
5201 the underlying Java object referred to by obj. The thread
5202 decrements the counter indicating the number of times it has
5203 entered this monitor. If the value of the counter becomes zero, the
5204 current thread releases the monitor.
5206 *******************************************************************************/
5208 jint _Jv_JNI_MonitorExit(JNIEnv *env, jobject obj)
5210 STATISTICS(jniinvokation());
5213 exceptions_throw_nullpointerexception();
5217 LOCK_MONITOR_EXIT(obj);
5223 /* JavaVM Interface ***********************************************************/
5225 /* GetJavaVM *******************************************************************
5227 Returns the Java VM interface (used in the Invocation API)
5228 associated with the current thread. The result is placed at the
5229 location pointed to by the second argument, vm.
5231 *******************************************************************************/
5233 jint _Jv_JNI_GetJavaVM(JNIEnv *env, JavaVM **vm)
5235 STATISTICS(jniinvokation());
5237 *vm = (JavaVM *) _Jv_jvm;
5243 /* GetStringRegion *************************************************************
5245 Copies len number of Unicode characters beginning at offset start
5246 to the given buffer buf.
5248 Throws StringIndexOutOfBoundsException on index overflow.
5250 *******************************************************************************/
5252 void _Jv_JNI_GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len,
5255 java_lang_String *s;
5258 STATISTICS(jniinvokation());
5260 s = (java_lang_String *) str;
5263 if ((start < 0) || (len < 0) || (start > s->count) ||
5264 (start + len > s->count)) {
5265 exceptions_throw_stringindexoutofboundsexception();
5269 MCOPY(buf, &ca->data[start], u2, len);
5273 void _Jv_JNI_GetStringUTFRegion(JNIEnv* env, jstring str, jsize start,
5274 jsize len, char *buf)
5276 STATISTICS(jniinvokation());
5278 log_text("JNI-Call: GetStringUTFRegion: IMPLEMENT ME!");
5282 /* GetPrimitiveArrayCritical ***************************************************
5284 Obtain a direct pointer to array elements.
5286 *******************************************************************************/
5288 void *_Jv_JNI_GetPrimitiveArrayCritical(JNIEnv *env, jarray array,
5294 ba = (java_bytearray *) array;
5296 /* do the same as Kaffe does */
5298 bp = _Jv_JNI_GetByteArrayElements(env, ba, isCopy);
5304 /* ReleasePrimitiveArrayCritical ***********************************************
5306 No specific documentation.
5308 *******************************************************************************/
5310 void _Jv_JNI_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array,
5311 void *carray, jint mode)
5313 STATISTICS(jniinvokation());
5315 /* do the same as Kaffe does */
5317 _Jv_JNI_ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray,
5322 /* GetStringCritical ***********************************************************
5324 The semantics of these two functions are similar to the existing
5325 Get/ReleaseStringChars functions.
5327 *******************************************************************************/
5329 const jchar *_Jv_JNI_GetStringCritical(JNIEnv *env, jstring string,
5332 STATISTICS(jniinvokation());
5334 return _Jv_JNI_GetStringChars(env, string, isCopy);
5338 void _Jv_JNI_ReleaseStringCritical(JNIEnv *env, jstring string,
5339 const jchar *cstring)
5341 STATISTICS(jniinvokation());
5343 _Jv_JNI_ReleaseStringChars(env, string, cstring);
5347 jweak _Jv_JNI_NewWeakGlobalRef(JNIEnv* env, jobject obj)
5349 STATISTICS(jniinvokation());
5351 log_text("JNI-Call: NewWeakGlobalRef: IMPLEMENT ME!");
5357 void _Jv_JNI_DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
5359 STATISTICS(jniinvokation());
5361 log_text("JNI-Call: DeleteWeakGlobalRef: IMPLEMENT ME");
5365 /* NewGlobalRef ****************************************************************
5367 Creates a new global reference to the object referred to by the obj
5370 *******************************************************************************/
5372 jobject _Jv_JNI_NewGlobalRef(JNIEnv* env, jobject obj)
5374 hashtable_global_ref_entry *gre;
5375 u4 key; /* hashkey */
5376 u4 slot; /* slot in hashtable */
5378 STATISTICS(jniinvokation());
5380 LOCK_MONITOR_ENTER(hashtable_global_ref->header);
5382 /* normally addresses are aligned to 4, 8 or 16 bytes */
5384 key = ((u4) (ptrint) obj) >> 4; /* align to 16-byte boundaries */
5385 slot = key & (hashtable_global_ref->size - 1);
5386 gre = hashtable_global_ref->ptr[slot];
5388 /* search external hash chain for the entry */
5391 if (gre->o == obj) {
5392 /* global object found, increment the reference */
5396 LOCK_MONITOR_EXIT(hashtable_global_ref->header);
5401 gre = gre->hashlink; /* next element in external chain */
5404 /* global ref not found, create a new one */
5406 gre = NEW(hashtable_global_ref_entry);
5411 /* insert entry into hashtable */
5413 gre->hashlink = hashtable_global_ref->ptr[slot];
5415 hashtable_global_ref->ptr[slot] = gre;
5417 /* update number of hashtable-entries */
5419 hashtable_global_ref->entries++;
5421 LOCK_MONITOR_EXIT(hashtable_global_ref->header);
5427 /* DeleteGlobalRef *************************************************************
5429 Deletes the global reference pointed to by globalRef.
5431 *******************************************************************************/
5433 void _Jv_JNI_DeleteGlobalRef(JNIEnv* env, jobject globalRef)
5435 hashtable_global_ref_entry *gre;
5436 hashtable_global_ref_entry *prevgre;
5437 u4 key; /* hashkey */
5438 u4 slot; /* slot in hashtable */
5440 STATISTICS(jniinvokation());
5442 LOCK_MONITOR_ENTER(hashtable_global_ref->header);
5444 /* normally addresses are aligned to 4, 8 or 16 bytes */
5446 key = ((u4) (ptrint) globalRef) >> 4; /* align to 16-byte boundaries */
5447 slot = key & (hashtable_global_ref->size - 1);
5448 gre = hashtable_global_ref->ptr[slot];
5450 /* initialize prevgre */
5454 /* search external hash chain for the entry */
5457 if (gre->o == globalRef) {
5458 /* global object found, decrement the reference count */
5462 /* if reference count is 0, remove the entry */
5464 if (gre->refs == 0) {
5465 /* special handling if it's the first in the chain */
5467 if (prevgre == NULL)
5468 hashtable_global_ref->ptr[slot] = gre->hashlink;
5470 prevgre->hashlink = gre->hashlink;
5472 FREE(gre, hashtable_global_ref_entry);
5475 LOCK_MONITOR_EXIT(hashtable_global_ref->header);
5480 prevgre = gre; /* save current pointer for removal */
5481 gre = gre->hashlink; /* next element in external chain */
5484 log_println("JNI-DeleteGlobalRef: global reference not found");
5486 LOCK_MONITOR_EXIT(hashtable_global_ref->header);
5490 /* ExceptionCheck **************************************************************
5492 Returns JNI_TRUE when there is a pending exception; otherwise,
5495 *******************************************************************************/
5497 jboolean _Jv_JNI_ExceptionCheck(JNIEnv *env)
5499 java_objectheader *o;
5501 STATISTICS(jniinvokation());
5503 o = exceptions_get_exception();
5505 return (o != NULL) ? JNI_TRUE : JNI_FALSE;
5509 /* New JNI 1.4 functions ******************************************************/
5511 /* NewDirectByteBuffer *********************************************************
5513 Allocates and returns a direct java.nio.ByteBuffer referring to the
5514 block of memory starting at the memory address address and
5515 extending capacity bytes.
5517 *******************************************************************************/
5519 jobject _Jv_JNI_NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
5521 #if defined(ENABLE_JAVASE)
5522 java_objectheader *nbuf;
5523 # if SIZEOF_VOID_P == 8
5524 gnu_classpath_Pointer64 *paddress;
5526 gnu_classpath_Pointer32 *paddress;
5529 STATISTICS(jniinvokation());
5531 /* alocate a gnu.classpath.Pointer{32,64} object */
5533 # if SIZEOF_VOID_P == 8
5534 if (!(paddress = (gnu_classpath_Pointer64 *)
5535 builtin_new(class_gnu_classpath_Pointer64)))
5537 if (!(paddress = (gnu_classpath_Pointer32 *)
5538 builtin_new(class_gnu_classpath_Pointer32)))
5542 /* fill gnu.classpath.Pointer{32,64} with address */
5544 paddress->data = (ptrint) address;
5546 /* create a java.nio.DirectByteBufferImpl$ReadWrite object */
5548 nbuf = (*env)->NewObject(env, class_java_nio_DirectByteBufferImpl_ReadWrite,
5549 (jmethodID) dbbirw_init, NULL, paddress,
5550 (jint) capacity, (jint) capacity, (jint) 0);
5552 /* add local reference and return the value */
5554 return _Jv_JNI_NewLocalRef(env, nbuf);
5556 vm_abort("_Jv_JNI_NewDirectByteBuffer: not implemented in this configuration");
5558 /* keep compiler happy */
5565 /* GetDirectBufferAddress ******************************************************
5567 Fetches and returns the starting address of the memory region
5568 referenced by the given direct java.nio.Buffer.
5570 *******************************************************************************/
5572 void *_Jv_JNI_GetDirectBufferAddress(JNIEnv *env, jobject buf)
5574 #if defined(ENABLE_JAVASE)
5575 java_nio_DirectByteBufferImpl *nbuf;
5576 # if SIZEOF_VOID_P == 8
5577 gnu_classpath_Pointer64 *address;
5579 gnu_classpath_Pointer32 *address;
5582 STATISTICS(jniinvokation());
5584 if (!builtin_instanceof(buf, class_java_nio_Buffer))
5587 nbuf = (java_nio_DirectByteBufferImpl *) buf;
5589 # if SIZEOF_VOID_P == 8
5590 address = (gnu_classpath_Pointer64 *) nbuf->address;
5592 address = (gnu_classpath_Pointer32 *) nbuf->address;
5595 if (address == NULL)
5598 return (void *) address->data;
5600 vm_abort("_Jv_JNI_GetDirectBufferAddress: not implemented in this configuration");
5602 /* keep compiler happy */
5609 /* GetDirectBufferCapacity *****************************************************
5611 Fetches and returns the capacity in bytes of the memory region
5612 referenced by the given direct java.nio.Buffer.
5614 *******************************************************************************/
5616 jlong _Jv_JNI_GetDirectBufferCapacity(JNIEnv* env, jobject buf)
5618 #if defined(ENABLE_JAVASE)
5619 java_nio_Buffer *nbuf;
5621 STATISTICS(jniinvokation());
5623 if (!builtin_instanceof(buf, class_java_nio_DirectByteBufferImpl))
5626 nbuf = (java_nio_Buffer *) buf;
5628 return (jlong) nbuf->cap;
5630 vm_abort("_Jv_JNI_GetDirectBufferCapacity: not implemented in this configuration");
5632 /* keep compiler happy */
5639 /* DestroyJavaVM ***************************************************************
5641 Unloads a Java VM and reclaims its resources. Only the main thread
5642 can unload the VM. The system waits until the main thread is only
5643 remaining user thread before it destroys the VM.
5645 *******************************************************************************/
5647 jint _Jv_JNI_DestroyJavaVM(JavaVM *vm)
5651 STATISTICS(jniinvokation());
5653 status = vm_destroy(vm);
5659 /* AttachCurrentThread *********************************************************
5661 Attaches the current thread to a Java VM. Returns a JNI interface
5662 pointer in the JNIEnv argument.
5664 Trying to attach a thread that is already attached is a no-op.
5666 A native thread cannot be attached simultaneously to two Java VMs.
5668 When a thread is attached to the VM, the context class loader is
5669 the bootstrap loader.
5671 *******************************************************************************/
5673 static s4 jni_attach_current_thread(void **p_env, void *thr_args, bool isdaemon)
5675 JavaVMAttachArgs *vm_aargs;
5677 #if defined(ENABLE_THREADS)
5678 if (threads_get_current_threadobject() == NULL) {
5679 vm_aargs = (JavaVMAttachArgs *) thr_args;
5681 if (vm_aargs != NULL) {
5682 if ((vm_aargs->version != JNI_VERSION_1_2) &&
5683 (vm_aargs->version != JNI_VERSION_1_4))
5684 return JNI_EVERSION;
5687 if (!threads_attach_current_thread(vm_aargs, false))
5690 if (!jni_init_localref_table())
5701 jint _Jv_JNI_AttachCurrentThread(JavaVM *vm, void **p_env, void *thr_args)
5703 STATISTICS(jniinvokation());
5705 return jni_attach_current_thread(p_env, thr_args, false);
5709 /* DetachCurrentThread *********************************************************
5711 Detaches the current thread from a Java VM. All Java monitors held
5712 by this thread are released. All Java threads waiting for this
5713 thread to die are notified.
5715 In JDK 1.1, the main thread cannot be detached from the VM. It must
5716 call DestroyJavaVM to unload the entire VM.
5718 In the JDK, the main thread can be detached from the VM.
5720 The main thread, which is the thread that created the Java VM,
5721 cannot be detached from the VM. Instead, the main thread must call
5722 JNI_DestroyJavaVM() to unload the entire VM.
5724 *******************************************************************************/
5726 jint _Jv_JNI_DetachCurrentThread(JavaVM *vm)
5728 #if defined(ENABLE_THREADS)
5729 threadobject *thread;
5731 STATISTICS(jniinvokation());
5733 thread = threads_get_current_threadobject();
5738 if (!jni_free_localref_table())
5741 if (!threads_detach_thread(thread))
5749 /* GetEnv **********************************************************************
5751 If the current thread is not attached to the VM, sets *env to NULL,
5752 and returns JNI_EDETACHED. If the specified version is not
5753 supported, sets *env to NULL, and returns JNI_EVERSION. Otherwise,
5754 sets *env to the appropriate interface, and returns JNI_OK.
5756 *******************************************************************************/
5758 jint _Jv_JNI_GetEnv(JavaVM *vm, void **env, jint version)
5760 STATISTICS(jniinvokation());
5762 #if defined(ENABLE_THREADS)
5763 if (threads_get_current_threadobject() == NULL) {
5766 return JNI_EDETACHED;
5770 /* check the JNI version */
5773 case JNI_VERSION_1_1:
5774 case JNI_VERSION_1_2:
5775 case JNI_VERSION_1_4:
5783 #if defined(ENABLE_JVMTI)
5784 if ((version & JVMTI_VERSION_MASK_INTERFACE_TYPE)
5785 == JVMTI_VERSION_INTERFACE_JVMTI) {
5787 *env = (void *) jvmti_new_environment();
5796 return JNI_EVERSION;
5800 /* AttachCurrentThreadAsDaemon *************************************************
5802 Same semantics as AttachCurrentThread, but the newly-created
5803 java.lang.Thread instance is a daemon.
5805 If the thread has already been attached via either
5806 AttachCurrentThread or AttachCurrentThreadAsDaemon, this routine
5807 simply sets the value pointed to by penv to the JNIEnv of the
5808 current thread. In this case neither AttachCurrentThread nor this
5809 routine have any effect on the daemon status of the thread.
5811 *******************************************************************************/
5813 jint _Jv_JNI_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *args)
5815 STATISTICS(jniinvokation());
5817 return jni_attach_current_thread(penv, args, true);
5821 /* JNI invocation table *******************************************************/
5823 const struct JNIInvokeInterface _Jv_JNIInvokeInterface = {
5828 _Jv_JNI_DestroyJavaVM,
5829 _Jv_JNI_AttachCurrentThread,
5830 _Jv_JNI_DetachCurrentThread,
5832 _Jv_JNI_AttachCurrentThreadAsDaemon
5836 /* JNI function table *********************************************************/
5838 struct JNINativeInterface _Jv_JNINativeInterface = {
5845 _Jv_JNI_DefineClass,
5847 _Jv_JNI_FromReflectedMethod,
5848 _Jv_JNI_FromReflectedField,
5849 _Jv_JNI_ToReflectedMethod,
5850 _Jv_JNI_GetSuperclass,
5851 _Jv_JNI_IsAssignableFrom,
5852 _Jv_JNI_ToReflectedField,
5856 _Jv_JNI_ExceptionOccurred,
5857 _Jv_JNI_ExceptionDescribe,
5858 _Jv_JNI_ExceptionClear,
5860 _Jv_JNI_PushLocalFrame,
5861 _Jv_JNI_PopLocalFrame,
5863 _Jv_JNI_NewGlobalRef,
5864 _Jv_JNI_DeleteGlobalRef,
5865 _Jv_JNI_DeleteLocalRef,
5866 _Jv_JNI_IsSameObject,
5867 _Jv_JNI_NewLocalRef,
5868 _Jv_JNI_EnsureLocalCapacity,
5870 _Jv_JNI_AllocObject,
5875 _Jv_JNI_GetObjectClass,
5876 _Jv_JNI_IsInstanceOf,
5878 _Jv_JNI_GetMethodID,
5880 _Jv_JNI_CallObjectMethod,
5881 _Jv_JNI_CallObjectMethodV,
5882 _Jv_JNI_CallObjectMethodA,
5883 _Jv_JNI_CallBooleanMethod,
5884 _Jv_JNI_CallBooleanMethodV,
5885 _Jv_JNI_CallBooleanMethodA,
5886 _Jv_JNI_CallByteMethod,
5887 _Jv_JNI_CallByteMethodV,
5888 _Jv_JNI_CallByteMethodA,
5889 _Jv_JNI_CallCharMethod,
5890 _Jv_JNI_CallCharMethodV,
5891 _Jv_JNI_CallCharMethodA,
5892 _Jv_JNI_CallShortMethod,
5893 _Jv_JNI_CallShortMethodV,
5894 _Jv_JNI_CallShortMethodA,
5895 _Jv_JNI_CallIntMethod,
5896 _Jv_JNI_CallIntMethodV,
5897 _Jv_JNI_CallIntMethodA,
5898 _Jv_JNI_CallLongMethod,
5899 _Jv_JNI_CallLongMethodV,
5900 _Jv_JNI_CallLongMethodA,
5901 _Jv_JNI_CallFloatMethod,
5902 _Jv_JNI_CallFloatMethodV,
5903 _Jv_JNI_CallFloatMethodA,
5904 _Jv_JNI_CallDoubleMethod,
5905 _Jv_JNI_CallDoubleMethodV,
5906 _Jv_JNI_CallDoubleMethodA,
5907 _Jv_JNI_CallVoidMethod,
5908 _Jv_JNI_CallVoidMethodV,
5909 _Jv_JNI_CallVoidMethodA,
5911 _Jv_JNI_CallNonvirtualObjectMethod,
5912 _Jv_JNI_CallNonvirtualObjectMethodV,
5913 _Jv_JNI_CallNonvirtualObjectMethodA,
5914 _Jv_JNI_CallNonvirtualBooleanMethod,
5915 _Jv_JNI_CallNonvirtualBooleanMethodV,
5916 _Jv_JNI_CallNonvirtualBooleanMethodA,
5917 _Jv_JNI_CallNonvirtualByteMethod,
5918 _Jv_JNI_CallNonvirtualByteMethodV,
5919 _Jv_JNI_CallNonvirtualByteMethodA,
5920 _Jv_JNI_CallNonvirtualCharMethod,
5921 _Jv_JNI_CallNonvirtualCharMethodV,
5922 _Jv_JNI_CallNonvirtualCharMethodA,
5923 _Jv_JNI_CallNonvirtualShortMethod,
5924 _Jv_JNI_CallNonvirtualShortMethodV,
5925 _Jv_JNI_CallNonvirtualShortMethodA,
5926 _Jv_JNI_CallNonvirtualIntMethod,
5927 _Jv_JNI_CallNonvirtualIntMethodV,
5928 _Jv_JNI_CallNonvirtualIntMethodA,
5929 _Jv_JNI_CallNonvirtualLongMethod,
5930 _Jv_JNI_CallNonvirtualLongMethodV,
5931 _Jv_JNI_CallNonvirtualLongMethodA,
5932 _Jv_JNI_CallNonvirtualFloatMethod,
5933 _Jv_JNI_CallNonvirtualFloatMethodV,
5934 _Jv_JNI_CallNonvirtualFloatMethodA,
5935 _Jv_JNI_CallNonvirtualDoubleMethod,
5936 _Jv_JNI_CallNonvirtualDoubleMethodV,
5937 _Jv_JNI_CallNonvirtualDoubleMethodA,
5938 _Jv_JNI_CallNonvirtualVoidMethod,
5939 _Jv_JNI_CallNonvirtualVoidMethodV,
5940 _Jv_JNI_CallNonvirtualVoidMethodA,
5944 _Jv_JNI_GetObjectField,
5945 _Jv_JNI_GetBooleanField,
5946 _Jv_JNI_GetByteField,
5947 _Jv_JNI_GetCharField,
5948 _Jv_JNI_GetShortField,
5949 _Jv_JNI_GetIntField,
5950 _Jv_JNI_GetLongField,
5951 _Jv_JNI_GetFloatField,
5952 _Jv_JNI_GetDoubleField,
5953 _Jv_JNI_SetObjectField,
5954 _Jv_JNI_SetBooleanField,
5955 _Jv_JNI_SetByteField,
5956 _Jv_JNI_SetCharField,
5957 _Jv_JNI_SetShortField,
5958 _Jv_JNI_SetIntField,
5959 _Jv_JNI_SetLongField,
5960 _Jv_JNI_SetFloatField,
5961 _Jv_JNI_SetDoubleField,
5963 _Jv_JNI_GetStaticMethodID,
5965 _Jv_JNI_CallStaticObjectMethod,
5966 _Jv_JNI_CallStaticObjectMethodV,
5967 _Jv_JNI_CallStaticObjectMethodA,
5968 _Jv_JNI_CallStaticBooleanMethod,
5969 _Jv_JNI_CallStaticBooleanMethodV,
5970 _Jv_JNI_CallStaticBooleanMethodA,
5971 _Jv_JNI_CallStaticByteMethod,
5972 _Jv_JNI_CallStaticByteMethodV,
5973 _Jv_JNI_CallStaticByteMethodA,
5974 _Jv_JNI_CallStaticCharMethod,
5975 _Jv_JNI_CallStaticCharMethodV,
5976 _Jv_JNI_CallStaticCharMethodA,
5977 _Jv_JNI_CallStaticShortMethod,
5978 _Jv_JNI_CallStaticShortMethodV,
5979 _Jv_JNI_CallStaticShortMethodA,
5980 _Jv_JNI_CallStaticIntMethod,
5981 _Jv_JNI_CallStaticIntMethodV,
5982 _Jv_JNI_CallStaticIntMethodA,
5983 _Jv_JNI_CallStaticLongMethod,
5984 _Jv_JNI_CallStaticLongMethodV,
5985 _Jv_JNI_CallStaticLongMethodA,
5986 _Jv_JNI_CallStaticFloatMethod,
5987 _Jv_JNI_CallStaticFloatMethodV,
5988 _Jv_JNI_CallStaticFloatMethodA,
5989 _Jv_JNI_CallStaticDoubleMethod,
5990 _Jv_JNI_CallStaticDoubleMethodV,
5991 _Jv_JNI_CallStaticDoubleMethodA,
5992 _Jv_JNI_CallStaticVoidMethod,
5993 _Jv_JNI_CallStaticVoidMethodV,
5994 _Jv_JNI_CallStaticVoidMethodA,
5996 _Jv_JNI_GetStaticFieldID,
5998 _Jv_JNI_GetStaticObjectField,
5999 _Jv_JNI_GetStaticBooleanField,
6000 _Jv_JNI_GetStaticByteField,
6001 _Jv_JNI_GetStaticCharField,
6002 _Jv_JNI_GetStaticShortField,
6003 _Jv_JNI_GetStaticIntField,
6004 _Jv_JNI_GetStaticLongField,
6005 _Jv_JNI_GetStaticFloatField,
6006 _Jv_JNI_GetStaticDoubleField,
6007 _Jv_JNI_SetStaticObjectField,
6008 _Jv_JNI_SetStaticBooleanField,
6009 _Jv_JNI_SetStaticByteField,
6010 _Jv_JNI_SetStaticCharField,
6011 _Jv_JNI_SetStaticShortField,
6012 _Jv_JNI_SetStaticIntField,
6013 _Jv_JNI_SetStaticLongField,
6014 _Jv_JNI_SetStaticFloatField,
6015 _Jv_JNI_SetStaticDoubleField,
6018 _Jv_JNI_GetStringLength,
6019 _Jv_JNI_GetStringChars,
6020 _Jv_JNI_ReleaseStringChars,
6022 _Jv_JNI_NewStringUTF,
6023 _Jv_JNI_GetStringUTFLength,
6024 _Jv_JNI_GetStringUTFChars,
6025 _Jv_JNI_ReleaseStringUTFChars,
6027 _Jv_JNI_GetArrayLength,
6029 _Jv_JNI_NewObjectArray,
6030 _Jv_JNI_GetObjectArrayElement,
6031 _Jv_JNI_SetObjectArrayElement,
6033 _Jv_JNI_NewBooleanArray,
6034 _Jv_JNI_NewByteArray,
6035 _Jv_JNI_NewCharArray,
6036 _Jv_JNI_NewShortArray,
6037 _Jv_JNI_NewIntArray,
6038 _Jv_JNI_NewLongArray,
6039 _Jv_JNI_NewFloatArray,
6040 _Jv_JNI_NewDoubleArray,
6042 _Jv_JNI_GetBooleanArrayElements,
6043 _Jv_JNI_GetByteArrayElements,
6044 _Jv_JNI_GetCharArrayElements,
6045 _Jv_JNI_GetShortArrayElements,
6046 _Jv_JNI_GetIntArrayElements,
6047 _Jv_JNI_GetLongArrayElements,
6048 _Jv_JNI_GetFloatArrayElements,
6049 _Jv_JNI_GetDoubleArrayElements,
6051 _Jv_JNI_ReleaseBooleanArrayElements,
6052 _Jv_JNI_ReleaseByteArrayElements,
6053 _Jv_JNI_ReleaseCharArrayElements,
6054 _Jv_JNI_ReleaseShortArrayElements,
6055 _Jv_JNI_ReleaseIntArrayElements,
6056 _Jv_JNI_ReleaseLongArrayElements,
6057 _Jv_JNI_ReleaseFloatArrayElements,
6058 _Jv_JNI_ReleaseDoubleArrayElements,
6060 _Jv_JNI_GetBooleanArrayRegion,
6061 _Jv_JNI_GetByteArrayRegion,
6062 _Jv_JNI_GetCharArrayRegion,
6063 _Jv_JNI_GetShortArrayRegion,
6064 _Jv_JNI_GetIntArrayRegion,
6065 _Jv_JNI_GetLongArrayRegion,
6066 _Jv_JNI_GetFloatArrayRegion,
6067 _Jv_JNI_GetDoubleArrayRegion,
6068 _Jv_JNI_SetBooleanArrayRegion,
6069 _Jv_JNI_SetByteArrayRegion,
6070 _Jv_JNI_SetCharArrayRegion,
6071 _Jv_JNI_SetShortArrayRegion,
6072 _Jv_JNI_SetIntArrayRegion,
6073 _Jv_JNI_SetLongArrayRegion,
6074 _Jv_JNI_SetFloatArrayRegion,
6075 _Jv_JNI_SetDoubleArrayRegion,
6077 _Jv_JNI_RegisterNatives,
6078 _Jv_JNI_UnregisterNatives,
6080 _Jv_JNI_MonitorEnter,
6081 _Jv_JNI_MonitorExit,
6085 /* new JNI 1.2 functions */
6087 _Jv_JNI_GetStringRegion,
6088 _Jv_JNI_GetStringUTFRegion,
6090 _Jv_JNI_GetPrimitiveArrayCritical,
6091 _Jv_JNI_ReleasePrimitiveArrayCritical,
6093 _Jv_JNI_GetStringCritical,
6094 _Jv_JNI_ReleaseStringCritical,
6096 _Jv_JNI_NewWeakGlobalRef,
6097 _Jv_JNI_DeleteWeakGlobalRef,
6099 _Jv_JNI_ExceptionCheck,
6101 /* new JNI 1.4 functions */
6103 _Jv_JNI_NewDirectByteBuffer,
6104 _Jv_JNI_GetDirectBufferAddress,
6105 _Jv_JNI_GetDirectBufferCapacity
6109 /* Invocation API Functions ***************************************************/
6111 /* JNI_GetDefaultJavaVMInitArgs ************************************************
6113 Returns a default configuration for the Java VM.
6115 *******************************************************************************/
6117 jint JNI_GetDefaultJavaVMInitArgs(void *vm_args)
6119 JavaVMInitArgs *_vm_args;
6121 _vm_args = (JavaVMInitArgs *) vm_args;
6123 /* GNU classpath currently supports JNI 1.2 */
6125 switch (_vm_args->version) {
6126 case JNI_VERSION_1_1:
6127 _vm_args->version = JNI_VERSION_1_1;
6130 case JNI_VERSION_1_2:
6131 case JNI_VERSION_1_4:
6132 _vm_args->ignoreUnrecognized = JNI_FALSE;
6133 _vm_args->options = NULL;
6134 _vm_args->nOptions = 0;
6145 /* JNI_GetCreatedJavaVMs *******************************************************
6147 Returns all Java VMs that have been created. Pointers to VMs are written in
6148 the buffer vmBuf in the order they are created. At most bufLen number of
6149 entries will be written. The total number of created VMs is returned in
6152 *******************************************************************************/
6154 jint JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs)
6156 log_text("JNI_GetCreatedJavaVMs: IMPLEMENT ME!!!");
6162 /* JNI_CreateJavaVM ************************************************************
6164 Loads and initializes a Java VM. The current thread becomes the main thread.
6165 Sets the env argument to the JNI interface pointer of the main thread.
6167 *******************************************************************************/
6169 jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args)
6171 /* actually create the JVM */
6173 if (!vm_createjvm(p_vm, p_env, vm_args))
6181 * These are local overrides for various environment variables in Emacs.
6182 * Please do not remove this and leave it at the end of the file, where
6183 * Emacs will automagically detect them.
6184 * ---------------------------------------------------------------------
6187 * indent-tabs-mode: t
6191 * vim:noexpandtab:sw=4:ts=4: