1 /********************************** jni.c *****************************************
3 implementation of the Java Native Interface functions
4 which are used in the JNI function table
6 ***********************************************************************************/
14 #include "threads/thread.h"
15 #include "nat/java_lang_Byte.h"
16 #include "nat/java_lang_Character.h"
17 #include "nat/java_lang_Short.h"
18 #include "nat/java_lang_Integer.h"
19 #include "nat/java_lang_Boolean.h"
20 #include "nat/java_lang_Long.h"
21 #include "nat/java_lang_Float.h"
22 #include "nat/java_lang_Double.h"
23 #include "nat/java_lang_Throwable.h"
26 #define JNI_VERSION 0x00010002
29 static utf* utf_char=0;
30 static utf* utf_bool=0;
31 static utf* utf_byte=0;
32 static utf* utf_short=0;
33 static utf* utf_int=0;
34 static utf* utf_long=0;
35 static utf* utf_float=0;
36 static utf* utf_double=0;
38 /********************* accessing instance-fields **********************************/
40 #define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
41 #define getField(obj,typ,var) *((typ*) ((long int) obj + (long int) var->offset))
42 #define setfield_critical(clazz,obj,name,sig,jdatatype,val) setField(obj,jdatatype,getFieldID_critical(env,clazz,name,sig),val);
46 u4 get_parametercount(methodinfo *m)
48 utf *descr = m->descriptor; /* method-descriptor */
49 char *utf_ptr = descr->text; /* current position in utf-text */
50 char *desc_end = utf_end(descr); /* points behind utf string */
51 java_objectarray* result;
52 int parametercount = 0;
58 /* determine number of parameters */
59 while ( *utf_ptr != ')' ) {
60 get_type(&utf_ptr,desc_end,true);
64 return parametercount;
69 void fill_callblock(void *obj,utf *descr,jni_callblock blk[], va_list data, char ret) {
70 char *utf__ptr = descr->text; /* current position in utf-text */
71 char **utf_ptr = &utf__ptr;
72 char *desc_end = utf_end(descr); /* points behind utf string */
81 log_text("fill_callblock");
88 /* determine number of parameters */
90 blk[0].itemtype=TYPE_ADR;
91 blk[0].item=(u8)(u4)obj;
94 while ( **utf_ptr != ')' ) {
95 if (*utf_ptr>=desc_end)
96 panic("illegal method descriptor");
98 switch (utf_nextu2(utf_ptr)) {
104 blk[cnt].itemtype=TYPE_INT;
105 blk[cnt].item=(u8) va_arg(data,int);
108 blk[cnt].itemtype=TYPE_INT;
109 dummy=va_arg(data,u4);
110 /*printf("fill_callblock: pos:%d, value:%d\n",cnt,dummy);*/
111 blk[cnt].item=(u8)dummy;
116 blk[cnt].itemtype=TYPE_LNG;
117 blk[cnt].item=(u8)va_arg(data,jlong);
120 blk[cnt].itemtype=TYPE_FLT;
121 *((jfloat*)(&blk[cnt].item))=((jfloat)va_arg(data,jdouble));
125 blk[cnt].itemtype=TYPE_DBL;
126 *((jdouble*)(&blk[cnt].item))=(jdouble)va_arg(data,jdouble);
128 case 'V' : panic ("V not allowed as function parameter");
131 while (utf_nextu2(utf_ptr)!=';')
133 blk[cnt].itemtype=TYPE_ADR;
134 blk[cnt].item=(u8)(u4)va_arg(data,void*);
140 char *start = *utf_ptr;
142 while ((ch = utf_nextu2(utf_ptr))=='[')
144 while (utf_nextu2(utf_ptr)!=';') {}
147 ch=utf_nextu2(utf_ptr);
148 blk[cnt].itemtype=TYPE_ADR;
149 blk[cnt].item=(u8)(u4)va_arg(data,void*);
156 /*the standard doesn't say anything about return value checking, but it appears to be usefull*/
157 c=utf_nextu2(utf_ptr);
158 c=utf_nextu2(utf_ptr);
159 /*printf("%c %c\n",ret,c);*/
161 if (!((c=='L') || (c=='['))) log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
162 } else if (ret != c) log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
166 /* XXX it could be considered if we should do typechecking here in the future */
167 char fill_callblock_objA(void *obj, utf *descr, jni_callblock blk[], java_objectarray* params)
169 char *utf__ptr = descr->text; /* current position in utf-text */
170 char **utf_ptr = &utf__ptr;
171 char *desc_end = utf_end(descr); /* points behind utf string */
182 utf_char=utf_new_char("java/lang/Character");
183 utf_bool=utf_new_char("java/lang/Boolean");
184 utf_byte=utf_new_char("java/lang/Byte");
185 utf_short=utf_new_char("java/lang/Short");
186 utf_int=utf_new_char("java/lang/Integer");
187 utf_long=utf_new_char("java/lang/Long");
188 utf_float=utf_new_char("java/lang/Float");
189 utf_double=utf_new_char("java/lang/Double");
194 log_text("fill_callblock");
201 /* determine number of parameters */
203 blk[0].itemtype = TYPE_ADR;
204 blk[0].item = (u8)(u4)obj;
212 while (**utf_ptr != ')') {
213 if (*utf_ptr >= desc_end)
214 panic("illegal method descriptor");
216 /* primitive types */
217 switch (utf_nextu2(utf_ptr)) {
219 param=params->data[cnts];
221 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
224 if (param->vftbl->class->name==utf_byte) {
225 blk[cnt].itemtype=TYPE_INT;
226 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
228 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
233 param=params->data[cnts];
235 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
238 if (param->vftbl->class->name==utf_char) {
239 blk[cnt].itemtype=TYPE_INT;
240 blk[cnt].item = (u8) ((struct java_lang_Character * )param)->value;
242 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
248 param=params->data[cnts];
250 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
253 if (param->vftbl->class->name==utf_short) {
254 blk[cnt].itemtype=TYPE_INT;
255 blk[cnt].item = (u8) ((struct java_lang_Short* )param)->value;
257 if (param->vftbl->class->name==utf_byte) {
258 blk[cnt].itemtype=TYPE_INT;
259 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
261 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
268 param=params->data[cnts];
270 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
273 if (param->vftbl->class->name==utf_bool) {
274 blk[cnt].itemtype=TYPE_INT;
275 blk[cnt].item = (u8) ((struct java_lang_Boolean * )param)->value;
277 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
283 log_text("fill_callblock_objA: param 'I'");
284 param=params->data[cnts];
286 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
289 if (param->vftbl->class->name==utf_int) {
290 blk[cnt].itemtype=TYPE_INT;
291 blk[cnt].item = (u8) ((struct java_lang_Integer * )param)->value;
292 /*printf("INT VALUE :%d\n",((struct java_lang_Integer * )param)->value);*/
294 if (param->vftbl->class->name==utf_short) {
295 blk[cnt].itemtype=TYPE_INT;
296 blk[cnt].item = (u8) ((struct java_lang_Short* )param)->value;
298 if (param->vftbl->class->name==utf_byte) {
299 blk[cnt].itemtype=TYPE_INT;
300 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
303 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
310 param=params->data[cnts];
312 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
315 if (param->vftbl->class->name==utf_long) {
316 blk[cnt].itemtype=TYPE_LNG;
317 blk[cnt].item = (u8) ((struct java_lang_Long * )param)->value;
319 if (param->vftbl->class->name==utf_int) {
320 blk[cnt].itemtype=TYPE_LNG;
321 blk[cnt].item = (u8) ((struct java_lang_Integer * )param)->value;
323 if (param->vftbl->class->name==utf_short) {
324 blk[cnt].itemtype=TYPE_LNG;
325 blk[cnt].item = (u8) ((struct java_lang_Short* )param)->value;
327 if (param->vftbl->class->name==utf_byte) {
328 blk[cnt].itemtype=TYPE_LNG;
329 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
331 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
341 param=params->data[cnts];
343 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
347 if (param->vftbl->class->name==utf_float) {
348 blk[cnt].itemtype=TYPE_FLT;
349 *((jfloat*)(&blk[cnt].item))=(jfloat) ((struct java_lang_Float*)param)->value;
351 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
356 param=params->data[cnts];
358 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
362 if (param->vftbl->class->name==utf_double) {
363 blk[cnt].itemtype=TYPE_DBL;
364 *((jdouble*)(&blk[cnt].item))=(jdouble) ((struct java_lang_Float*)param)->value;
366 if (param->vftbl->class->name==utf_float) {
367 blk[cnt].itemtype=TYPE_DBL;
368 *((jdouble*)(&blk[cnt].item))=(jdouble) ((struct java_lang_Float*)param)->value;
370 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
376 panic("V not allowed as function parameter");
380 char *start=(*utf_ptr)-1;
383 while (utf_nextu2(utf_ptr) != ';')
385 if (!builtin_instanceof(params->data[cnts],class_from_descriptor(start,end,0,CLASSLOAD_LOAD))) {
386 if (params->data[cnts]!=0) {
387 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
391 blk[cnt].itemtype = TYPE_ADR;
392 blk[cnt].item= (u8)(u4) (params->data[cnts]);
398 char *start=(*utf_ptr)-1;
402 while ((ch = utf_nextu2(utf_ptr)) == '[')
404 while (utf_nextu2(utf_ptr) != ';') {}
407 ch = utf_nextu2(utf_ptr);
408 if (!builtin_arrayinstanceof(params->data[cnts],class_from_descriptor(start,end,0,CLASSLOAD_LOAD))) {
409 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
414 blk[cnt].itemtype = TYPE_ADR;
415 blk[cnt].item = (u8)(u4) (params->data[cnts]);
423 c = utf_nextu2(utf_ptr);
424 c = utf_nextu2(utf_ptr);
425 return c; /*return type needed usage of the right lowlevel methods*/
442 jmethodID get_virtual(jobject obj,jmethodID methodID) {
443 if (obj->vftbl->class==methodID->class) return methodID;
444 return class_resolvemethod (obj->vftbl->class, methodID->name, methodID->descriptor);
447 jmethodID get_nonvirtual(jclass clazz,jmethodID methodID) {
448 if (clazz==methodID->class) return methodID;
449 return class_resolvemethod (clazz, methodID->name, methodID->descriptor);
454 jobject callObjectMethod (jobject obj, jmethodID methodID, va_list args)
461 log_text("JNI-Call: CallObjectMethodV");
462 utf_display(methodID->name);
463 utf_display(methodID->descriptor);
464 printf("\nParmaeter count: %d\n",argcount);
465 utf_display(obj->vftbl->class->name);
470 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
473 argcount=get_parametercount(methodID);
475 if (!( ((methodID->flags & ACC_STATIC) && (obj==0)) ||
476 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
477 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
481 if (obj && (! builtin_instanceof(obj,methodID->class))) {
482 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
487 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
488 log_text("Too many arguments. CallObjectMethod does not support that");
492 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
494 fill_callblock(obj,methodID->descriptor,blk,args,'O');
496 /* printf("parameter: obj: %p",blk[0].item); */
497 ret=asm_calljavafunction2(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
498 MFREE(blk,jni_callblock,argcount+1);
499 /* printf("(CallObjectMethodV)-->%p\n",ret); */
505 core function for integer class methods (bool, byte, short, integer)
506 This is basically needed for i386
508 jint callIntegerMethod(jobject obj, jmethodID methodID, char retType, va_list args)
514 /* printf("%p, %c\n",retType,methodID,retType);*/
517 log_text("JNI-Call: CallObjectMethodV");
518 utf_display(methodID->name);
519 utf_display(methodID->descriptor);
520 printf("\nParmaeter count: %d\n",argcount);
521 utf_display(obj->vftbl->class->name);
525 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
529 argcount = get_parametercount(methodID);
531 if (!( ((methodID->flags & ACC_STATIC) && (obj==0)) ||
532 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
533 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
537 if (obj && (! builtin_instanceof(obj,methodID->class))) {
538 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
544 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
545 log_text("Too many arguments. CallObjectMethod does not support that");
549 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
551 fill_callblock(obj, methodID->descriptor, blk, args, retType);
553 /* printf("parameter: obj: %p",blk[0].item); */
554 ret = (jint) asm_calljavafunction2(methodID,
556 (argcount + 1) * sizeof(jni_callblock),
559 MFREE(blk, jni_callblock, argcount + 1);
560 /* printf("(CallObjectMethodV)-->%p\n",ret); */
566 /*core function for long class functions*/
567 jlong callLongMethod(jobject obj, jmethodID methodID, va_list args)
574 log_text("JNI-Call: CallObjectMethodV");
575 utf_display(methodID->name);
576 utf_display(methodID->descriptor);
577 printf("\nParmaeter count: %d\n",argcount);
578 utf_display(obj->vftbl->class->name);
582 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
585 argcount=get_parametercount(methodID);
587 if (!( ((methodID->flags & ACC_STATIC) && (obj==0)) ||
588 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
589 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
593 if (obj && (! builtin_instanceof(obj,methodID->class))) {
594 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
600 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
601 log_text("Too many arguments. CallObjectMethod does not support that");
605 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
607 fill_callblock(obj,methodID->descriptor,blk,args,'L');
609 /* printf("parameter: obj: %p",blk[0].item); */
610 ret=asm_calljavafunction2long(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
611 MFREE(blk,jni_callblock,argcount+1);
612 /* printf("(CallObjectMethodV)-->%p\n",ret); */
618 /*core function for float class methods (float,double)*/
619 jdouble callFloatMethod (jobject obj, jmethodID methodID, va_list args,char retType)
621 int argcount=get_parametercount(methodID);
626 log_text("JNI-Call: CallObjectMethodV");
627 utf_display(methodID->name);
628 utf_display(methodID->descriptor);
629 printf("\nParmaeter count: %d\n",argcount);
630 utf_display(obj->vftbl->class->name);
634 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
635 log_text("Too many arguments. CallObjectMethod does not support that");
639 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
641 fill_callblock(obj,methodID->descriptor,blk,args,retType);
643 /* printf("parameter: obj: %p",blk[0].item); */
644 ret=asm_calljavafunction2double(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
645 MFREE(blk,jni_callblock,argcount+1);
646 /* printf("(CallObjectMethodV)-->%p\n",ret); */
652 /*************************** function: jclass_findfield ****************************
654 searches for field with specified name and type in a 'classinfo'-structur
655 if no such field is found NULL is returned
657 ************************************************************************************/
659 fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
662 /* printf(" FieldCount: %d\n",c->fieldscount);
663 utf_display(c->name); */
664 for (i = 0; i < c->fieldscount; i++) {
665 /* utf_display(c->fields[i].name);
667 utf_display(c->fields[i].descriptor);
669 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
670 return &(c->fields[i]);
673 if (c->super) return jclass_findfield(c->super,name,desc);
678 /********************* returns version of native method interface *****************/
680 jint GetVersion (JNIEnv* env)
685 /****************** loads a class from a buffer of raw class data *****************/
687 jclass DefineClass(JNIEnv* env, const char *name, jobject loader, const jbyte *buf, jsize len)
691 /* change suck-mode, so subsequent class_load will read from memory-buffer */
692 classload_buffer( (u1*) buf,len);
694 clazz = loader_load(utf_new_char ((char *) name));
696 /* restore old suck-mode */
697 classload_buffer(NULL,0);
703 /*************** loads locally defined class with the specified name **************/
705 jclass FindClass (JNIEnv* env, const char *name)
709 /* if (strcmp(name,"[B")==0) {
710 c = loader_load(utf_new_char("The_Array_Class"));
713 c = loader_load(utf_new_char_classname ((char *) name));
715 if (!c) exceptionptr = native_new_and_init(class_java_lang_ClassFormatError);
721 /***********************************************************************************
723 converts java.lang.reflect.Method or
724 java.lang.reflect.Constructor object to a method ID
726 **********************************************************************************/
728 jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
730 /* log_text("JNI-Call: FromReflectedMethod"); */
736 /*************** return superclass of the class represented by sub ****************/
738 jclass GetSuperclass(JNIEnv* env, jclass sub)
742 c = ((classinfo*) sub)->super;
746 use_class_as_object(c);
752 /*********************** check whether sub can be cast to sup ********************/
754 jboolean IsAssignableForm(JNIEnv* env, jclass sub, jclass sup)
756 return builtin_isanysubclass(sub, sup);
760 /***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
762 jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
764 /* log_text("JNI-Call: ToReflectedField"); */
770 /***************** throw java.lang.Throwable object ******************************/
772 jint Throw(JNIEnv* env, jthrowable obj)
774 exceptionptr = (java_objectheader*) obj;
780 /***********************************************************************************
782 create exception object from the class clazz with the
783 specified message and cause it to be thrown
785 **********************************************************************************/
788 jint ThrowNew (JNIEnv* env, jclass clazz, const char *msg)
790 java_lang_Throwable *o;
792 /* instantiate exception object */
793 o = (java_lang_Throwable *) native_new_and_init ((classinfo*) clazz);
797 o->detailMessage = (java_lang_String*) javastring_new_char((char *) msg);
799 exceptionptr = (java_objectheader*) o;
803 /************************* check if exception occured *****************************/
805 jthrowable ExceptionOccurred (JNIEnv* env)
807 return (jthrowable) exceptionptr;
810 /********** print exception and a backtrace of the stack (for debugging) **********/
812 void ExceptionDescribe (JNIEnv* env)
814 utf_display(exceptionptr->vftbl->class->name);
820 /******************* clear any exception currently being thrown *******************/
822 void ExceptionClear (JNIEnv* env)
828 /********** raises a fatal error and does not expect the VM to recover ************/
830 void FatalError (JNIEnv* env, const char *msg)
835 /******************* creates a new local reference frame **************************/
837 jint PushLocalFrame(JNIEnv* env, jint capacity)
844 /**************** Pops off the current local reference frame **********************/
846 jobject PopLocalFrame(JNIEnv* env, jobject result)
854 /** Creates a new global reference to the object referred to by the obj argument **/
856 jobject NewGlobalRef(JNIEnv* env, jobject lobj)
858 heap_addreference((void**) &lobj);
863 /************* Deletes the global reference pointed to by globalRef **************/
865 void DeleteGlobalRef (JNIEnv* env, jobject gref)
871 /*************** Deletes the local reference pointed to by localRef ***************/
873 void DeleteLocalRef (JNIEnv* env, jobject localRef)
878 /********** Tests whether two references refer to the same Java object ************/
880 jboolean IsSameObject (JNIEnv* env, jobject obj1, jobject obj2)
885 /***** Creates a new local reference that refers to the same object as ref *******/
887 jobject NewLocalRef (JNIEnv* env, jobject ref)
892 /***********************************************************************************
894 Ensures that at least a given number of local references can
895 be created in the current thread
897 **********************************************************************************/
899 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
901 return 0; /* return 0 on success */
905 /********* Allocates a new Java object without invoking a constructor *************/
907 jobject AllocObject (JNIEnv* env, jclass clazz)
909 java_objectheader *o = builtin_new(clazz);
914 /***********************************************************************************
916 Constructs a new Java object
917 arguments that are to be passed to the constructor are placed after methodID
919 ***********************************************************************************/
921 jobject NewObject (JNIEnv* env, jclass clazz, jmethodID methodID, ...)
923 java_objectheader *o;
925 int argcount=get_parametercount(methodID);
929 /* log_text("JNI-Call: NewObject"); */
932 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
933 log_text("Too many arguments. NewObject does not support that");
938 o = builtin_new (clazz); /* create object */
942 va_start(vaargs,methodID);
943 for (i=0;i<argcount;i++) {
944 args[i]=va_arg(vaargs,void*);
947 exceptionptr=asm_calljavamethod(methodID,o,args[0],args[1],args[2]);
953 /***********************************************************************************
955 Constructs a new Java object
956 arguments that are to be passed to the constructor are placed in va_list args
958 ***********************************************************************************/
960 jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
962 /* log_text("JNI-Call: NewObjectV"); */
968 /***********************************************************************************
970 Constructs a new Java object
971 arguments that are to be passed to the constructor are placed in
972 args array of jvalues
974 ***********************************************************************************/
976 jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
978 /* log_text("JNI-Call: NewObjectA"); */
984 /************************ returns the class of an object **************************/
986 jclass GetObjectClass(JNIEnv* env, jobject obj)
988 classinfo *c = obj->vftbl->class;
989 /* log_text("GetObjectClass");
990 utf_display(obj->vftbl->class->name);*/
991 use_class_as_object(c);
993 /*printf("\nPointer: %p\n",c);*/
998 /************* tests whether an object is an instance of a class ******************/
1000 jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz)
1002 return builtin_instanceof(obj,clazz);
1006 /***************** converts a java.lang.reflect.Field to a field ID ***************/
1008 jfieldID FromReflectedField(JNIEnv* env, jobject field)
1010 log_text("JNI-Call: FromReflectedField");
1016 /**********************************************************************************
1018 converts a method ID to a java.lang.reflect.Method or
1019 java.lang.reflect.Constructor object
1021 **********************************************************************************/
1023 jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
1025 log_text("JNI-Call: ToReflectedMethod");
1031 /**************** returns the method ID for an instance method ********************/
1033 jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, const char *sig)
1037 m = class_resolvemethod (
1039 utf_new_char ((char*) name),
1040 utf_new_char ((char*) sig)
1043 if (!m) exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
1049 /******************** JNI-functions for calling instance methods ******************/
1051 jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1056 /* log_text("JNI-Call: CallObjectMethod");*/
1058 va_start(vaargs, methodID);
1059 ret = callObjectMethod(obj, methodID, vaargs);
1066 jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1068 return callObjectMethod(obj,methodID,args);
1072 jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1074 log_text("JNI-Call: CallObjectMethodA");
1082 jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1087 /* log_text("JNI-Call: CallBooleanMethod");*/
1089 va_start(vaargs,methodID);
1090 ret = (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',vaargs);
1096 jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1098 return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',args);
1102 jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1104 log_text("JNI-Call: CallBooleanMethodA");
1109 jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1114 /* log_text("JNI-Call: CallVyteMethod");*/
1116 va_start(vaargs,methodID);
1117 ret = callIntegerMethod(obj,get_virtual(obj,methodID),'B',vaargs);
1123 jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1125 /* log_text("JNI-Call: CallByteMethodV");*/
1126 return callIntegerMethod(obj,methodID,'B',args);
1130 jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1132 log_text("JNI-Call: CallByteMethodA");
1138 jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1143 /* log_text("JNI-Call: CallCharMethod");*/
1145 va_start(vaargs,methodID);
1146 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'C', vaargs);
1153 jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1155 /* log_text("JNI-Call: CallCharMethodV");*/
1156 return callIntegerMethod(obj,get_virtual(obj,methodID),'C',args);
1160 jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1162 log_text("JNI-Call: CallCharMethodA");
1168 jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1173 /* log_text("JNI-Call: CallShortMethod");*/
1175 va_start(vaargs, methodID);
1176 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'S', vaargs);
1183 jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1185 return callIntegerMethod(obj, get_virtual(obj, methodID), 'S', args);
1189 jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1191 log_text("JNI-Call: CallShortMethodA");
1198 jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1203 va_start(vaargs,methodID);
1204 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'I', vaargs);
1211 jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1213 return callIntegerMethod(obj, get_virtual(obj, methodID), 'I', args);
1217 jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1219 log_text("JNI-Call: CallIntMethodA");
1226 jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1228 log_text("JNI-Call: CallLongMethod");
1234 jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1236 log_text("JNI-Call: CallLongMethodV");
1242 jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1244 log_text("JNI-Call: CallLongMethodA");
1251 jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1256 /* log_text("JNI-Call: CallFloatMethod");*/
1258 va_start(vaargs,methodID);
1259 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'F');
1266 jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1268 log_text("JNI-Call: CallFloatMethodV");
1269 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'F');
1273 jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1275 log_text("JNI-Call: CallFloatMethodA");
1282 jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1287 /* log_text("JNI-Call: CallDoubleMethod");*/
1289 va_start(vaargs,methodID);
1290 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'D');
1297 jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1299 log_text("JNI-Call: CallDoubleMethodV");
1300 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'D');
1304 jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1306 log_text("JNI-Call: CallDoubleMethodA");
1312 void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1316 /* log_text("JNI-Call: CallVoidMethod");*/
1318 va_start(vaargs,methodID);
1319 (void) callIntegerMethod(obj, get_virtual(obj, methodID), 'V', vaargs);
1324 void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1326 log_text("JNI-Call: CallVoidMethodV");
1327 (void)callIntegerMethod(obj,get_virtual(obj,methodID),'V',args);
1331 void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1333 log_text("JNI-Call: CallVoidMethodA");
1338 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1340 log_text("JNI-Call: CallNonvirtualObjectMethod");
1346 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1348 log_text("JNI-Call: CallNonvirtualObjectMethodV");
1354 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1356 log_text("JNI-Call: CallNonvirtualObjectMethodA");
1363 jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1368 /* log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
1370 va_start(vaargs,methodID);
1371 ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',vaargs);
1378 jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1380 /* log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
1381 return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',args);
1385 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1387 log_text("JNI-Call: CallNonvirtualBooleanMethodA");
1394 jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1399 /* log_text("JNI-Call: CallNonvirutalByteMethod");*/
1401 va_start(vaargs,methodID);
1402 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',vaargs);
1408 jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1410 /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
1411 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',args);
1416 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1418 log_text("JNI-Call: CallNonvirtualByteMethodA");
1425 jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1430 /* log_text("JNI-Call: CallNonVirtualCharMethod");*/
1432 va_start(vaargs,methodID);
1433 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',vaargs);
1439 jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1441 /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
1442 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',args);
1446 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1448 log_text("JNI-Call: CallNonvirtualCharMethodA");
1455 jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1460 /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
1462 va_start(vaargs,methodID);
1463 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',vaargs);
1469 jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1471 /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
1472 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',args);
1476 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1478 log_text("JNI-Call: CallNonvirtualShortMethodA");
1485 jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1491 /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
1493 va_start(vaargs,methodID);
1494 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',vaargs);
1500 jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1502 /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
1503 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',args);
1507 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1509 log_text("JNI-Call: CallNonvirtualIntMethodA");
1516 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1518 log_text("JNI-Call: CallNonvirtualLongMethod");
1524 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1526 log_text("JNI-Call: CallNonvirtualLongMethodV");
1532 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1534 log_text("JNI-Call: CallNonvirtualLongMethodA");
1541 jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1546 /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
1549 va_start(vaargs,methodID);
1550 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'F');
1557 jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1559 log_text("JNI-Call: CallNonvirtualFloatMethodV");
1560 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'F');
1564 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1566 log_text("JNI-Call: CallNonvirtualFloatMethodA");
1573 jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1577 log_text("JNI-Call: CallNonvirtualDoubleMethod");
1579 va_start(vaargs,methodID);
1580 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'D');
1587 jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1589 /* log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
1590 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'D');
1594 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1596 log_text("JNI-Call: CallNonvirtualDoubleMethodA");
1603 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1607 /* log_text("JNI-Call: CallNonvirtualVoidMethod");*/
1609 va_start(vaargs,methodID);
1610 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',vaargs);
1616 void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1618 /* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
1620 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',args);
1625 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1627 log_text("JNI-Call: CallNonvirtualVoidMethodA");
1630 /************************* JNI-functions for accessing fields ************************/
1632 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1636 /* log_text("========================= searching for:");
1639 f = jclass_findfield(clazz,
1640 utf_new_char ((char*) name),
1641 utf_new_char ((char*) sig)
1645 /* utf_display(clazz->name);
1648 exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldError);
1653 /*************************** retrieve fieldid, abort on error ************************/
1655 jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig)
1657 jfieldID id = GetFieldID(env, clazz, name, sig);
1661 utf_display(clazz->name);
1662 log_text("\nfield:");
1667 panic("setfield_critical failed");
1672 jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
1674 return getField(obj,jobject,fieldID);
1677 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
1679 return getField(obj,jboolean,fieldID);
1683 jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
1685 return getField(obj,jbyte,fieldID);
1689 jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
1691 return getField(obj,jchar,fieldID);
1695 jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
1697 return getField(obj,jshort,fieldID);
1701 jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
1703 return getField(obj,jint,fieldID);
1707 jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
1709 return getField(obj,jlong,fieldID);
1713 jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
1715 return getField(obj,jfloat,fieldID);
1719 jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
1721 return getField(obj,jdouble,fieldID);
1724 void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
1726 setField(obj,jobject,fieldID,val);
1730 void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
1732 setField(obj,jboolean,fieldID,val);
1736 void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
1738 setField(obj,jbyte,fieldID,val);
1742 void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
1744 setField(obj,jchar,fieldID,val);
1748 void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
1750 setField(obj,jshort,fieldID,val);
1754 void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
1756 setField(obj,jint,fieldID,val);
1760 void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
1762 setField(obj,jlong,fieldID,val);
1766 void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
1768 setField(obj,jfloat,fieldID,val);
1772 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
1774 setField(obj,jdouble,fieldID,val);
1777 /**************** JNI-functions for calling static methods **********************/
1779 jmethodID GetStaticMethodID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1783 m = class_resolvemethod (
1785 utf_new_char ((char*) name),
1786 utf_new_char ((char*) sig)
1789 if (!m) exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
1794 jobject CallStaticObjectMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1796 log_text("JNI-Call: CallStaticObjectMethod");
1802 jobject CallStaticObjectMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1804 log_text("JNI-Call: CallStaticObjectMethodV");
1810 jobject CallStaticObjectMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1812 log_text("JNI-Call: CallStaticObjectMethodA");
1818 jboolean CallStaticBooleanMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1823 /* log_text("JNI-Call: CallStaticBooleanMethod");*/
1825 va_start(vaargs,methodID);
1826 ret = (jboolean)callIntegerMethod(0,methodID,'Z',vaargs);
1833 jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1835 return (jboolean) callIntegerMethod(0, methodID, 'Z', args);
1838 jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1840 log_text("JNI-Call: CallStaticBooleanMethodA");
1846 jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1851 /* log_text("JNI-Call: CallStaticByteMethod");*/
1853 va_start(vaargs, methodID);
1854 ret = (jbyte) callIntegerMethod(0, methodID, 'B', vaargs);
1861 jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1863 return (jbyte) callIntegerMethod(0, methodID, 'B', args);
1867 jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1869 log_text("JNI-Call: CallStaticByteMethodA");
1875 jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1880 /* log_text("JNI-Call: CallStaticByteMethod");*/
1882 va_start(vaargs, methodID);
1883 ret = (jchar) callIntegerMethod(0, methodID, 'C', vaargs);
1890 jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1892 return (jchar) callIntegerMethod(0, methodID, 'C', args);
1896 jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1898 log_text("JNI-Call: CallStaticCharMethodA");
1905 jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1910 /* log_text("JNI-Call: CallStaticByteMethod");*/
1912 va_start(vaargs,methodID);
1913 ret = (jshort) callIntegerMethod(0, methodID, 'S', vaargs);
1920 jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1922 /*log_text("JNI-Call: CallStaticShortMethodV");*/
1923 return (jshort) callIntegerMethod(0, methodID, 'S', args);
1927 jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1929 log_text("JNI-Call: CallStaticShortMethodA");
1936 jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1941 /* log_text("JNI-Call: CallStaticIntMethod");*/
1943 va_start(vaargs, methodID);
1944 ret = callIntegerMethod(0, methodID, 'I', vaargs);
1951 jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1953 log_text("JNI-Call: CallStaticIntMethodV");
1955 return callIntegerMethod(0, methodID, 'I', args);
1959 jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1961 log_text("JNI-Call: CallStaticIntMethodA");
1968 jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1973 /* log_text("JNI-Call: CallStaticLongMethod");*/
1975 va_start(vaargs, methodID);
1976 ret = callLongMethod(0, methodID, vaargs);
1983 jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1985 log_text("JNI-Call: CallStaticLongMethodV");
1987 return callLongMethod(0,methodID,args);
1991 jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1993 log_text("JNI-Call: CallStaticLongMethodA");
2000 jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2005 /* log_text("JNI-Call: CallStaticLongMethod");*/
2007 va_start(vaargs, methodID);
2008 ret = callFloatMethod(0, methodID, vaargs, 'F');
2015 jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2018 return callFloatMethod(0, methodID, args, 'F');
2023 jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2025 log_text("JNI-Call: CallStaticFloatMethodA");
2032 jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2037 /* log_text("JNI-Call: CallStaticDoubleMethod");*/
2039 va_start(vaargs,methodID);
2040 ret = callFloatMethod(0, methodID, vaargs, 'D');
2047 jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2049 log_text("JNI-Call: CallStaticDoubleMethodV");
2051 return callFloatMethod(0, methodID, args, 'D');
2055 jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2057 log_text("JNI-Call: CallStaticDoubleMethodA");
2063 void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
2067 /* log_text("JNI-Call: CallStaticVoidMethod");*/
2069 va_start(vaargs, methodID);
2070 (void) callIntegerMethod(0, methodID, 'V', vaargs);
2075 void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
2077 log_text("JNI-Call: CallStaticVoidMethodV");
2078 (void)callIntegerMethod(0, methodID, 'V', args);
2082 void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
2084 log_text("JNI-Call: CallStaticVoidMethodA");
2088 /****************** JNI-functions for accessing static fields ********************/
2090 jfieldID GetStaticFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
2094 f = jclass_findfield(clazz,
2095 utf_new_char ((char*) name),
2096 utf_new_char ((char*) sig)
2099 if (!f) exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldError);
2105 jobject GetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2108 return fieldID->value.a;
2112 jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2115 return fieldID->value.i;
2119 jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2122 return fieldID->value.i;
2126 jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2129 return fieldID->value.i;
2133 jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2136 return fieldID->value.i;
2140 jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2143 return fieldID->value.i;
2147 jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2150 return fieldID->value.l;
2154 jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2157 return fieldID->value.f;
2161 jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2164 return fieldID->value.d;
2169 void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
2172 fieldID->value.a = value;
2176 void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
2179 fieldID->value.i = value;
2183 void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
2186 fieldID->value.i = value;
2190 void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
2193 fieldID->value.i = value;
2197 void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
2200 fieldID->value.i = value;
2204 void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
2207 fieldID->value.i = value;
2211 void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
2214 fieldID->value.l = value;
2218 void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
2221 fieldID->value.f = value;
2225 void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
2228 fieldID->value.d = value;
2232 /***** create new java.lang.String object from an array of Unicode characters ****/
2234 jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
2237 java_lang_String *s;
2240 s = (java_lang_String*) builtin_new (class_java_lang_String);
2241 a = builtin_newarray_char (len);
2243 /* javastring or characterarray could not be created */
2244 if ( (!a) || (!s) ) return NULL;
2247 for (i=0; i<len; i++) a->data[i] = buf[i];
2256 static char emptyString[]="";
2257 static jchar emptyStringJ[]={0,0};
2259 /******************* returns the length of a Java string ***************************/
2261 jsize GetStringLength (JNIEnv *env, jstring str)
2263 return ((java_lang_String*) str)->count;
2267 /******************** convertes javastring to u2-array ****************************/
2269 u2 *javastring_tou2 (jstring so)
2271 java_lang_String *s = (java_lang_String*) so;
2276 if (!s) return NULL;
2279 if (!a) return NULL;
2281 /* allocate memory */
2282 stringbuffer = MNEW( u2 , s->count + 1 );
2285 for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
2287 /* terminate string */
2288 stringbuffer[i] = '\0';
2290 return stringbuffer;
2293 /********* returns a pointer to an array of Unicode characters of the string *******/
2295 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
2297 jchar *jc=javastring_tou2(str);
2300 if (isCopy) *isCopy=JNI_TRUE;
2303 if (isCopy) *isCopy=JNI_TRUE;
2304 return emptyStringJ;
2307 /**************** native code no longer needs access to chars **********************/
2309 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
2311 if (chars==emptyStringJ) return;
2312 MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count+1);
2315 /************ create new java.lang.String object from utf8-characterarray **********/
2317 jstring NewStringUTF (JNIEnv *env, const char *utf)
2319 /* log_text("NewStringUTF called");*/
2320 return javastring_new(utf_new_char(utf));
2323 /****************** returns the utf8 length in bytes of a string *******************/
2325 jsize GetStringUTFLength (JNIEnv *env, jstring string)
2327 java_lang_String *s = (java_lang_String*) string;
2329 return (jsize) u2_utflength(s->value->data, s->count);
2332 /************ converts a Javastring to an array of UTF-8 characters ****************/
2334 const char* GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy)
2337 if (verbose) log_text("GetStringUTFChars:");
2339 u=javastring_toutf((java_lang_String*) string,false);
2340 if (isCopy) *isCopy=JNI_FALSE;
2348 /***************** native code no longer needs access to utf ***********************/
2350 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
2352 /*we don't release utf chars right now, perhaps that should be done later. Since there is always one reference
2353 the garbage collector will never get them*/
2355 log_text("JNI-Call: ReleaseStringUTFChars");
2356 utf_display(utf_new_char(chars));
2360 /************************** array operations ***************************************/
2362 jsize GetArrayLength (JNIEnv *env, jarray array)
2367 jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
2370 exceptionptr=proto_java_lang_NegativeArraySizeException;
2373 java_objectarray *j = builtin_anewarray (len, clazz);
2374 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2378 jobject GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
2382 if (index<array->header.size)
2383 j = array->data[index];
2385 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2390 void SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index, jobject val)
2392 if (index>=array->header.size)
2393 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2396 /* check if the class of value is a subclass of the element class of the array */
2398 if (!builtin_canstore((java_objectarray*)array,(java_objectheader*)val))
2399 exceptionptr = proto_java_lang_ArrayStoreException;
2401 array->data[index] = val;
2407 jbooleanArray NewBooleanArray (JNIEnv *env, jsize len)
2410 exceptionptr=proto_java_lang_NegativeArraySizeException;
2413 java_booleanarray *j = builtin_newarray_boolean(len);
2414 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2419 jbyteArray NewByteArray (JNIEnv *env, jsize len)
2422 exceptionptr=proto_java_lang_NegativeArraySizeException;
2425 java_bytearray *j = builtin_newarray_byte(len);
2426 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2431 jcharArray NewCharArray (JNIEnv *env, jsize len)
2434 exceptionptr=proto_java_lang_NegativeArraySizeException;
2437 java_chararray *j = builtin_newarray_char(len);
2438 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2443 jshortArray NewShortArray (JNIEnv *env, jsize len)
2446 exceptionptr=proto_java_lang_NegativeArraySizeException;
2449 java_shortarray *j = builtin_newarray_short(len);
2450 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2455 jintArray NewIntArray (JNIEnv *env, jsize len)
2458 exceptionptr=proto_java_lang_NegativeArraySizeException;
2461 java_intarray *j = builtin_newarray_int(len);
2462 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2467 jlongArray NewLongArray (JNIEnv *env, jsize len)
2470 exceptionptr=proto_java_lang_NegativeArraySizeException;
2473 java_longarray *j = builtin_newarray_long(len);
2474 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2479 jfloatArray NewFloatArray (JNIEnv *env, jsize len)
2482 exceptionptr=proto_java_lang_NegativeArraySizeException;
2485 java_floatarray *j = builtin_newarray_float(len);
2486 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2491 jdoubleArray NewDoubleArray (JNIEnv *env, jsize len)
2494 exceptionptr=proto_java_lang_NegativeArraySizeException;
2497 java_doublearray *j = builtin_newarray_double(len);
2498 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2503 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
2505 if (isCopy) *isCopy = JNI_FALSE;
2510 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
2512 if (isCopy) *isCopy = JNI_FALSE;
2517 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
2519 if (isCopy) *isCopy = JNI_FALSE;
2524 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
2526 if (isCopy) *isCopy = JNI_FALSE;
2531 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
2533 if (isCopy) *isCopy = JNI_FALSE;
2538 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
2540 if (isCopy) *isCopy = JNI_FALSE;
2545 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
2547 if (isCopy) *isCopy = JNI_FALSE;
2552 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
2554 if (isCopy) *isCopy = JNI_FALSE;
2560 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
2566 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
2572 void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
2578 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
2584 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
2590 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
2596 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
2602 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
2607 void GetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2609 if (start<0 || len<0 || start+len>array->header.size)
2610 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2612 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2616 void GetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2618 if (start<0 || len<0 || start+len>array->header.size)
2619 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2621 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2625 void GetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2627 if (start<0 || len<0 || start+len>array->header.size)
2628 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2630 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2634 void GetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2636 if (start<0 || len<0 || start+len>array->header.size)
2637 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2639 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2643 void GetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2645 if (start<0 || len<0 || start+len>array->header.size)
2646 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2648 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2652 void GetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2654 if (start<0 || len<0 || start+len>array->header.size)
2655 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2657 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2661 void GetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2663 if (start<0 || len<0 || start+len>array->header.size)
2664 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2666 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2670 void GetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2672 if (start<0 || len<0 || start+len>array->header.size)
2673 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2675 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2679 void SetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2681 if (start<0 || len<0 || start+len>array->header.size)
2682 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2684 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2688 void SetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2690 if (start<0 || len<0 || start+len>array->header.size)
2691 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2693 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2697 void SetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2699 if (start<0 || len<0 || start+len>array->header.size)
2700 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2702 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2707 void SetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2709 if (start<0 || len<0 || start+len>array->header.size)
2710 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2712 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2716 void SetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2718 if (start<0 || len<0 || start+len>array->header.size)
2719 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2721 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2725 void SetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2727 if (start<0 || len<0 || start+len>array->header.size)
2728 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2730 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2734 void SetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2736 if (start<0 || len<0 || start+len>array->header.size)
2737 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2739 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2743 void SetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2745 if (start<0 || len<0 || start+len>array->header.size)
2746 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2748 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2751 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
2753 log_text("JNI-Call: RegisterNatives");
2758 jint UnregisterNatives (JNIEnv* env, jclass clazz)
2760 log_text("JNI-Call: UnregisterNatives");
2764 /******************************* monitor operations ********************************/
2766 jint MonitorEnter (JNIEnv* env, jobject obj)
2768 builtin_monitorenter(obj);
2773 jint MonitorExit (JNIEnv* env, jobject obj)
2775 builtin_monitorexit(obj);
2780 /************************************* JavaVM interface ****************************/
2782 #error CPP mode not supported yet
2784 jint GetJavaVM (JNIEnv* env, JavaVM **vm)
2786 log_text("JNI-Call: GetJavaVM");
2790 #endif /*__cplusplus*/
2792 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
2794 log_text("JNI-Call: GetStringRegion");
2798 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
2800 log_text("JNI-Call: GetStringUTFRegion");
2804 /****************** obtain direct pointer to array elements ***********************/
2806 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
2808 java_objectheader *s = (java_objectheader*) array;
2809 arraydescriptor *desc = s->vftbl->arraydesc;
2811 if (!desc) return NULL;
2813 return ((u1*)s) + desc->dataoffset;
2817 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
2819 log_text("JNI-Call: ReleasePrimitiveArrayCritical");
2824 /********* returns a pointer to an array of Unicode characters of the string *******/
2826 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
2828 log_text("JNI-Call: GetStringCritical");
2830 return GetStringChars(env,string,isCopy);
2833 /**************** native code no longer needs access to chars **********************/
2835 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
2837 log_text("JNI-Call: ReleaseStringCritical");
2839 ReleaseStringChars(env,string,cstring);
2843 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
2845 log_text("JNI-Call: NewWeakGlobalRef");
2851 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
2853 log_text("JNI-Call: DeleteWeakGlobalRef");
2859 /******************************* check for pending exception ***********************/
2862 jboolean ExceptionCheck(JNIEnv* env)
2864 log_text("JNI-Call: ExceptionCheck");
2866 return exceptionptr ? JNI_TRUE : JNI_FALSE;
2874 jint DestroyJavaVM(JavaVM *vm)
2876 log_text("DestroyJavaVM called");
2882 jint AttachCurrentThread(JavaVM *vm, void **par1, void *par2)
2884 log_text("AttachCurrentThread called");
2890 jint DetachCurrentThread(JavaVM *vm)
2892 log_text("DetachCurrentThread called");
2898 jint GetEnv(JavaVM *vm, void **environment, jint jniversion)
2900 *environment = &env;
2906 jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
2908 log_text("AttachCurrentThreadAsDaemon called");
2923 /********************************* JNI invocation table ******************************/
2925 struct _JavaVM javaVMTable={
2930 &AttachCurrentThread,
2931 &DetachCurrentThread,
2933 &AttachCurrentThreadAsDaemon
2936 JavaVM javaVM = &javaVMTable;
2939 /********************************* JNI function table ******************************/
2941 struct JNI_Table envTable = {
2949 &FromReflectedMethod,
2950 &FromReflectedField,
2968 &EnsureLocalCapacity,
2980 &CallBooleanMethodV,
2981 &CallBooleanMethodA,
3006 &CallNonvirtualObjectMethod,
3007 &CallNonvirtualObjectMethodV,
3008 &CallNonvirtualObjectMethodA,
3009 &CallNonvirtualBooleanMethod,
3010 &CallNonvirtualBooleanMethodV,
3011 &CallNonvirtualBooleanMethodA,
3012 &CallNonvirtualByteMethod,
3013 &CallNonvirtualByteMethodV,
3014 &CallNonvirtualByteMethodA,
3015 &CallNonvirtualCharMethod,
3016 &CallNonvirtualCharMethodV,
3017 &CallNonvirtualCharMethodA,
3018 &CallNonvirtualShortMethod,
3019 &CallNonvirtualShortMethodV,
3020 &CallNonvirtualShortMethodA,
3021 &CallNonvirtualIntMethod,
3022 &CallNonvirtualIntMethodV,
3023 &CallNonvirtualIntMethodA,
3024 &CallNonvirtualLongMethod,
3025 &CallNonvirtualLongMethodV,
3026 &CallNonvirtualLongMethodA,
3027 &CallNonvirtualFloatMethod,
3028 &CallNonvirtualFloatMethodV,
3029 &CallNonvirtualFloatMethodA,
3030 &CallNonvirtualDoubleMethod,
3031 &CallNonvirtualDoubleMethodV,
3032 &CallNonvirtualDoubleMethodA,
3033 &CallNonvirtualVoidMethod,
3034 &CallNonvirtualVoidMethodV,
3035 &CallNonvirtualVoidMethodA,
3056 &CallStaticObjectMethod,
3057 &CallStaticObjectMethodV,
3058 &CallStaticObjectMethodA,
3059 &CallStaticBooleanMethod,
3060 &CallStaticBooleanMethodV,
3061 &CallStaticBooleanMethodA,
3062 &CallStaticByteMethod,
3063 &CallStaticByteMethodV,
3064 &CallStaticByteMethodA,
3065 &CallStaticCharMethod,
3066 &CallStaticCharMethodV,
3067 &CallStaticCharMethodA,
3068 &CallStaticShortMethod,
3069 &CallStaticShortMethodV,
3070 &CallStaticShortMethodA,
3071 &CallStaticIntMethod,
3072 &CallStaticIntMethodV,
3073 &CallStaticIntMethodA,
3074 &CallStaticLongMethod,
3075 &CallStaticLongMethodV,
3076 &CallStaticLongMethodA,
3077 &CallStaticFloatMethod,
3078 &CallStaticFloatMethodV,
3079 &CallStaticFloatMethodA,
3080 &CallStaticDoubleMethod,
3081 &CallStaticDoubleMethodV,
3082 &CallStaticDoubleMethodA,
3083 &CallStaticVoidMethod,
3084 &CallStaticVoidMethodV,
3085 &CallStaticVoidMethodA,
3087 &GetStaticObjectField,
3088 &GetStaticBooleanField,
3089 &GetStaticByteField,
3090 &GetStaticCharField,
3091 &GetStaticShortField,
3093 &GetStaticLongField,
3094 &GetStaticFloatField,
3095 &GetStaticDoubleField,
3096 &SetStaticObjectField,
3097 &SetStaticBooleanField,
3098 &SetStaticByteField,
3099 &SetStaticCharField,
3100 &SetStaticShortField,
3102 &SetStaticLongField,
3103 &SetStaticFloatField,
3104 &SetStaticDoubleField,
3108 &ReleaseStringChars,
3110 &GetStringUTFLength,
3112 &ReleaseStringUTFChars,
3115 &GetObjectArrayElement,
3116 &SetObjectArrayElement,
3125 &GetBooleanArrayElements,
3126 &GetByteArrayElements,
3127 &GetCharArrayElements,
3128 &GetShortArrayElements,
3129 &GetIntArrayElements,
3130 &GetLongArrayElements,
3131 &GetFloatArrayElements,
3132 &GetDoubleArrayElements,
3133 &ReleaseBooleanArrayElements,
3134 &ReleaseByteArrayElements,
3135 &ReleaseCharArrayElements,
3136 &ReleaseShortArrayElements,
3137 &ReleaseIntArrayElements,
3138 &ReleaseLongArrayElements,
3139 &ReleaseFloatArrayElements,
3140 &ReleaseDoubleArrayElements,
3141 &GetBooleanArrayRegion,
3142 &GetByteArrayRegion,
3143 &GetCharArrayRegion,
3144 &GetShortArrayRegion,
3146 &GetLongArrayRegion,
3147 &GetFloatArrayRegion,
3148 &GetDoubleArrayRegion,
3149 &SetBooleanArrayRegion,
3150 &SetByteArrayRegion,
3151 &SetCharArrayRegion,
3152 &SetShortArrayRegion,
3154 &SetLongArrayRegion,
3155 &SetFloatArrayRegion,
3156 &SetDoubleArrayRegion,
3163 &GetStringUTFRegion,
3164 &GetPrimitiveArrayCritical,
3165 &ReleasePrimitiveArrayCritical,
3167 &ReleaseStringCritical,
3169 &DeleteWeakGlobalRef,
3174 JNIEnv env = &envTable;
3183 jobject *jni_method_invokeNativeHelper(JNIEnv *env,struct methodinfo *methodID,jobject obj, java_objectarray *params) {
3190 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
3193 argcount=get_parametercount(methodID);
3195 if (obj && (!builtin_instanceof((java_objectheader*)obj,methodID->class))) {
3196 (*env)->ThrowNew(env,loader_load(utf_new_char("java/lang/IllegalArgumentException")),
3197 "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
3204 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
3205 log_text("Too many arguments. invokeNativeHelper does not support that");
3209 if ( ((!params) && (argcount!=0)) ||
3210 (params && (params->header.size!=argcount))
3212 exceptionptr = native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
3217 if (!(methodID->flags & ACC_STATIC) && (!obj)) {
3218 (*env)->ThrowNew(env,loader_load(utf_new_char("java/lang/NullPointerException")),
3219 "Static mismatch in Java_java_lang_reflect_Method_invokeNative");
3223 if ((methodID->flags & ACC_STATIC) && (obj)) obj=0;
3225 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
3227 retT=fill_callblock_objA(obj,methodID->descriptor,blk,params);
3230 case 'V': (void)asm_calljavafunction2(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3231 retVal=native_new_and_init(loader_load(utf_new_char("java/lang/Void")));
3235 intVal=(s4)asm_calljavafunction2(methodID,
3236 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3237 retVal=builtin_new(loader_load(utf_new_char("java/lang/Integer")));
3238 CallVoidMethod(env,retVal,
3239 class_resolvemethod(retVal->vftbl->class,
3240 utf_new_char("<init>"),utf_new_char("(I)V")),intVal);
3245 intVal=(s4)asm_calljavafunction2(methodID,
3246 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3247 retVal=builtin_new(loader_load(utf_new_char("java/lang/Byte")));
3248 CallVoidMethod(env,retVal,
3249 class_resolvemethod(retVal->vftbl->class,
3250 utf_new_char("<init>"),utf_new_char("(B)V")),intVal);
3255 intVal=(s4)asm_calljavafunction2(methodID,
3256 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3257 retVal=builtin_new(loader_load(utf_new_char("java/lang/Character")));
3258 CallVoidMethod(env,retVal,
3259 class_resolvemethod(retVal->vftbl->class,
3260 utf_new_char("<init>"),utf_new_char("(C)V")),intVal);
3265 intVal=(s4)asm_calljavafunction2(methodID,
3266 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3267 retVal=builtin_new(loader_load(utf_new_char("java/lang/Short")));
3268 CallVoidMethod(env,retVal,
3269 class_resolvemethod(retVal->vftbl->class,
3270 utf_new_char("<init>"),utf_new_char("(S)V")),intVal);
3275 intVal=(s4)asm_calljavafunction2(methodID,
3276 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3277 retVal=builtin_new(loader_load(utf_new_char("java/lang/Boolean")));
3278 CallVoidMethod(env,retVal,
3279 class_resolvemethod(retVal->vftbl->class,
3280 utf_new_char("<init>"),utf_new_char("(Z)V")),intVal);
3285 intVal=asm_calljavafunction2long(methodID,
3286 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3287 retVal=builtin_new(loader_load(utf_new_char("java/lang/Long")));
3288 CallVoidMethod(env,retVal,
3289 class_resolvemethod(retVal->vftbl->class,
3290 utf_new_char("<init>"),utf_new_char("(J)V")),intVal);
3295 floatVal=asm_calljavafunction2double(methodID,
3296 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3297 retVal=builtin_new(loader_load(utf_new_char("java/lang/Float")));
3298 CallVoidMethod(env,retVal,
3299 class_resolvemethod(retVal->vftbl->class,
3300 utf_new_char("<init>"),utf_new_char("(F)V")),floatVal);
3305 floatVal=asm_calljavafunction2double(methodID,
3306 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3307 retVal=builtin_new(loader_load(utf_new_char("java/lang/Double")));
3308 CallVoidMethod(env,retVal,
3309 class_resolvemethod(retVal->vftbl->class,
3310 utf_new_char("<init>"),utf_new_char("(D)V")),floatVal);
3314 case 'L': /* fall through */
3315 case '[': retVal=asm_calljavafunction2(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3318 /* if this happens the acception has already been set by fill_callblock_objA*/
3319 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3323 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3326 exceptionptr=native_new_and_init(loader_load("java/lang/reflect/InvocationTargetException"));
3334 * These are local overrides for various environment variables in Emacs.
3335 * Please do not remove this and leave it at the end of the file, where
3336 * Emacs will automagically detect them.
3337 * ---------------------------------------------------------------------
3340 * indent-tabs-mode: t