1 /* jni.c - implementation of the Java Native Interface functions
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser,
5 M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck,
6 P. Tomsich, J. Wenninger, M. Platter
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., 59 Temple Place - Suite 330, Boston, MA
25 Contact: cacao@complang.tuwien.ac.at
29 Changes: Joseph Wenninger, Martin Platter
31 $Id: jni.c 1384 2004-08-02 11:41:26Z motse $
37 #include "exceptions.h"
46 #include "statistics.h"
47 #include "threads/thread.h"
48 #include "toolbox/logging.h"
49 #include "toolbox/memory.h"
50 #include "nat/java_lang_Byte.h"
51 #include "nat/java_lang_Character.h"
52 #include "nat/java_lang_Short.h"
53 #include "nat/java_lang_Integer.h"
54 #include "nat/java_lang_Boolean.h"
55 #include "nat/java_lang_Long.h"
56 #include "nat/java_lang_Float.h"
57 #include "nat/java_lang_Double.h"
58 #include "nat/java_lang_Throwable.h"
61 #define JNI_VERSION 0x00010002
64 #define PTR_TO_ITEM(ptr) ((u8)(size_t)(ptr))
66 static utf* utf_char = 0;
67 static utf* utf_bool = 0;
68 static utf* utf_byte =0;
69 static utf* utf_short = 0;
70 static utf* utf_int = 0;
71 static utf* utf_long = 0;
72 static utf* utf_float = 0;
73 static utf* utf_double = 0;
76 /********************* accessing instance-fields **********************************/
78 #define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
79 #define getField(obj,typ,var) *((typ*) ((long int) obj + (long int) var->offset))
80 #define setfield_critical(clazz,obj,name,sig,jdatatype,val) setField(obj,jdatatype,getFieldID_critical(env,clazz,name,sig),val);
84 u4 get_parametercount(methodinfo *m)
86 utf *descr = m->descriptor; /* method-descriptor */
87 char *utf_ptr = descr->text; /* current position in utf-text */
88 char *desc_end = utf_end(descr); /* points behind utf string */
89 u4 parametercount = 0;
94 /* determine number of parameters */
95 while (*utf_ptr != ')') {
96 get_type(&utf_ptr, desc_end, true);
100 return parametercount;
105 void fill_callblock(void *obj, utf *descr, jni_callblock blk[], va_list data, char ret)
107 char *utf__ptr = descr->text; /* current position in utf-text */
108 char **utf_ptr = &utf__ptr;
109 char *desc_end = utf_end(descr); /* points behind utf string */
115 log_text("fill_callblock");
122 /* determine number of parameters */
124 blk[0].itemtype = TYPE_ADR;
125 blk[0].item = PTR_TO_ITEM(obj);
129 while (**utf_ptr != ')') {
130 if (*utf_ptr >= desc_end)
131 panic("illegal method descriptor");
133 switch (utf_nextu2(utf_ptr)) {
134 /* primitive types */
139 blk[cnt].itemtype = TYPE_INT;
140 blk[cnt].item = (u8) va_arg(data, int);
144 blk[cnt].itemtype = TYPE_INT;
145 dummy = va_arg(data, u4);
146 /*printf("fill_callblock: pos:%d, value:%d\n",cnt,dummy);*/
147 blk[cnt].item = (u8) dummy;
151 blk[cnt].itemtype = TYPE_LNG;
152 blk[cnt].item = (u8) va_arg(data, jlong);
156 blk[cnt].itemtype = TYPE_FLT;
157 *((jfloat *) (&blk[cnt].item)) = (jfloat) va_arg(data, jdouble);
161 blk[cnt].itemtype = TYPE_DBL;
162 *((jdouble *) (&blk[cnt].item)) = (jdouble) va_arg(data, jdouble);
166 panic ("V not allowed as function parameter");
170 while (utf_nextu2(utf_ptr) != ';')
171 blk[cnt].itemtype = TYPE_ADR;
172 blk[cnt].item = PTR_TO_ITEM(va_arg(data, void*));
179 /* char *start = *utf_ptr; */
181 while ((ch = utf_nextu2(utf_ptr)) == '[')
183 while (utf_nextu2(utf_ptr) != ';') {}
186 ch = utf_nextu2(utf_ptr);
187 blk[cnt].itemtype = TYPE_ADR;
188 blk[cnt].item = PTR_TO_ITEM(va_arg(data, void*));
195 /*the standard doesn't say anything about return value checking, but it appears to be usefull*/
196 c = utf_nextu2(utf_ptr);
197 c = utf_nextu2(utf_ptr);
198 /*printf("%c %c\n",ret,c);*/
200 if (!((c == 'L') || (c == '[')))
201 log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
203 log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
207 /* XXX it could be considered if we should do typechecking here in the future */
208 char fill_callblock_objA(void *obj, utf *descr, jni_callblock blk[], java_objectarray* params)
210 char *utf__ptr = descr->text; /* current position in utf-text */
211 char **utf_ptr = &utf__ptr;
212 char *desc_end = utf_end(descr); /* points behind utf string */
219 #if defined(USE_THREADS) && !defined(NATIVE_THREADS)
223 utf_char=utf_new_char("java/lang/Character");
224 utf_bool=utf_new_char("java/lang/Boolean");
225 utf_byte=utf_new_char("java/lang/Byte");
226 utf_short=utf_new_char("java/lang/Short");
227 utf_int=utf_new_char("java/lang/Integer");
228 utf_long=utf_new_char("java/lang/Long");
229 utf_float=utf_new_char("java/lang/Float");
230 utf_double=utf_new_char("java/lang/Double");
232 #if defined(USE_THREADS) && !defined(NATIVE_THREADS)
237 log_text("fill_callblock");
244 /* determine number of parameters */
246 blk[0].itemtype = TYPE_ADR;
247 blk[0].item = PTR_TO_ITEM(obj);
255 while (**utf_ptr != ')') {
256 if (*utf_ptr >= desc_end)
257 panic("illegal method descriptor");
259 /* primitive types */
260 switch (utf_nextu2(utf_ptr)) {
262 param = params->data[cnts];
264 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
267 if (param->vftbl->class->name == utf_byte) {
268 blk[cnt].itemtype = TYPE_INT;
269 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
272 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
278 param = params->data[cnts];
280 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
283 if (param->vftbl->class->name == utf_char) {
284 blk[cnt].itemtype = TYPE_INT;
285 blk[cnt].item = (u8) ((java_lang_Character *) param)->value;
288 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
294 param = params->data[cnts];
296 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
299 if (param->vftbl->class->name == utf_short) {
300 blk[cnt].itemtype = TYPE_INT;
301 blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
304 if (param->vftbl->class->name == utf_byte) {
305 blk[cnt].itemtype = TYPE_INT;
306 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
309 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
316 param = params->data[cnts];
318 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
321 if (param->vftbl->class->name == utf_bool) {
322 blk[cnt].itemtype = TYPE_INT;
323 blk[cnt].item = (u8) ((java_lang_Boolean *) param)->value;
326 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
332 /*log_text("fill_callblock_objA: param 'I'");*/
333 param = params->data[cnts];
335 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
338 if (param->vftbl->class->name == utf_int) {
339 blk[cnt].itemtype = TYPE_INT;
340 blk[cnt].item = (u8) ((java_lang_Integer *) param)->value;
341 /*printf("INT VALUE :%d\n",((struct java_lang_Integer * )param)->value);*/
343 if (param->vftbl->class->name == utf_short) {
344 blk[cnt].itemtype = TYPE_INT;
345 blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
348 if (param->vftbl->class->name == utf_byte) {
349 blk[cnt].itemtype = TYPE_INT;
350 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
353 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
361 param = params->data[cnts];
363 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
366 if (param->vftbl->class->name == utf_long) {
367 blk[cnt].itemtype = TYPE_LNG;
368 blk[cnt].item = (u8) ((java_lang_Long *) param)->value;
371 if (param->vftbl->class->name == utf_int) {
372 blk[cnt].itemtype = TYPE_LNG;
373 blk[cnt].item = (u8) ((java_lang_Integer *) param)->value;
376 if (param->vftbl->class->name == utf_short) {
377 blk[cnt].itemtype = TYPE_LNG;
378 blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
381 if (param->vftbl->class->name == utf_byte) {
382 blk[cnt].itemtype = TYPE_LNG;
383 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
385 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
395 param = params->data[cnts];
397 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
401 if (param->vftbl->class->name == utf_float) {
402 blk[cnt].itemtype = TYPE_FLT;
403 *((jfloat *) (&blk[cnt].item)) = (jfloat) ((java_lang_Float *) param)->value;
406 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
412 param = params->data[cnts];
414 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
418 if (param->vftbl->class->name == utf_double) {
419 blk[cnt].itemtype = TYPE_DBL;
420 *((jdouble *) (&blk[cnt].item)) = (jdouble) ((java_lang_Float *) param)->value;
423 if (param->vftbl->class->name == utf_float) {
424 blk[cnt].itemtype = TYPE_DBL;
425 *((jdouble *) (&blk[cnt].item)) = (jdouble) ((java_lang_Float *) param)->value;
428 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
435 panic("V not allowed as function parameter");
440 char *start = (*utf_ptr) - 1;
443 while (utf_nextu2(utf_ptr) != ';')
444 end = (*utf_ptr) + 1;
446 if (!builtin_instanceof(params->data[cnts], class_from_descriptor(start, end, 0, CLASSLOAD_LOAD))) {
447 if (params->data[cnts] != 0) {
448 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
453 blk[cnt].itemtype = TYPE_ADR;
454 blk[cnt].item = PTR_TO_ITEM(params->data[cnts]);
460 char *start = (*utf_ptr) - 1;
464 while ((ch = utf_nextu2(utf_ptr)) == '[')
466 while (utf_nextu2(utf_ptr) != ';') {}
469 end = (*utf_ptr) - 1;
470 ch = utf_nextu2(utf_ptr);
472 if (!builtin_arrayinstanceof(params->data[cnts], class_from_descriptor(start, end, 0, CLASSLOAD_LOAD)->vftbl)) {
473 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
477 blk[cnt].itemtype = TYPE_ADR;
478 blk[cnt].item = PTR_TO_ITEM(params->data[cnts]);
486 c = utf_nextu2(utf_ptr);
487 c = utf_nextu2(utf_ptr);
488 return c; /*return type needed usage of the right lowlevel methods*/
505 jmethodID get_virtual(jobject obj,jmethodID methodID) {
506 if (obj->vftbl->class==methodID->class) return methodID;
507 return class_resolvemethod (obj->vftbl->class, methodID->name, methodID->descriptor);
510 jmethodID get_nonvirtual(jclass clazz,jmethodID methodID) {
511 if (clazz==methodID->class) return methodID;
512 /*class_resolvemethod -> classfindmethod? (JOWENN)*/
513 return class_resolvemethod (clazz, methodID->name, methodID->descriptor);
518 jobject callObjectMethod (jobject obj, jmethodID methodID, va_list args)
525 log_text("JNI-Call: CallObjectMethodV");
526 utf_display(methodID->name);
527 utf_display(methodID->descriptor);
528 printf("\nParmaeter count: %d\n",argcount);
529 utf_display(obj->vftbl->class->name);
534 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
538 argcount = get_parametercount(methodID);
540 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
541 ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
542 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
546 if (obj && !builtin_instanceof(obj, methodID->class)) {
547 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
552 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
553 log_text("Too many arguments. CallObjectMethod does not support that");
557 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
559 fill_callblock(obj, methodID->descriptor, blk, args, 'O');
561 /* printf("parameter: obj: %p",blk[0].item); */
562 ret = asm_calljavafunction2(methodID,
564 (argcount + 1) * sizeof(jni_callblock),
567 MFREE(blk, jni_callblock, argcount + 1);
568 /* printf("(CallObjectMethodV)-->%p\n",ret); */
574 core function for integer class methods (bool, byte, short, integer)
575 This is basically needed for i386
577 jint callIntegerMethod(jobject obj, jmethodID methodID, char retType, va_list args)
583 /* printf("%p, %c\n",retType,methodID,retType);*/
586 log_text("JNI-Call: CallObjectMethodV");
587 utf_display(methodID->name);
588 utf_display(methodID->descriptor);
589 printf("\nParmaeter count: %d\n",argcount);
590 utf_display(obj->vftbl->class->name);
594 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
598 argcount = get_parametercount(methodID);
600 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
601 ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
602 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
606 if (obj && !builtin_instanceof(obj, methodID->class)) {
607 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
613 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
614 log_text("Too many arguments. CallIntegerMethod does not support that");
618 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
620 fill_callblock(obj, methodID->descriptor, blk, args, retType);
622 /* printf("parameter: obj: %p",blk[0].item); */
623 ret = (jint) asm_calljavafunction2(methodID,
625 (argcount + 1) * sizeof(jni_callblock),
628 MFREE(blk, jni_callblock, argcount + 1);
629 /* printf("(CallObjectMethodV)-->%p\n",ret); */
635 /*core function for long class functions*/
636 jlong callLongMethod(jobject obj, jmethodID methodID, va_list args)
643 log_text("JNI-Call: CallObjectMethodV");
644 utf_display(methodID->name);
645 utf_display(methodID->descriptor);
646 printf("\nParmaeter count: %d\n",argcount);
647 utf_display(obj->vftbl->class->name);
651 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
655 argcount = get_parametercount(methodID);
657 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
658 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
659 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
663 if (obj && !builtin_instanceof(obj,methodID->class)) {
664 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
670 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
671 log_text("Too many arguments. CallObjectMethod does not support that");
675 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
677 fill_callblock(obj, methodID->descriptor, blk, args, 'J');
679 /* printf("parameter: obj: %p",blk[0].item); */
680 ret = asm_calljavafunction2long(methodID,
682 (argcount + 1) * sizeof(jni_callblock),
685 MFREE(blk, jni_callblock, argcount + 1);
686 /* printf("(CallObjectMethodV)-->%p\n",ret); */
692 /*core function for float class methods (float,double)*/
693 jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,char retType)
695 int argcount = get_parametercount(methodID);
700 log_text("JNI-Call: CallObjectMethodV");
701 utf_display(methodID->name);
702 utf_display(methodID->descriptor);
703 printf("\nParmaeter count: %d\n",argcount);
704 utf_display(obj->vftbl->class->name);
709 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
710 log_text("Too many arguments. CallObjectMethod does not support that");
714 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
716 fill_callblock(obj, methodID->descriptor, blk, args, retType);
718 /* printf("parameter: obj: %p",blk[0].item); */
719 ret = asm_calljavafunction2double(methodID,
721 (argcount + 1) * sizeof(jni_callblock),
724 MFREE(blk, jni_callblock, argcount + 1);
725 /* printf("(CallObjectMethodV)-->%p\n",ret); */
731 /*************************** function: jclass_findfield ****************************
733 searches for field with specified name and type in a 'classinfo'-structur
734 if no such field is found NULL is returned
736 ************************************************************************************/
738 fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
741 /* printf(" FieldCount: %d\n",c->fieldscount);
742 utf_display(c->name); */
743 for (i = 0; i < c->fieldscount; i++) {
744 /* utf_display(c->fields[i].name);
746 utf_display(c->fields[i].descriptor);
748 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
749 return &(c->fields[i]);
752 if (c->super) return jclass_findfield(c->super,name,desc);
757 /********************* returns version of native method interface *****************/
759 jint GetVersion (JNIEnv* env)
765 /****************** loads a class from a buffer of raw class data *****************/
767 jclass DefineClass(JNIEnv* env, const char *name, jobject loader, const jbyte *buf, jsize len)
774 #if defined(USE_THREADS)
775 #if defined(NATIVE_THREADS)
785 starttime = getcputime();
787 clazz = class_new(utf_new_char((char *) name));
789 /* build a classbuffer with the given data */
790 cb = NEW(classbuffer);
793 cb->data = (u1 *) buf;
794 cb->pos = cb->data - 1;
796 class_load_intern(cb);
799 FREE(cb, classbuffer);
802 if (getloadingtime) {
803 stoptime = getcputime();
804 loadingtime += (stoptime - starttime);
807 #if defined(USE_THREADS)
808 #if defined(NATIVE_THREADS)
819 /* XXX link the class here? */
826 clazz->classloader = loader;
832 /*************** loads locally defined class with the specified name **************/
834 jclass FindClass(JNIEnv* env, const char *name)
838 c = class_new(utf_new_char_classname((char *) name));
854 /***********************************************************************************
856 converts java.lang.reflect.Method or
857 java.lang.reflect.Constructor object to a method ID
859 **********************************************************************************/
861 jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
863 /* log_text("JNI-Call: FromReflectedMethod"); */
869 /*************** return superclass of the class represented by sub ****************/
871 jclass GetSuperclass(JNIEnv* env, jclass sub)
875 c = ((classinfo*) sub)->super;
879 use_class_as_object(c);
885 /*********************** check whether sub can be cast to sup ********************/
887 jboolean IsAssignableForm(JNIEnv* env, jclass sub, jclass sup)
889 return builtin_isanysubclass(sub, sup);
893 /***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
895 jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
897 /* log_text("JNI-Call: ToReflectedField"); */
903 /***************** throw java.lang.Throwable object ******************************/
905 jint Throw(JNIEnv* env, jthrowable obj)
907 *exceptionptr = (java_objectheader*) obj;
913 /*******************************************************************************
915 create exception object from the class clazz with the
916 specified message and cause it to be thrown
918 *******************************************************************************/
920 jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
922 java_lang_Throwable *o;
924 /* instantiate exception object */
925 o = (java_lang_Throwable *) native_new_and_init((classinfo*) clazz);
929 o->detailMessage = (java_lang_String *) javastring_new_char((char *) msg);
931 *exceptionptr = (java_objectheader *) o;
937 /************************* check if exception occured *****************************/
939 jthrowable ExceptionOccurred (JNIEnv* env)
941 return (jthrowable) *exceptionptr;
944 /********** print exception and a backtrace of the stack (for debugging) **********/
946 void ExceptionDescribe (JNIEnv* env)
948 utf_display((*exceptionptr)->vftbl->class->name);
954 /******************* clear any exception currently being thrown *******************/
956 void ExceptionClear (JNIEnv* env)
958 *exceptionptr = NULL;
962 /********** raises a fatal error and does not expect the VM to recover ************/
964 void FatalError (JNIEnv* env, const char *msg)
969 /******************* creates a new local reference frame **************************/
971 jint PushLocalFrame(JNIEnv* env, jint capacity)
978 /**************** Pops off the current local reference frame **********************/
980 jobject PopLocalFrame(JNIEnv* env, jobject result)
988 /** Creates a new global reference to the object referred to by the obj argument **/
990 jobject NewGlobalRef(JNIEnv* env, jobject lobj)
995 /************* Deletes the global reference pointed to by globalRef **************/
997 void DeleteGlobalRef (JNIEnv* env, jobject gref)
1003 /*************** Deletes the local reference pointed to by localRef ***************/
1005 void DeleteLocalRef (JNIEnv* env, jobject localRef)
1010 /********** Tests whether two references refer to the same Java object ************/
1012 jboolean IsSameObject (JNIEnv* env, jobject obj1, jobject obj2)
1014 return (obj1==obj2);
1017 /***** Creates a new local reference that refers to the same object as ref *******/
1019 jobject NewLocalRef (JNIEnv* env, jobject ref)
1024 /***********************************************************************************
1026 Ensures that at least a given number of local references can
1027 be created in the current thread
1029 **********************************************************************************/
1031 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
1033 return 0; /* return 0 on success */
1037 /********* Allocates a new Java object without invoking a constructor *************/
1039 jobject AllocObject (JNIEnv* env, jclass clazz)
1041 java_objectheader *o = builtin_new(clazz);
1046 /***********************************************************************************
1048 Constructs a new Java object
1049 arguments that are to be passed to the constructor are placed after methodID
1051 ***********************************************************************************/
1053 jobject NewObject (JNIEnv* env, jclass clazz, jmethodID methodID, ...)
1055 java_objectheader *o;
1057 int argcount=get_parametercount(methodID);
1061 /* log_text("JNI-Call: NewObject"); */
1064 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
1065 log_text("Too many arguments. NewObject does not support that");
1070 o = builtin_new (clazz); /* create object */
1072 if (!o) return NULL;
1074 va_start(vaargs,methodID);
1075 for (i=0;i<argcount;i++) {
1076 args[i]=va_arg(vaargs,void*);
1079 asm_calljavafunction(methodID,o,args[0],args[1],args[2]);
1085 /***********************************************************************************
1087 Constructs a new Java object
1088 arguments that are to be passed to the constructor are placed in va_list args
1090 ***********************************************************************************/
1092 jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
1094 /* log_text("JNI-Call: NewObjectV"); */
1100 /***********************************************************************************
1102 Constructs a new Java object
1103 arguments that are to be passed to the constructor are placed in
1104 args array of jvalues
1106 ***********************************************************************************/
1108 jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
1110 /* log_text("JNI-Call: NewObjectA"); */
1116 /************************ returns the class of an object **************************/
1118 jclass GetObjectClass(JNIEnv* env, jobject obj)
1120 classinfo *c = obj->vftbl->class;
1122 use_class_as_object(c);
1128 /************* tests whether an object is an instance of a class ******************/
1130 jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz)
1132 return builtin_instanceof(obj,clazz);
1136 /***************** converts a java.lang.reflect.Field to a field ID ***************/
1138 jfieldID FromReflectedField(JNIEnv* env, jobject field)
1140 log_text("JNI-Call: FromReflectedField");
1146 /**********************************************************************************
1148 converts a method ID to a java.lang.reflect.Method or
1149 java.lang.reflect.Constructor object
1151 **********************************************************************************/
1153 jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
1155 log_text("JNI-Call: ToReflectedMethod");
1161 /**************** returns the method ID for an instance method ********************/
1163 jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, const char *sig)
1167 m = class_resolvemethod (
1169 utf_new_char ((char*) name),
1170 utf_new_char ((char*) sig)
1173 if (!m) *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1174 else if (m->flags & ACC_STATIC) {
1176 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1182 /******************** JNI-functions for calling instance methods ******************/
1184 jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1189 /* log_text("JNI-Call: CallObjectMethod");*/
1191 va_start(vaargs, methodID);
1192 ret = callObjectMethod(obj, methodID, vaargs);
1199 jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1201 return callObjectMethod(obj,methodID,args);
1205 jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1207 log_text("JNI-Call: CallObjectMethodA");
1215 jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1220 /* log_text("JNI-Call: CallBooleanMethod");*/
1222 va_start(vaargs,methodID);
1223 ret = (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',vaargs);
1229 jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1231 return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',args);
1235 jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1237 log_text("JNI-Call: CallBooleanMethodA");
1242 jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1247 /* log_text("JNI-Call: CallVyteMethod");*/
1249 va_start(vaargs,methodID);
1250 ret = callIntegerMethod(obj,get_virtual(obj,methodID),'B',vaargs);
1256 jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1258 /* log_text("JNI-Call: CallByteMethodV");*/
1259 return callIntegerMethod(obj,methodID,'B',args);
1263 jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1265 log_text("JNI-Call: CallByteMethodA");
1271 jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1276 /* log_text("JNI-Call: CallCharMethod");*/
1278 va_start(vaargs,methodID);
1279 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'C', vaargs);
1286 jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1288 /* log_text("JNI-Call: CallCharMethodV");*/
1289 return callIntegerMethod(obj,get_virtual(obj,methodID),'C',args);
1293 jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1295 log_text("JNI-Call: CallCharMethodA");
1301 jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1306 /* log_text("JNI-Call: CallShortMethod");*/
1308 va_start(vaargs, methodID);
1309 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'S', vaargs);
1316 jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1318 return callIntegerMethod(obj, get_virtual(obj, methodID), 'S', args);
1322 jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1324 log_text("JNI-Call: CallShortMethodA");
1331 jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1336 va_start(vaargs,methodID);
1337 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'I', vaargs);
1344 jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1346 return callIntegerMethod(obj, get_virtual(obj, methodID), 'I', args);
1350 jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1352 log_text("JNI-Call: CallIntMethodA");
1359 jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1364 va_start(vaargs,methodID);
1365 ret = callLongMethod(obj,get_virtual(obj, methodID),vaargs);
1372 jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1374 return callLongMethod(obj,get_virtual(obj, methodID),args);
1378 jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1380 log_text("JNI-Call: CallLongMethodA");
1387 jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1392 /* log_text("JNI-Call: CallFloatMethod");*/
1394 va_start(vaargs,methodID);
1395 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'F');
1402 jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1404 log_text("JNI-Call: CallFloatMethodV");
1405 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'F');
1409 jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1411 log_text("JNI-Call: CallFloatMethodA");
1418 jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1423 /* log_text("JNI-Call: CallDoubleMethod");*/
1425 va_start(vaargs,methodID);
1426 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'D');
1433 jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1435 log_text("JNI-Call: CallDoubleMethodV");
1436 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'D');
1440 jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1442 log_text("JNI-Call: CallDoubleMethodA");
1448 void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1452 /* log_text("JNI-Call: CallVoidMethod");*/
1454 va_start(vaargs,methodID);
1455 (void) callIntegerMethod(obj, get_virtual(obj, methodID), 'V', vaargs);
1460 void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1462 log_text("JNI-Call: CallVoidMethodV");
1463 (void)callIntegerMethod(obj,get_virtual(obj,methodID),'V',args);
1467 void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1469 log_text("JNI-Call: CallVoidMethodA");
1474 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1476 log_text("JNI-Call: CallNonvirtualObjectMethod");
1482 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1484 log_text("JNI-Call: CallNonvirtualObjectMethodV");
1490 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1492 log_text("JNI-Call: CallNonvirtualObjectMethodA");
1499 jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1504 /* log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
1506 va_start(vaargs,methodID);
1507 ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',vaargs);
1514 jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1516 /* log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
1517 return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',args);
1521 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1523 log_text("JNI-Call: CallNonvirtualBooleanMethodA");
1530 jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1535 /* log_text("JNI-Call: CallNonvirutalByteMethod");*/
1537 va_start(vaargs,methodID);
1538 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',vaargs);
1544 jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1546 /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
1547 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',args);
1552 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1554 log_text("JNI-Call: CallNonvirtualByteMethodA");
1561 jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1566 /* log_text("JNI-Call: CallNonVirtualCharMethod");*/
1568 va_start(vaargs,methodID);
1569 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',vaargs);
1575 jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1577 /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
1578 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',args);
1582 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1584 log_text("JNI-Call: CallNonvirtualCharMethodA");
1591 jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1596 /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
1598 va_start(vaargs,methodID);
1599 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',vaargs);
1605 jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1607 /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
1608 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',args);
1612 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1614 log_text("JNI-Call: CallNonvirtualShortMethodA");
1621 jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1627 /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
1629 va_start(vaargs,methodID);
1630 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',vaargs);
1636 jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1638 /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
1639 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',args);
1643 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1645 log_text("JNI-Call: CallNonvirtualIntMethodA");
1652 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1654 log_text("JNI-Call: CallNonvirtualLongMethod");
1660 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1662 log_text("JNI-Call: CallNonvirtualLongMethodV");
1668 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1670 log_text("JNI-Call: CallNonvirtualLongMethodA");
1677 jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1682 /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
1685 va_start(vaargs,methodID);
1686 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'F');
1693 jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1695 log_text("JNI-Call: CallNonvirtualFloatMethodV");
1696 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'F');
1700 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1702 log_text("JNI-Call: CallNonvirtualFloatMethodA");
1709 jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1713 log_text("JNI-Call: CallNonvirtualDoubleMethod");
1715 va_start(vaargs,methodID);
1716 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'D');
1723 jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1725 /* log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
1726 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'D');
1730 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1732 log_text("JNI-Call: CallNonvirtualDoubleMethodA");
1739 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1743 /* log_text("JNI-Call: CallNonvirtualVoidMethod");*/
1745 va_start(vaargs,methodID);
1746 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',vaargs);
1752 void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1754 /* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
1756 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',args);
1761 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1763 log_text("JNI-Call: CallNonvirtualVoidMethodA");
1766 /************************* JNI-functions for accessing fields ************************/
1768 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1772 /* log_text("========================= searching for:");
1775 f = jclass_findfield(clazz,
1776 utf_new_char ((char*) name),
1777 utf_new_char ((char*) sig)
1781 /* utf_display(clazz->name);
1784 *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
1789 /*************************** retrieve fieldid, abort on error ************************/
1791 jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig)
1793 jfieldID id = GetFieldID(env, clazz, name, sig);
1797 utf_display(clazz->name);
1798 log_text("\nfield:");
1803 panic("setfield_critical failed");
1808 jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
1810 return getField(obj,jobject,fieldID);
1813 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
1815 return getField(obj,jboolean,fieldID);
1819 jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
1821 return getField(obj,jbyte,fieldID);
1825 jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
1827 return getField(obj,jchar,fieldID);
1831 jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
1833 return getField(obj,jshort,fieldID);
1837 jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
1839 return getField(obj,jint,fieldID);
1843 jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
1845 return getField(obj,jlong,fieldID);
1849 jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
1851 return getField(obj,jfloat,fieldID);
1855 jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
1857 return getField(obj,jdouble,fieldID);
1860 void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
1862 setField(obj,jobject,fieldID,val);
1866 void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
1868 setField(obj,jboolean,fieldID,val);
1872 void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
1874 setField(obj,jbyte,fieldID,val);
1878 void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
1880 setField(obj,jchar,fieldID,val);
1884 void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
1886 setField(obj,jshort,fieldID,val);
1890 void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
1892 setField(obj,jint,fieldID,val);
1896 void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
1898 setField(obj,jlong,fieldID,val);
1902 void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
1904 setField(obj,jfloat,fieldID,val);
1908 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
1910 setField(obj,jdouble,fieldID,val);
1914 /**************** JNI-functions for calling static methods **********************/
1916 jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
1920 m = class_resolvemethod(clazz,
1921 utf_new_char((char *) name),
1922 utf_new_char((char *) sig));
1924 if (!m) *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1925 else if (!(m->flags & ACC_STATIC)) {
1927 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1934 jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1939 /* log_text("JNI-Call: CallStaticObjectMethod");*/
1941 va_start(vaargs, methodID);
1942 ret = callObjectMethod(0, methodID, vaargs);
1949 jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1951 /* log_text("JNI-Call: CallStaticObjectMethodV"); */
1953 return callObjectMethod(0,methodID,args);
1957 jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1959 log_text("JNI-Call: CallStaticObjectMethodA");
1965 jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1970 va_start(vaargs, methodID);
1971 ret = (jboolean) callIntegerMethod(0, methodID, 'Z', vaargs);
1978 jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1980 return (jboolean) callIntegerMethod(0, methodID, 'Z', args);
1984 jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1986 log_text("JNI-Call: CallStaticBooleanMethodA");
1992 jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1997 /* log_text("JNI-Call: CallStaticByteMethod");*/
1999 va_start(vaargs, methodID);
2000 ret = (jbyte) callIntegerMethod(0, methodID, 'B', vaargs);
2007 jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2009 return (jbyte) callIntegerMethod(0, methodID, 'B', args);
2013 jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2015 log_text("JNI-Call: CallStaticByteMethodA");
2021 jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2026 /* log_text("JNI-Call: CallStaticByteMethod");*/
2028 va_start(vaargs, methodID);
2029 ret = (jchar) callIntegerMethod(0, methodID, 'C', vaargs);
2036 jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2038 return (jchar) callIntegerMethod(0, methodID, 'C', args);
2042 jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2044 log_text("JNI-Call: CallStaticCharMethodA");
2051 jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2056 /* log_text("JNI-Call: CallStaticByteMethod");*/
2058 va_start(vaargs, methodID);
2059 ret = (jshort) callIntegerMethod(0, methodID, 'S', vaargs);
2066 jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2068 /*log_text("JNI-Call: CallStaticShortMethodV");*/
2069 return (jshort) callIntegerMethod(0, methodID, 'S', args);
2073 jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2075 log_text("JNI-Call: CallStaticShortMethodA");
2082 jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2087 /* log_text("JNI-Call: CallStaticIntMethod");*/
2089 va_start(vaargs, methodID);
2090 ret = callIntegerMethod(0, methodID, 'I', vaargs);
2097 jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2099 log_text("JNI-Call: CallStaticIntMethodV");
2101 return callIntegerMethod(0, methodID, 'I', args);
2105 jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2107 log_text("JNI-Call: CallStaticIntMethodA");
2114 jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2119 /* log_text("JNI-Call: CallStaticLongMethod");*/
2121 va_start(vaargs, methodID);
2122 ret = callLongMethod(0, methodID, vaargs);
2129 jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2131 log_text("JNI-Call: CallStaticLongMethodV");
2133 return callLongMethod(0,methodID,args);
2137 jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2139 log_text("JNI-Call: CallStaticLongMethodA");
2146 jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2151 /* log_text("JNI-Call: CallStaticLongMethod");*/
2153 va_start(vaargs, methodID);
2154 ret = callFloatMethod(0, methodID, vaargs, 'F');
2161 jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2164 return callFloatMethod(0, methodID, args, 'F');
2169 jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2171 log_text("JNI-Call: CallStaticFloatMethodA");
2178 jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2183 /* log_text("JNI-Call: CallStaticDoubleMethod");*/
2185 va_start(vaargs,methodID);
2186 ret = callFloatMethod(0, methodID, vaargs, 'D');
2193 jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2195 log_text("JNI-Call: CallStaticDoubleMethodV");
2197 return callFloatMethod(0, methodID, args, 'D');
2201 jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2203 log_text("JNI-Call: CallStaticDoubleMethodA");
2209 void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
2213 /* log_text("JNI-Call: CallStaticVoidMethod");*/
2215 va_start(vaargs, methodID);
2216 (void) callIntegerMethod(0, methodID, 'V', vaargs);
2221 void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
2223 log_text("JNI-Call: CallStaticVoidMethodV");
2224 (void)callIntegerMethod(0, methodID, 'V', args);
2228 void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
2230 log_text("JNI-Call: CallStaticVoidMethodA");
2234 /****************** JNI-functions for accessing static fields ********************/
2236 jfieldID GetStaticFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
2240 f = jclass_findfield(clazz,
2241 utf_new_char ((char*) name),
2242 utf_new_char ((char*) sig)
2245 if (!f) *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
2251 jobject GetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2254 return fieldID->value.a;
2258 jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2261 return fieldID->value.i;
2265 jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2268 return fieldID->value.i;
2272 jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2275 return fieldID->value.i;
2279 jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2282 return fieldID->value.i;
2286 jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2289 return fieldID->value.i;
2293 jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2296 return fieldID->value.l;
2300 jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2303 return fieldID->value.f;
2307 jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2310 return fieldID->value.d;
2315 void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
2318 fieldID->value.a = value;
2322 void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
2325 fieldID->value.i = value;
2329 void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
2332 fieldID->value.i = value;
2336 void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
2339 fieldID->value.i = value;
2343 void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
2346 fieldID->value.i = value;
2350 void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
2353 fieldID->value.i = value;
2357 void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
2360 fieldID->value.l = value;
2364 void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
2367 fieldID->value.f = value;
2371 void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
2374 fieldID->value.d = value;
2378 /***** create new java.lang.String object from an array of Unicode characters ****/
2380 jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
2383 java_lang_String *s;
2386 s = (java_lang_String*) builtin_new (class_java_lang_String);
2387 a = builtin_newarray_char (len);
2389 /* javastring or characterarray could not be created */
2390 if ( (!a) || (!s) ) return NULL;
2393 for (i=0; i<len; i++) a->data[i] = buf[i];
2402 static char emptyString[]="";
2403 static jchar emptyStringJ[]={0,0};
2405 /******************* returns the length of a Java string ***************************/
2407 jsize GetStringLength (JNIEnv *env, jstring str)
2409 return ((java_lang_String*) str)->count;
2413 /******************** convertes javastring to u2-array ****************************/
2415 u2 *javastring_tou2 (jstring so)
2417 java_lang_String *s = (java_lang_String*) so;
2422 if (!s) return NULL;
2425 if (!a) return NULL;
2427 /* allocate memory */
2428 stringbuffer = MNEW( u2 , s->count + 1 );
2431 for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
2433 /* terminate string */
2434 stringbuffer[i] = '\0';
2436 return stringbuffer;
2439 /********* returns a pointer to an array of Unicode characters of the string *******/
2441 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
2443 jchar *jc=javastring_tou2(str);
2446 if (isCopy) *isCopy=JNI_TRUE;
2449 if (isCopy) *isCopy=JNI_TRUE;
2450 return emptyStringJ;
2453 /**************** native code no longer needs access to chars **********************/
2455 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
2457 if (chars==emptyStringJ) return;
2458 MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count+1);
2461 /************ create new java.lang.String object from utf8-characterarray **********/
2463 jstring NewStringUTF (JNIEnv *env, const char *utf)
2465 /* log_text("NewStringUTF called");*/
2466 return (jstring) javastring_new(utf_new_char((char *) utf));
2469 /****************** returns the utf8 length in bytes of a string *******************/
2471 jsize GetStringUTFLength (JNIEnv *env, jstring string)
2473 java_lang_String *s = (java_lang_String*) string;
2475 return (jsize) u2_utflength(s->value->data, s->count);
2479 /************ converts a Javastring to an array of UTF-8 characters ****************/
2481 const char* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
2485 u = javastring_toutf((java_lang_String *) string, false);
2488 *isCopy = JNI_FALSE;
2498 /***************** native code no longer needs access to utf ***********************/
2500 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
2502 /*we don't release utf chars right now, perhaps that should be done later. Since there is always one reference
2503 the garbage collector will never get them*/
2505 log_text("JNI-Call: ReleaseStringUTFChars");
2506 utf_display(utf_new_char(chars));
2510 /************************** array operations ***************************************/
2512 jsize GetArrayLength(JNIEnv *env, jarray array)
2518 jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
2520 java_objectarray *j;
2523 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2527 j = builtin_anewarray(len, clazz);
2533 jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
2537 if (index < array->header.size)
2538 j = array->data[index];
2540 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2546 void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
2548 if (index >= array->header.size)
2549 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2552 /* check if the class of value is a subclass of the element class of the array */
2553 if (!builtin_canstore((java_objectarray *) array, (java_objectheader *) val))
2554 *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
2557 array->data[index] = val;
2563 jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
2565 java_booleanarray *j;
2568 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2572 j = builtin_newarray_boolean(len);
2578 jbyteArray NewByteArray(JNIEnv *env, jsize len)
2583 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2587 j = builtin_newarray_byte(len);
2593 jcharArray NewCharArray(JNIEnv *env, jsize len)
2598 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2602 j = builtin_newarray_char(len);
2608 jshortArray NewShortArray(JNIEnv *env, jsize len)
2613 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2617 j = builtin_newarray_short(len);
2623 jintArray NewIntArray(JNIEnv *env, jsize len)
2628 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2632 j = builtin_newarray_int(len);
2638 jlongArray NewLongArray(JNIEnv *env, jsize len)
2643 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2647 j = builtin_newarray_long(len);
2653 jfloatArray NewFloatArray(JNIEnv *env, jsize len)
2658 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2662 j = builtin_newarray_float(len);
2668 jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
2670 java_doublearray *j;
2673 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2677 j = builtin_newarray_double(len);
2683 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
2685 if (isCopy) *isCopy = JNI_FALSE;
2690 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
2692 if (isCopy) *isCopy = JNI_FALSE;
2697 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
2699 if (isCopy) *isCopy = JNI_FALSE;
2704 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
2706 if (isCopy) *isCopy = JNI_FALSE;
2711 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
2713 if (isCopy) *isCopy = JNI_FALSE;
2718 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
2720 if (isCopy) *isCopy = JNI_FALSE;
2725 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
2727 if (isCopy) *isCopy = JNI_FALSE;
2732 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
2734 if (isCopy) *isCopy = JNI_FALSE;
2740 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
2746 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
2752 void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
2758 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
2764 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
2770 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
2776 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
2782 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
2788 void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2790 if (start < 0 || len < 0 || start + len > array->header.size)
2791 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2794 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2798 void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2800 if (start < 0 || len < 0 || start + len > array->header.size)
2801 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2804 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2808 void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2810 if (start < 0 || len < 0 || start + len > array->header.size)
2811 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2814 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2818 void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2820 if (start < 0 || len < 0 || start + len > array->header.size)
2821 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2824 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2828 void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2830 if (start < 0 || len < 0 || start + len > array->header.size)
2831 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2834 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2838 void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2840 if (start < 0 || len < 0 || start + len > array->header.size)
2841 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2844 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2848 void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2850 if (start < 0 || len < 0 || start + len > array->header.size)
2851 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2854 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2858 void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2860 if (start < 0 || len < 0 || start+len>array->header.size)
2861 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2864 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2868 void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2870 if (start < 0 || len < 0 || start + len > array->header.size)
2871 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2874 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2878 void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2880 if (start < 0 || len < 0 || start + len > array->header.size)
2881 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2884 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2888 void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2890 if (start < 0 || len < 0 || start + len > array->header.size)
2891 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2894 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2899 void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2901 if (start < 0 || len < 0 || start + len > array->header.size)
2902 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2905 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2909 void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2911 if (start < 0 || len < 0 || start + len > array->header.size)
2912 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2915 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2920 void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2922 if (start < 0 || len < 0 || start + len > array->header.size)
2923 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2926 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2931 void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2933 if (start < 0 || len < 0 || start + len > array->header.size)
2934 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2937 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2942 void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2944 if (start < 0 || len < 0 || start + len > array->header.size)
2945 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2948 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2952 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
2954 log_text("JNI-Call: RegisterNatives");
2959 jint UnregisterNatives (JNIEnv* env, jclass clazz)
2961 log_text("JNI-Call: UnregisterNatives");
2965 /******************************* monitor operations ********************************/
2967 jint MonitorEnter (JNIEnv* env, jobject obj)
2969 builtin_monitorenter(obj);
2974 jint MonitorExit (JNIEnv* env, jobject obj)
2976 builtin_monitorexit(obj);
2981 /************************************* JavaVM interface ****************************/
2983 #error CPP mode not supported yet
2985 jint GetJavaVM (JNIEnv* env, JavaVM **vm)
2987 log_text("JNI-Call: GetJavaVM");
2991 #endif /*__cplusplus*/
2993 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
2995 log_text("JNI-Call: GetStringRegion");
2999 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
3001 log_text("JNI-Call: GetStringUTFRegion");
3005 /************** obtain direct pointer to array elements ***********************/
3007 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
3009 java_objectheader *s = (java_objectheader*) array;
3010 arraydescriptor *desc = s->vftbl->arraydesc;
3012 if (!desc) return NULL;
3014 return ((u1*)s) + desc->dataoffset;
3018 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
3020 log_text("JNI-Call: ReleasePrimitiveArrayCritical");
3025 /**** returns a pointer to an array of Unicode characters of the string *******/
3027 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
3029 log_text("JNI-Call: GetStringCritical");
3031 return GetStringChars(env,string,isCopy);
3034 /*********** native code no longer needs access to chars **********************/
3036 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
3038 log_text("JNI-Call: ReleaseStringCritical");
3040 ReleaseStringChars(env,string,cstring);
3044 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
3046 log_text("JNI-Call: NewWeakGlobalRef");
3052 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
3054 log_text("JNI-Call: DeleteWeakGlobalRef");
3060 /******************************* check for pending exception ***********************/
3063 jboolean ExceptionCheck(JNIEnv* env)
3065 log_text("JNI-Call: ExceptionCheck");
3067 return *exceptionptr ? JNI_TRUE : JNI_FALSE;
3075 jint DestroyJavaVM(JavaVM *vm)
3077 log_text("DestroyJavaVM called");
3083 jint AttachCurrentThread(JavaVM *vm, void **par1, void *par2)
3085 log_text("AttachCurrentThread called");
3091 jint DetachCurrentThread(JavaVM *vm)
3093 log_text("DetachCurrentThread called");
3099 jint GetEnv(JavaVM *vm, void **environment, jint jniversion)
3101 *environment = &env;
3107 jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
3109 log_text("AttachCurrentThreadAsDaemon called");
3115 /********************************* JNI invocation table ******************************/
3117 struct _JavaVM javaVMTable={
3122 &AttachCurrentThread,
3123 &DetachCurrentThread,
3125 &AttachCurrentThreadAsDaemon
3128 JavaVM javaVM = &javaVMTable;
3131 /********************************* JNI function table ******************************/
3133 struct JNI_Table envTable = {
3141 &FromReflectedMethod,
3142 &FromReflectedField,
3160 &EnsureLocalCapacity,
3172 &CallBooleanMethodV,
3173 &CallBooleanMethodA,
3198 &CallNonvirtualObjectMethod,
3199 &CallNonvirtualObjectMethodV,
3200 &CallNonvirtualObjectMethodA,
3201 &CallNonvirtualBooleanMethod,
3202 &CallNonvirtualBooleanMethodV,
3203 &CallNonvirtualBooleanMethodA,
3204 &CallNonvirtualByteMethod,
3205 &CallNonvirtualByteMethodV,
3206 &CallNonvirtualByteMethodA,
3207 &CallNonvirtualCharMethod,
3208 &CallNonvirtualCharMethodV,
3209 &CallNonvirtualCharMethodA,
3210 &CallNonvirtualShortMethod,
3211 &CallNonvirtualShortMethodV,
3212 &CallNonvirtualShortMethodA,
3213 &CallNonvirtualIntMethod,
3214 &CallNonvirtualIntMethodV,
3215 &CallNonvirtualIntMethodA,
3216 &CallNonvirtualLongMethod,
3217 &CallNonvirtualLongMethodV,
3218 &CallNonvirtualLongMethodA,
3219 &CallNonvirtualFloatMethod,
3220 &CallNonvirtualFloatMethodV,
3221 &CallNonvirtualFloatMethodA,
3222 &CallNonvirtualDoubleMethod,
3223 &CallNonvirtualDoubleMethodV,
3224 &CallNonvirtualDoubleMethodA,
3225 &CallNonvirtualVoidMethod,
3226 &CallNonvirtualVoidMethodV,
3227 &CallNonvirtualVoidMethodA,
3248 &CallStaticObjectMethod,
3249 &CallStaticObjectMethodV,
3250 &CallStaticObjectMethodA,
3251 &CallStaticBooleanMethod,
3252 &CallStaticBooleanMethodV,
3253 &CallStaticBooleanMethodA,
3254 &CallStaticByteMethod,
3255 &CallStaticByteMethodV,
3256 &CallStaticByteMethodA,
3257 &CallStaticCharMethod,
3258 &CallStaticCharMethodV,
3259 &CallStaticCharMethodA,
3260 &CallStaticShortMethod,
3261 &CallStaticShortMethodV,
3262 &CallStaticShortMethodA,
3263 &CallStaticIntMethod,
3264 &CallStaticIntMethodV,
3265 &CallStaticIntMethodA,
3266 &CallStaticLongMethod,
3267 &CallStaticLongMethodV,
3268 &CallStaticLongMethodA,
3269 &CallStaticFloatMethod,
3270 &CallStaticFloatMethodV,
3271 &CallStaticFloatMethodA,
3272 &CallStaticDoubleMethod,
3273 &CallStaticDoubleMethodV,
3274 &CallStaticDoubleMethodA,
3275 &CallStaticVoidMethod,
3276 &CallStaticVoidMethodV,
3277 &CallStaticVoidMethodA,
3279 &GetStaticObjectField,
3280 &GetStaticBooleanField,
3281 &GetStaticByteField,
3282 &GetStaticCharField,
3283 &GetStaticShortField,
3285 &GetStaticLongField,
3286 &GetStaticFloatField,
3287 &GetStaticDoubleField,
3288 &SetStaticObjectField,
3289 &SetStaticBooleanField,
3290 &SetStaticByteField,
3291 &SetStaticCharField,
3292 &SetStaticShortField,
3294 &SetStaticLongField,
3295 &SetStaticFloatField,
3296 &SetStaticDoubleField,
3300 &ReleaseStringChars,
3302 &GetStringUTFLength,
3304 &ReleaseStringUTFChars,
3307 &GetObjectArrayElement,
3308 &SetObjectArrayElement,
3317 &GetBooleanArrayElements,
3318 &GetByteArrayElements,
3319 &GetCharArrayElements,
3320 &GetShortArrayElements,
3321 &GetIntArrayElements,
3322 &GetLongArrayElements,
3323 &GetFloatArrayElements,
3324 &GetDoubleArrayElements,
3325 &ReleaseBooleanArrayElements,
3326 &ReleaseByteArrayElements,
3327 &ReleaseCharArrayElements,
3328 &ReleaseShortArrayElements,
3329 &ReleaseIntArrayElements,
3330 &ReleaseLongArrayElements,
3331 &ReleaseFloatArrayElements,
3332 &ReleaseDoubleArrayElements,
3333 &GetBooleanArrayRegion,
3334 &GetByteArrayRegion,
3335 &GetCharArrayRegion,
3336 &GetShortArrayRegion,
3338 &GetLongArrayRegion,
3339 &GetFloatArrayRegion,
3340 &GetDoubleArrayRegion,
3341 &SetBooleanArrayRegion,
3342 &SetByteArrayRegion,
3343 &SetCharArrayRegion,
3344 &SetShortArrayRegion,
3346 &SetLongArrayRegion,
3347 &SetFloatArrayRegion,
3348 &SetDoubleArrayRegion,
3355 &GetStringUTFRegion,
3356 &GetPrimitiveArrayCritical,
3357 &ReleasePrimitiveArrayCritical,
3359 &ReleaseStringCritical,
3361 &DeleteWeakGlobalRef,
3365 JNIEnv env = &envTable;
3368 jobject *jni_method_invokeNativeHelper(JNIEnv *env, struct methodinfo *methodID, jobject obj, java_objectarray *params)
3375 if (methodID == 0) {
3376 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
3380 argcount = get_parametercount(methodID);
3382 if (obj && (!builtin_instanceof((java_objectheader *) obj, methodID->class))) {
3383 *exceptionptr = new_exception_message(string_java_lang_IllegalArgumentException,
3384 "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
3391 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
3392 log_text("Too many arguments. invokeNativeHelper does not support that");
3396 if (((!params) && (argcount != 0)) || (params && (params->header.size != argcount))) {
3397 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
3402 if (!(methodID->flags & ACC_STATIC) && (!obj)) {
3403 *exceptionptr = new_exception_message(string_java_lang_NullPointerException,
3404 "Static mismatch in Java_java_lang_reflect_Method_invokeNative");
3408 if ((methodID->flags & ACC_STATIC) && (obj)) obj = 0;
3410 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
3412 retT = fill_callblock_objA(obj, methodID->descriptor, blk, params);
3416 (void) asm_calljavafunction2(methodID,
3418 (argcount + 1) * sizeof(jni_callblock),
3420 retVal = NULL; /*native_new_and_init(loader_load(utf_new_char("java/lang/Void")));*/
3425 intVal = (s4) asm_calljavafunction2(methodID,
3427 (argcount + 1) * sizeof(jni_callblock),
3429 retVal = builtin_new(class_new(utf_new_char("java/lang/Integer")));
3432 class_resolvemethod(retVal->vftbl->class,
3433 utf_new_char("<init>"),
3434 utf_new_char("(I)V")),
3441 intVal = (s4) asm_calljavafunction2(methodID,
3443 (argcount + 1) * sizeof(jni_callblock),
3445 retVal = builtin_new(class_new(utf_new_char("java/lang/Byte")));
3448 class_resolvemethod(retVal->vftbl->class,
3449 utf_new_char("<init>"),
3450 utf_new_char("(B)V")),
3457 intVal = (s4) asm_calljavafunction2(methodID,
3459 (argcount + 1) * sizeof(jni_callblock),
3461 retVal = builtin_new(class_new(utf_new_char("java/lang/Character")));
3464 class_resolvemethod(retVal->vftbl->class,
3465 utf_new_char("<init>"),
3466 utf_new_char("(C)V")),
3473 intVal = (s4) asm_calljavafunction2(methodID,
3475 (argcount + 1) * sizeof(jni_callblock),
3477 retVal = builtin_new(class_new(utf_new_char("java/lang/Short")));
3480 class_resolvemethod(retVal->vftbl->class,
3481 utf_new_char("<init>"),
3482 utf_new_char("(S)V")),
3489 intVal = (s4) asm_calljavafunction2(methodID,
3491 (argcount + 1) * sizeof(jni_callblock),
3493 retVal = builtin_new(class_new(utf_new_char("java/lang/Boolean")));
3496 class_resolvemethod(retVal->vftbl->class,
3497 utf_new_char("<init>"),
3498 utf_new_char("(Z)V")),
3505 intVal = asm_calljavafunction2long(methodID,
3507 (argcount + 1) * sizeof(jni_callblock),
3509 retVal = builtin_new(class_new(utf_new_char("java/lang/Long")));
3512 class_resolvemethod(retVal->vftbl->class,
3513 utf_new_char("<init>"),
3514 utf_new_char("(J)V")),
3521 floatVal = asm_calljavafunction2double(methodID,
3523 (argcount + 1) * sizeof(jni_callblock),
3525 retVal = builtin_new(class_new(utf_new_char("java/lang/Float")));
3528 class_resolvemethod(retVal->vftbl->class,
3529 utf_new_char("<init>"),
3530 utf_new_char("(F)V")),
3537 floatVal = asm_calljavafunction2double(methodID,
3539 (argcount + 1) * sizeof(jni_callblock),
3541 retVal = builtin_new(class_new(utf_new_char("java/lang/Double")));
3544 class_resolvemethod(retVal->vftbl->class,
3545 utf_new_char("<init>"),
3546 utf_new_char("(D)V")),
3551 case 'L': /* fall through */
3553 retVal = asm_calljavafunction2(methodID,
3555 (argcount + 1) * sizeof(jni_callblock),
3560 /* if this happens the acception has already been set by fill_callblock_objA*/
3561 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3562 return (jobject *) 0;
3565 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3567 if (*exceptionptr) {
3568 java_objectheader *exceptionToWrap = *exceptionptr;
3570 java_objectheader *ivte;
3572 *exceptionptr = NULL;
3573 ivtec = class_new(utf_new_char("java/lang/reflect/InvocationTargetException"));
3574 ivte = builtin_new(ivtec);
3575 asm_calljavafunction(class_resolvemethod(ivtec,
3576 utf_new_char("<init>"),
3577 utf_new_char("(Ljava/lang/Throwable;)V")),
3583 if (*exceptionptr != NULL)
3584 panic("jni.c: error while creating InvocationTargetException wrapper");
3586 *exceptionptr = ivte;
3589 return (jobject *) retVal;
3594 * These are local overrides for various environment variables in Emacs.
3595 * Please do not remove this and leave it at the end of the file, where
3596 * Emacs will automagically detect them.
3597 * ---------------------------------------------------------------------
3600 * indent-tabs-mode: t