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
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
31 $Id: jni.c 771 2003-12-13 23:11:08Z stefan $
43 #include "threads/thread.h"
44 #include "toolbox/loging.h"
45 #include "toolbox/memory.h"
46 #include "nat/java_lang_Byte.h"
47 #include "nat/java_lang_Character.h"
48 #include "nat/java_lang_Short.h"
49 #include "nat/java_lang_Integer.h"
50 #include "nat/java_lang_Boolean.h"
51 #include "nat/java_lang_Long.h"
52 #include "nat/java_lang_Float.h"
53 #include "nat/java_lang_Double.h"
54 #include "nat/java_lang_Throwable.h"
57 #define JNI_VERSION 0x00010002
60 static utf* utf_char = 0;
61 static utf* utf_bool = 0;
62 static utf* utf_byte =0;
63 static utf* utf_short = 0;
64 static utf* utf_int = 0;
65 static utf* utf_long = 0;
66 static utf* utf_float = 0;
67 static utf* utf_double = 0;
70 /********************* accessing instance-fields **********************************/
72 #define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
73 #define getField(obj,typ,var) *((typ*) ((long int) obj + (long int) var->offset))
74 #define setfield_critical(clazz,obj,name,sig,jdatatype,val) setField(obj,jdatatype,getFieldID_critical(env,clazz,name,sig),val);
78 u4 get_parametercount(methodinfo *m)
80 utf *descr = m->descriptor; /* method-descriptor */
81 char *utf_ptr = descr->text; /* current position in utf-text */
82 char *desc_end = utf_end(descr); /* points behind utf string */
83 java_objectarray* result;
84 int parametercount = 0;
90 /* determine number of parameters */
91 while ( *utf_ptr != ')' ) {
92 get_type(&utf_ptr,desc_end,true);
96 return parametercount;
101 void fill_callblock(void *obj,utf *descr,jni_callblock blk[], va_list data, char ret) {
102 char *utf__ptr = descr->text; /* current position in utf-text */
103 char **utf_ptr = &utf__ptr;
104 char *desc_end = utf_end(descr); /* points behind utf string */
113 log_text("fill_callblock");
120 /* determine number of parameters */
122 blk[0].itemtype=TYPE_ADR;
123 blk[0].item=(u8)(u4)obj;
126 while ( **utf_ptr != ')' ) {
127 if (*utf_ptr>=desc_end)
128 panic("illegal method descriptor");
130 switch (utf_nextu2(utf_ptr)) {
131 /* primitive types */
136 blk[cnt].itemtype=TYPE_INT;
137 blk[cnt].item=(u8) va_arg(data,int);
140 blk[cnt].itemtype=TYPE_INT;
141 dummy=va_arg(data,u4);
142 /*printf("fill_callblock: pos:%d, value:%d\n",cnt,dummy);*/
143 blk[cnt].item=(u8)dummy;
148 blk[cnt].itemtype=TYPE_LNG;
149 blk[cnt].item=(u8)va_arg(data,jlong);
152 blk[cnt].itemtype=TYPE_FLT;
153 *((jfloat*)(&blk[cnt].item))=((jfloat)va_arg(data,jdouble));
157 blk[cnt].itemtype=TYPE_DBL;
158 *((jdouble*)(&blk[cnt].item))=(jdouble)va_arg(data,jdouble);
160 case 'V' : panic ("V not allowed as function parameter");
163 while (utf_nextu2(utf_ptr)!=';')
165 blk[cnt].itemtype=TYPE_ADR;
166 blk[cnt].item=(u8)(u4)va_arg(data,void*);
172 char *start = *utf_ptr;
174 while ((ch = utf_nextu2(utf_ptr))=='[')
176 while (utf_nextu2(utf_ptr)!=';') {}
179 ch=utf_nextu2(utf_ptr);
180 blk[cnt].itemtype=TYPE_ADR;
181 blk[cnt].item=(u8)(u4)va_arg(data,void*);
188 /*the standard doesn't say anything about return value checking, but it appears to be usefull*/
189 c=utf_nextu2(utf_ptr);
190 c=utf_nextu2(utf_ptr);
191 /*printf("%c %c\n",ret,c);*/
193 if (!((c=='L') || (c=='['))) log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
194 } else if (ret != c) log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
198 /* XXX it could be considered if we should do typechecking here in the future */
199 char fill_callblock_objA(void *obj, utf *descr, jni_callblock blk[], java_objectarray* params)
201 char *utf__ptr = descr->text; /* current position in utf-text */
202 char **utf_ptr = &utf__ptr;
203 char *desc_end = utf_end(descr); /* points behind utf string */
214 utf_char=utf_new_char("java/lang/Character");
215 utf_bool=utf_new_char("java/lang/Boolean");
216 utf_byte=utf_new_char("java/lang/Byte");
217 utf_short=utf_new_char("java/lang/Short");
218 utf_int=utf_new_char("java/lang/Integer");
219 utf_long=utf_new_char("java/lang/Long");
220 utf_float=utf_new_char("java/lang/Float");
221 utf_double=utf_new_char("java/lang/Double");
226 log_text("fill_callblock");
233 /* determine number of parameters */
235 blk[0].itemtype = TYPE_ADR;
236 blk[0].item = (u8)(u4)obj;
244 while (**utf_ptr != ')') {
245 if (*utf_ptr >= desc_end)
246 panic("illegal method descriptor");
248 /* primitive types */
249 switch (utf_nextu2(utf_ptr)) {
251 param=params->data[cnts];
253 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
256 if (param->vftbl->class->name==utf_byte) {
257 blk[cnt].itemtype=TYPE_INT;
258 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
260 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
265 param=params->data[cnts];
267 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
270 if (param->vftbl->class->name==utf_char) {
271 blk[cnt].itemtype=TYPE_INT;
272 blk[cnt].item = (u8) ((struct java_lang_Character * )param)->value;
274 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
280 param=params->data[cnts];
282 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
285 if (param->vftbl->class->name==utf_short) {
286 blk[cnt].itemtype=TYPE_INT;
287 blk[cnt].item = (u8) ((struct java_lang_Short* )param)->value;
289 if (param->vftbl->class->name==utf_byte) {
290 blk[cnt].itemtype=TYPE_INT;
291 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
293 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
300 param=params->data[cnts];
302 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
305 if (param->vftbl->class->name==utf_bool) {
306 blk[cnt].itemtype=TYPE_INT;
307 blk[cnt].item = (u8) ((struct java_lang_Boolean * )param)->value;
309 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
315 /*log_text("fill_callblock_objA: param 'I'");*/
316 param=params->data[cnts];
318 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
321 if (param->vftbl->class->name==utf_int) {
322 blk[cnt].itemtype=TYPE_INT;
323 blk[cnt].item = (u8) ((struct java_lang_Integer * )param)->value;
324 /*printf("INT VALUE :%d\n",((struct java_lang_Integer * )param)->value);*/
326 if (param->vftbl->class->name==utf_short) {
327 blk[cnt].itemtype=TYPE_INT;
328 blk[cnt].item = (u8) ((struct java_lang_Short* )param)->value;
330 if (param->vftbl->class->name==utf_byte) {
331 blk[cnt].itemtype=TYPE_INT;
332 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
335 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
342 param=params->data[cnts];
344 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
347 if (param->vftbl->class->name==utf_long) {
348 blk[cnt].itemtype=TYPE_LNG;
349 blk[cnt].item = (u8) ((struct java_lang_Long * )param)->value;
351 if (param->vftbl->class->name==utf_int) {
352 blk[cnt].itemtype=TYPE_LNG;
353 blk[cnt].item = (u8) ((struct java_lang_Integer * )param)->value;
355 if (param->vftbl->class->name==utf_short) {
356 blk[cnt].itemtype=TYPE_LNG;
357 blk[cnt].item = (u8) ((struct java_lang_Short* )param)->value;
359 if (param->vftbl->class->name==utf_byte) {
360 blk[cnt].itemtype=TYPE_LNG;
361 blk[cnt].item = (u8) ((struct java_lang_Byte * )param)->value;
363 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
373 param=params->data[cnts];
375 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
379 if (param->vftbl->class->name==utf_float) {
380 blk[cnt].itemtype=TYPE_FLT;
381 *((jfloat*)(&blk[cnt].item))=(jfloat) ((struct java_lang_Float*)param)->value;
383 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
388 param=params->data[cnts];
390 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
394 if (param->vftbl->class->name==utf_double) {
395 blk[cnt].itemtype=TYPE_DBL;
396 *((jdouble*)(&blk[cnt].item))=(jdouble) ((struct java_lang_Float*)param)->value;
398 if (param->vftbl->class->name==utf_float) {
399 blk[cnt].itemtype=TYPE_DBL;
400 *((jdouble*)(&blk[cnt].item))=(jdouble) ((struct java_lang_Float*)param)->value;
402 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
408 panic("V not allowed as function parameter");
412 char *start=(*utf_ptr)-1;
415 while (utf_nextu2(utf_ptr) != ';')
417 if (!builtin_instanceof(params->data[cnts],class_from_descriptor(start,end,0,CLASSLOAD_LOAD))) {
418 if (params->data[cnts]!=0) {
419 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
423 blk[cnt].itemtype = TYPE_ADR;
424 blk[cnt].item= (u8)(u4) (params->data[cnts]);
430 char *start=(*utf_ptr)-1;
434 while ((ch = utf_nextu2(utf_ptr)) == '[')
436 while (utf_nextu2(utf_ptr) != ';') {}
439 ch = utf_nextu2(utf_ptr);
440 if (!builtin_arrayinstanceof(params->data[cnts],class_from_descriptor(start,end,0,CLASSLOAD_LOAD))) {
441 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
446 blk[cnt].itemtype = TYPE_ADR;
447 blk[cnt].item = (u8)(u4) (params->data[cnts]);
455 c = utf_nextu2(utf_ptr);
456 c = utf_nextu2(utf_ptr);
457 return c; /*return type needed usage of the right lowlevel methods*/
474 jmethodID get_virtual(jobject obj,jmethodID methodID) {
475 if (obj->vftbl->class==methodID->class) return methodID;
476 return class_resolvemethod (obj->vftbl->class, methodID->name, methodID->descriptor);
479 jmethodID get_nonvirtual(jclass clazz,jmethodID methodID) {
480 if (clazz==methodID->class) return methodID;
481 return class_resolvemethod (clazz, methodID->name, methodID->descriptor);
486 jobject callObjectMethod (jobject obj, jmethodID methodID, va_list args)
493 log_text("JNI-Call: CallObjectMethodV");
494 utf_display(methodID->name);
495 utf_display(methodID->descriptor);
496 printf("\nParmaeter count: %d\n",argcount);
497 utf_display(obj->vftbl->class->name);
502 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
506 argcount = get_parametercount(methodID);
508 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
509 ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
510 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
514 if (obj && !builtin_instanceof(obj, methodID->class)) {
515 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
520 exceptionptr = native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
521 log_text("Too many arguments. CallObjectMethod does not support that");
525 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
527 fill_callblock(obj, methodID->descriptor, blk, args, 'O');
529 /* printf("parameter: obj: %p",blk[0].item); */
530 ret = asm_calljavafunction2(methodID,
532 (argcount + 1) * sizeof(jni_callblock),
535 MFREE(blk, jni_callblock, argcount + 1);
536 /* printf("(CallObjectMethodV)-->%p\n",ret); */
542 core function for integer class methods (bool, byte, short, integer)
543 This is basically needed for i386
545 jint callIntegerMethod(jobject obj, jmethodID methodID, char retType, va_list args)
551 /* printf("%p, %c\n",retType,methodID,retType);*/
554 log_text("JNI-Call: CallObjectMethodV");
555 utf_display(methodID->name);
556 utf_display(methodID->descriptor);
557 printf("\nParmaeter count: %d\n",argcount);
558 utf_display(obj->vftbl->class->name);
562 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
566 argcount = get_parametercount(methodID);
568 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
569 ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
570 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
574 if (obj && !builtin_instanceof(obj, methodID->class)) {
575 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
581 exceptionptr = native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
582 log_text("Too many arguments. CallObjectMethod does not support that");
586 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
588 fill_callblock(obj, methodID->descriptor, blk, args, retType);
590 /* printf("parameter: obj: %p",blk[0].item); */
591 ret = (jint) asm_calljavafunction2(methodID,
593 (argcount + 1) * sizeof(jni_callblock),
596 MFREE(blk, jni_callblock, argcount + 1);
597 /* printf("(CallObjectMethodV)-->%p\n",ret); */
603 /*core function for long class functions*/
604 jlong callLongMethod(jobject obj, jmethodID methodID, va_list args)
611 log_text("JNI-Call: CallObjectMethodV");
612 utf_display(methodID->name);
613 utf_display(methodID->descriptor);
614 printf("\nParmaeter count: %d\n",argcount);
615 utf_display(obj->vftbl->class->name);
619 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
623 argcount = get_parametercount(methodID);
625 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
626 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
627 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
631 if (obj && !builtin_instanceof(obj,methodID->class)) {
632 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
638 exceptionptr = native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
639 log_text("Too many arguments. CallObjectMethod does not support that");
643 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
645 fill_callblock(obj, methodID->descriptor, blk, args, 'L');
647 /* printf("parameter: obj: %p",blk[0].item); */
648 ret = asm_calljavafunction2long(methodID,
650 (argcount + 1) * sizeof(jni_callblock),
653 MFREE(blk, jni_callblock, argcount + 1);
654 /* printf("(CallObjectMethodV)-->%p\n",ret); */
660 /*core function for float class methods (float,double)*/
661 jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,char retType)
663 int argcount = get_parametercount(methodID);
668 log_text("JNI-Call: CallObjectMethodV");
669 utf_display(methodID->name);
670 utf_display(methodID->descriptor);
671 printf("\nParmaeter count: %d\n",argcount);
672 utf_display(obj->vftbl->class->name);
677 exceptionptr = native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
678 log_text("Too many arguments. CallObjectMethod does not support that");
682 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
684 fill_callblock(obj, methodID->descriptor, blk, args, retType);
686 /* printf("parameter: obj: %p",blk[0].item); */
687 ret = asm_calljavafunction2double(methodID,
689 (argcount + 1) * sizeof(jni_callblock),
692 MFREE(blk, jni_callblock, argcount + 1);
693 /* printf("(CallObjectMethodV)-->%p\n",ret); */
699 /*************************** function: jclass_findfield ****************************
701 searches for field with specified name and type in a 'classinfo'-structur
702 if no such field is found NULL is returned
704 ************************************************************************************/
706 fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
709 /* printf(" FieldCount: %d\n",c->fieldscount);
710 utf_display(c->name); */
711 for (i = 0; i < c->fieldscount; i++) {
712 /* utf_display(c->fields[i].name);
714 utf_display(c->fields[i].descriptor);
716 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
717 return &(c->fields[i]);
720 if (c->super) return jclass_findfield(c->super,name,desc);
725 /********************* returns version of native method interface *****************/
727 jint GetVersion (JNIEnv* env)
732 /****************** loads a class from a buffer of raw class data *****************/
734 jclass DefineClass(JNIEnv* env, const char *name, jobject loader, const jbyte *buf, jsize len)
738 /* change suck-mode, so subsequent class_load will read from memory-buffer */
739 classload_buffer( (u1*) buf,len);
741 clazz = loader_load(utf_new_char ((char *) name));
743 /* restore old suck-mode */
744 classload_buffer(NULL,0);
750 /*************** loads locally defined class with the specified name **************/
752 jclass FindClass (JNIEnv* env, const char *name)
756 /* if (strcmp(name,"[B")==0) {
757 c = loader_load(utf_new_char("The_Array_Class"));
760 c = loader_load(utf_new_char_classname ((char *) name));
762 if (!c) exceptionptr = native_new_and_init(class_java_lang_ClassFormatError);
768 /***********************************************************************************
770 converts java.lang.reflect.Method or
771 java.lang.reflect.Constructor object to a method ID
773 **********************************************************************************/
775 jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
777 /* log_text("JNI-Call: FromReflectedMethod"); */
783 /*************** return superclass of the class represented by sub ****************/
785 jclass GetSuperclass(JNIEnv* env, jclass sub)
789 c = ((classinfo*) sub)->super;
793 use_class_as_object(c);
799 /*********************** check whether sub can be cast to sup ********************/
801 jboolean IsAssignableForm(JNIEnv* env, jclass sub, jclass sup)
803 return builtin_isanysubclass(sub, sup);
807 /***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
809 jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
811 /* log_text("JNI-Call: ToReflectedField"); */
817 /***************** throw java.lang.Throwable object ******************************/
819 jint Throw(JNIEnv* env, jthrowable obj)
821 exceptionptr = (java_objectheader*) obj;
827 /***********************************************************************************
829 create exception object from the class clazz with the
830 specified message and cause it to be thrown
832 **********************************************************************************/
835 jint ThrowNew (JNIEnv* env, jclass clazz, const char *msg)
837 java_lang_Throwable *o;
839 /* instantiate exception object */
840 o = (java_lang_Throwable *) native_new_and_init ((classinfo*) clazz);
844 o->detailMessage = (java_lang_String*) javastring_new_char((char *) msg);
846 exceptionptr = (java_objectheader*) o;
850 /************************* check if exception occured *****************************/
852 jthrowable ExceptionOccurred (JNIEnv* env)
854 return (jthrowable) exceptionptr;
857 /********** print exception and a backtrace of the stack (for debugging) **********/
859 void ExceptionDescribe (JNIEnv* env)
861 utf_display(exceptionptr->vftbl->class->name);
867 /******************* clear any exception currently being thrown *******************/
869 void ExceptionClear (JNIEnv* env)
875 /********** raises a fatal error and does not expect the VM to recover ************/
877 void FatalError (JNIEnv* env, const char *msg)
882 /******************* creates a new local reference frame **************************/
884 jint PushLocalFrame(JNIEnv* env, jint capacity)
891 /**************** Pops off the current local reference frame **********************/
893 jobject PopLocalFrame(JNIEnv* env, jobject result)
901 /** Creates a new global reference to the object referred to by the obj argument **/
903 jobject NewGlobalRef(JNIEnv* env, jobject lobj)
908 /************* Deletes the global reference pointed to by globalRef **************/
910 void DeleteGlobalRef (JNIEnv* env, jobject gref)
916 /*************** Deletes the local reference pointed to by localRef ***************/
918 void DeleteLocalRef (JNIEnv* env, jobject localRef)
923 /********** Tests whether two references refer to the same Java object ************/
925 jboolean IsSameObject (JNIEnv* env, jobject obj1, jobject obj2)
930 /***** Creates a new local reference that refers to the same object as ref *******/
932 jobject NewLocalRef (JNIEnv* env, jobject ref)
937 /***********************************************************************************
939 Ensures that at least a given number of local references can
940 be created in the current thread
942 **********************************************************************************/
944 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
946 return 0; /* return 0 on success */
950 /********* Allocates a new Java object without invoking a constructor *************/
952 jobject AllocObject (JNIEnv* env, jclass clazz)
954 java_objectheader *o = builtin_new(clazz);
959 /***********************************************************************************
961 Constructs a new Java object
962 arguments that are to be passed to the constructor are placed after methodID
964 ***********************************************************************************/
966 jobject NewObject (JNIEnv* env, jclass clazz, jmethodID methodID, ...)
968 java_objectheader *o;
970 int argcount=get_parametercount(methodID);
974 /* log_text("JNI-Call: NewObject"); */
977 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
978 log_text("Too many arguments. NewObject does not support that");
983 o = builtin_new (clazz); /* create object */
987 va_start(vaargs,methodID);
988 for (i=0;i<argcount;i++) {
989 args[i]=va_arg(vaargs,void*);
992 asm_calljavafunction(methodID,o,args[0],args[1],args[2]);
998 /***********************************************************************************
1000 Constructs a new Java object
1001 arguments that are to be passed to the constructor are placed in va_list args
1003 ***********************************************************************************/
1005 jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
1007 /* log_text("JNI-Call: NewObjectV"); */
1013 /***********************************************************************************
1015 Constructs a new Java object
1016 arguments that are to be passed to the constructor are placed in
1017 args array of jvalues
1019 ***********************************************************************************/
1021 jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
1023 /* log_text("JNI-Call: NewObjectA"); */
1029 /************************ returns the class of an object **************************/
1031 jclass GetObjectClass(JNIEnv* env, jobject obj)
1033 classinfo *c = obj->vftbl->class;
1034 /* log_text("GetObjectClass");
1035 utf_display(obj->vftbl->class->name);*/
1036 use_class_as_object(c);
1038 /*printf("\nPointer: %p\n",c);*/
1043 /************* tests whether an object is an instance of a class ******************/
1045 jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz)
1047 return builtin_instanceof(obj,clazz);
1051 /***************** converts a java.lang.reflect.Field to a field ID ***************/
1053 jfieldID FromReflectedField(JNIEnv* env, jobject field)
1055 log_text("JNI-Call: FromReflectedField");
1061 /**********************************************************************************
1063 converts a method ID to a java.lang.reflect.Method or
1064 java.lang.reflect.Constructor object
1066 **********************************************************************************/
1068 jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
1070 log_text("JNI-Call: ToReflectedMethod");
1076 /**************** returns the method ID for an instance method ********************/
1078 jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, const char *sig)
1082 m = class_resolvemethod (
1084 utf_new_char ((char*) name),
1085 utf_new_char ((char*) sig)
1088 if (!m) exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
1094 /******************** JNI-functions for calling instance methods ******************/
1096 jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1101 /* log_text("JNI-Call: CallObjectMethod");*/
1103 va_start(vaargs, methodID);
1104 ret = callObjectMethod(obj, methodID, vaargs);
1111 jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1113 return callObjectMethod(obj,methodID,args);
1117 jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1119 log_text("JNI-Call: CallObjectMethodA");
1127 jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1132 /* log_text("JNI-Call: CallBooleanMethod");*/
1134 va_start(vaargs,methodID);
1135 ret = (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',vaargs);
1141 jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1143 return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',args);
1147 jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1149 log_text("JNI-Call: CallBooleanMethodA");
1154 jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1159 /* log_text("JNI-Call: CallVyteMethod");*/
1161 va_start(vaargs,methodID);
1162 ret = callIntegerMethod(obj,get_virtual(obj,methodID),'B',vaargs);
1168 jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1170 /* log_text("JNI-Call: CallByteMethodV");*/
1171 return callIntegerMethod(obj,methodID,'B',args);
1175 jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1177 log_text("JNI-Call: CallByteMethodA");
1183 jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1188 /* log_text("JNI-Call: CallCharMethod");*/
1190 va_start(vaargs,methodID);
1191 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'C', vaargs);
1198 jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1200 /* log_text("JNI-Call: CallCharMethodV");*/
1201 return callIntegerMethod(obj,get_virtual(obj,methodID),'C',args);
1205 jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1207 log_text("JNI-Call: CallCharMethodA");
1213 jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1218 /* log_text("JNI-Call: CallShortMethod");*/
1220 va_start(vaargs, methodID);
1221 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'S', vaargs);
1228 jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1230 return callIntegerMethod(obj, get_virtual(obj, methodID), 'S', args);
1234 jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1236 log_text("JNI-Call: CallShortMethodA");
1243 jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1248 va_start(vaargs,methodID);
1249 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'I', vaargs);
1256 jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1258 return callIntegerMethod(obj, get_virtual(obj, methodID), 'I', args);
1262 jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1264 log_text("JNI-Call: CallIntMethodA");
1271 jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1273 log_text("JNI-Call: CallLongMethod");
1279 jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1281 log_text("JNI-Call: CallLongMethodV");
1287 jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1289 log_text("JNI-Call: CallLongMethodA");
1296 jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1301 /* log_text("JNI-Call: CallFloatMethod");*/
1303 va_start(vaargs,methodID);
1304 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'F');
1311 jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1313 log_text("JNI-Call: CallFloatMethodV");
1314 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'F');
1318 jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1320 log_text("JNI-Call: CallFloatMethodA");
1327 jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1332 /* log_text("JNI-Call: CallDoubleMethod");*/
1334 va_start(vaargs,methodID);
1335 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'D');
1342 jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1344 log_text("JNI-Call: CallDoubleMethodV");
1345 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'D');
1349 jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1351 log_text("JNI-Call: CallDoubleMethodA");
1357 void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1361 /* log_text("JNI-Call: CallVoidMethod");*/
1363 va_start(vaargs,methodID);
1364 (void) callIntegerMethod(obj, get_virtual(obj, methodID), 'V', vaargs);
1369 void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1371 log_text("JNI-Call: CallVoidMethodV");
1372 (void)callIntegerMethod(obj,get_virtual(obj,methodID),'V',args);
1376 void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1378 log_text("JNI-Call: CallVoidMethodA");
1383 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1385 log_text("JNI-Call: CallNonvirtualObjectMethod");
1391 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1393 log_text("JNI-Call: CallNonvirtualObjectMethodV");
1399 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1401 log_text("JNI-Call: CallNonvirtualObjectMethodA");
1408 jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1413 /* log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
1415 va_start(vaargs,methodID);
1416 ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',vaargs);
1423 jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1425 /* log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
1426 return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',args);
1430 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1432 log_text("JNI-Call: CallNonvirtualBooleanMethodA");
1439 jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1444 /* log_text("JNI-Call: CallNonvirutalByteMethod");*/
1446 va_start(vaargs,methodID);
1447 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',vaargs);
1453 jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1455 /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
1456 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',args);
1461 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1463 log_text("JNI-Call: CallNonvirtualByteMethodA");
1470 jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1475 /* log_text("JNI-Call: CallNonVirtualCharMethod");*/
1477 va_start(vaargs,methodID);
1478 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',vaargs);
1484 jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1486 /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
1487 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',args);
1491 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1493 log_text("JNI-Call: CallNonvirtualCharMethodA");
1500 jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1505 /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
1507 va_start(vaargs,methodID);
1508 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',vaargs);
1514 jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1516 /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
1517 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',args);
1521 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1523 log_text("JNI-Call: CallNonvirtualShortMethodA");
1530 jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1536 /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
1538 va_start(vaargs,methodID);
1539 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',vaargs);
1545 jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1547 /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
1548 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',args);
1552 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1554 log_text("JNI-Call: CallNonvirtualIntMethodA");
1561 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1563 log_text("JNI-Call: CallNonvirtualLongMethod");
1569 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1571 log_text("JNI-Call: CallNonvirtualLongMethodV");
1577 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1579 log_text("JNI-Call: CallNonvirtualLongMethodA");
1586 jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1591 /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
1594 va_start(vaargs,methodID);
1595 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'F');
1602 jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1604 log_text("JNI-Call: CallNonvirtualFloatMethodV");
1605 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'F');
1609 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1611 log_text("JNI-Call: CallNonvirtualFloatMethodA");
1618 jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1622 log_text("JNI-Call: CallNonvirtualDoubleMethod");
1624 va_start(vaargs,methodID);
1625 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'D');
1632 jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1634 /* log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
1635 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'D');
1639 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1641 log_text("JNI-Call: CallNonvirtualDoubleMethodA");
1648 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1652 /* log_text("JNI-Call: CallNonvirtualVoidMethod");*/
1654 va_start(vaargs,methodID);
1655 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',vaargs);
1661 void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1663 /* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
1665 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',args);
1670 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1672 log_text("JNI-Call: CallNonvirtualVoidMethodA");
1675 /************************* JNI-functions for accessing fields ************************/
1677 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1681 /* log_text("========================= searching for:");
1684 f = jclass_findfield(clazz,
1685 utf_new_char ((char*) name),
1686 utf_new_char ((char*) sig)
1690 /* utf_display(clazz->name);
1693 exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldError);
1698 /*************************** retrieve fieldid, abort on error ************************/
1700 jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig)
1702 jfieldID id = GetFieldID(env, clazz, name, sig);
1706 utf_display(clazz->name);
1707 log_text("\nfield:");
1712 panic("setfield_critical failed");
1717 jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
1719 return getField(obj,jobject,fieldID);
1722 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
1724 return getField(obj,jboolean,fieldID);
1728 jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
1730 return getField(obj,jbyte,fieldID);
1734 jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
1736 return getField(obj,jchar,fieldID);
1740 jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
1742 return getField(obj,jshort,fieldID);
1746 jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
1748 return getField(obj,jint,fieldID);
1752 jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
1754 return getField(obj,jlong,fieldID);
1758 jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
1760 return getField(obj,jfloat,fieldID);
1764 jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
1766 return getField(obj,jdouble,fieldID);
1769 void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
1771 setField(obj,jobject,fieldID,val);
1775 void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
1777 setField(obj,jboolean,fieldID,val);
1781 void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
1783 setField(obj,jbyte,fieldID,val);
1787 void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
1789 setField(obj,jchar,fieldID,val);
1793 void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
1795 setField(obj,jshort,fieldID,val);
1799 void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
1801 setField(obj,jint,fieldID,val);
1805 void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
1807 setField(obj,jlong,fieldID,val);
1811 void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
1813 setField(obj,jfloat,fieldID,val);
1817 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
1819 setField(obj,jdouble,fieldID,val);
1822 /**************** JNI-functions for calling static methods **********************/
1824 jmethodID GetStaticMethodID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1828 m = class_resolvemethod (
1830 utf_new_char ((char*) name),
1831 utf_new_char ((char*) sig)
1834 if (!m) exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
1839 jobject CallStaticObjectMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1841 log_text("JNI-Call: CallStaticObjectMethod");
1847 jobject CallStaticObjectMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1849 log_text("JNI-Call: CallStaticObjectMethodV");
1855 jobject CallStaticObjectMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1857 log_text("JNI-Call: CallStaticObjectMethodA");
1863 jboolean CallStaticBooleanMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1868 /* log_text("JNI-Call: CallStaticBooleanMethod");*/
1870 va_start(vaargs,methodID);
1871 ret = (jboolean)callIntegerMethod(0,methodID,'Z',vaargs);
1878 jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1880 return (jboolean) callIntegerMethod(0, methodID, 'Z', args);
1883 jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1885 log_text("JNI-Call: CallStaticBooleanMethodA");
1891 jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1896 /* log_text("JNI-Call: CallStaticByteMethod");*/
1898 va_start(vaargs, methodID);
1899 ret = (jbyte) callIntegerMethod(0, methodID, 'B', vaargs);
1906 jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1908 return (jbyte) callIntegerMethod(0, methodID, 'B', args);
1912 jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1914 log_text("JNI-Call: CallStaticByteMethodA");
1920 jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1925 /* log_text("JNI-Call: CallStaticByteMethod");*/
1927 va_start(vaargs, methodID);
1928 ret = (jchar) callIntegerMethod(0, methodID, 'C', vaargs);
1935 jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1937 return (jchar) callIntegerMethod(0, methodID, 'C', args);
1941 jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1943 log_text("JNI-Call: CallStaticCharMethodA");
1950 jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1955 /* log_text("JNI-Call: CallStaticByteMethod");*/
1957 va_start(vaargs,methodID);
1958 ret = (jshort) callIntegerMethod(0, methodID, 'S', vaargs);
1965 jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1967 /*log_text("JNI-Call: CallStaticShortMethodV");*/
1968 return (jshort) callIntegerMethod(0, methodID, 'S', args);
1972 jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1974 log_text("JNI-Call: CallStaticShortMethodA");
1981 jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1986 /* log_text("JNI-Call: CallStaticIntMethod");*/
1988 va_start(vaargs, methodID);
1989 ret = callIntegerMethod(0, methodID, 'I', vaargs);
1996 jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1998 log_text("JNI-Call: CallStaticIntMethodV");
2000 return callIntegerMethod(0, methodID, 'I', args);
2004 jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2006 log_text("JNI-Call: CallStaticIntMethodA");
2013 jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2018 /* log_text("JNI-Call: CallStaticLongMethod");*/
2020 va_start(vaargs, methodID);
2021 ret = callLongMethod(0, methodID, vaargs);
2028 jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2030 log_text("JNI-Call: CallStaticLongMethodV");
2032 return callLongMethod(0,methodID,args);
2036 jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2038 log_text("JNI-Call: CallStaticLongMethodA");
2045 jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2050 /* log_text("JNI-Call: CallStaticLongMethod");*/
2052 va_start(vaargs, methodID);
2053 ret = callFloatMethod(0, methodID, vaargs, 'F');
2060 jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2063 return callFloatMethod(0, methodID, args, 'F');
2068 jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2070 log_text("JNI-Call: CallStaticFloatMethodA");
2077 jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2082 /* log_text("JNI-Call: CallStaticDoubleMethod");*/
2084 va_start(vaargs,methodID);
2085 ret = callFloatMethod(0, methodID, vaargs, 'D');
2092 jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2094 log_text("JNI-Call: CallStaticDoubleMethodV");
2096 return callFloatMethod(0, methodID, args, 'D');
2100 jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2102 log_text("JNI-Call: CallStaticDoubleMethodA");
2108 void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
2112 /* log_text("JNI-Call: CallStaticVoidMethod");*/
2114 va_start(vaargs, methodID);
2115 (void) callIntegerMethod(0, methodID, 'V', vaargs);
2120 void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
2122 log_text("JNI-Call: CallStaticVoidMethodV");
2123 (void)callIntegerMethod(0, methodID, 'V', args);
2127 void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
2129 log_text("JNI-Call: CallStaticVoidMethodA");
2133 /****************** JNI-functions for accessing static fields ********************/
2135 jfieldID GetStaticFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
2139 f = jclass_findfield(clazz,
2140 utf_new_char ((char*) name),
2141 utf_new_char ((char*) sig)
2144 if (!f) exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldError);
2150 jobject GetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2153 return fieldID->value.a;
2157 jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2160 return fieldID->value.i;
2164 jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2167 return fieldID->value.i;
2171 jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2174 return fieldID->value.i;
2178 jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2181 return fieldID->value.i;
2185 jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2188 return fieldID->value.i;
2192 jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2195 return fieldID->value.l;
2199 jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2202 return fieldID->value.f;
2206 jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2209 return fieldID->value.d;
2214 void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
2217 fieldID->value.a = value;
2221 void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
2224 fieldID->value.i = value;
2228 void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
2231 fieldID->value.i = value;
2235 void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
2238 fieldID->value.i = value;
2242 void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
2245 fieldID->value.i = value;
2249 void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
2252 fieldID->value.i = value;
2256 void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
2259 fieldID->value.l = value;
2263 void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
2266 fieldID->value.f = value;
2270 void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
2273 fieldID->value.d = value;
2277 /***** create new java.lang.String object from an array of Unicode characters ****/
2279 jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
2282 java_lang_String *s;
2285 s = (java_lang_String*) builtin_new (class_java_lang_String);
2286 a = builtin_newarray_char (len);
2288 /* javastring or characterarray could not be created */
2289 if ( (!a) || (!s) ) return NULL;
2292 for (i=0; i<len; i++) a->data[i] = buf[i];
2301 static char emptyString[]="";
2302 static jchar emptyStringJ[]={0,0};
2304 /******************* returns the length of a Java string ***************************/
2306 jsize GetStringLength (JNIEnv *env, jstring str)
2308 return ((java_lang_String*) str)->count;
2312 /******************** convertes javastring to u2-array ****************************/
2314 u2 *javastring_tou2 (jstring so)
2316 java_lang_String *s = (java_lang_String*) so;
2321 if (!s) return NULL;
2324 if (!a) return NULL;
2326 /* allocate memory */
2327 stringbuffer = MNEW( u2 , s->count + 1 );
2330 for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
2332 /* terminate string */
2333 stringbuffer[i] = '\0';
2335 return stringbuffer;
2338 /********* returns a pointer to an array of Unicode characters of the string *******/
2340 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
2342 jchar *jc=javastring_tou2(str);
2345 if (isCopy) *isCopy=JNI_TRUE;
2348 if (isCopy) *isCopy=JNI_TRUE;
2349 return emptyStringJ;
2352 /**************** native code no longer needs access to chars **********************/
2354 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
2356 if (chars==emptyStringJ) return;
2357 MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count+1);
2360 /************ create new java.lang.String object from utf8-characterarray **********/
2362 jstring NewStringUTF (JNIEnv *env, const char *utf)
2364 /* log_text("NewStringUTF called");*/
2365 return javastring_new(utf_new_char(utf));
2368 /****************** returns the utf8 length in bytes of a string *******************/
2370 jsize GetStringUTFLength (JNIEnv *env, jstring string)
2372 java_lang_String *s = (java_lang_String*) string;
2374 return (jsize) u2_utflength(s->value->data, s->count);
2377 /************ converts a Javastring to an array of UTF-8 characters ****************/
2379 const char* GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy)
2382 if (verbose) log_text("GetStringUTFChars:");
2384 u=javastring_toutf((java_lang_String*) string,false);
2385 if (isCopy) *isCopy=JNI_FALSE;
2393 /***************** native code no longer needs access to utf ***********************/
2395 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
2397 /*we don't release utf chars right now, perhaps that should be done later. Since there is always one reference
2398 the garbage collector will never get them*/
2400 log_text("JNI-Call: ReleaseStringUTFChars");
2401 utf_display(utf_new_char(chars));
2405 /************************** array operations ***************************************/
2407 jsize GetArrayLength (JNIEnv *env, jarray array)
2412 jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
2414 java_objectarray *j;
2416 exceptionptr=proto_java_lang_NegativeArraySizeException;
2419 j = builtin_anewarray (len, clazz);
2420 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2424 jobject GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
2428 if (index<array->header.size)
2429 j = array->data[index];
2431 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2436 void SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index, jobject val)
2438 if (index>=array->header.size)
2439 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2442 /* check if the class of value is a subclass of the element class of the array */
2444 if (!builtin_canstore((java_objectarray*)array,(java_objectheader*)val))
2445 exceptionptr = proto_java_lang_ArrayStoreException;
2447 array->data[index] = val;
2453 jbooleanArray NewBooleanArray (JNIEnv *env, jsize len)
2455 java_booleanarray *j;
2457 exceptionptr=proto_java_lang_NegativeArraySizeException;
2460 j = builtin_newarray_boolean(len);
2461 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2466 jbyteArray NewByteArray (JNIEnv *env, jsize len)
2470 exceptionptr=proto_java_lang_NegativeArraySizeException;
2473 j = builtin_newarray_byte(len);
2474 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2479 jcharArray NewCharArray (JNIEnv *env, jsize len)
2483 exceptionptr=proto_java_lang_NegativeArraySizeException;
2486 j = builtin_newarray_char(len);
2487 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2492 jshortArray NewShortArray (JNIEnv *env, jsize len)
2496 exceptionptr=proto_java_lang_NegativeArraySizeException;
2499 j = builtin_newarray_short(len);
2500 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2505 jintArray NewIntArray (JNIEnv *env, jsize len)
2509 exceptionptr=proto_java_lang_NegativeArraySizeException;
2512 j = builtin_newarray_int(len);
2513 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2518 jlongArray NewLongArray (JNIEnv *env, jsize len)
2522 exceptionptr=proto_java_lang_NegativeArraySizeException;
2525 j = builtin_newarray_long(len);
2526 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2531 jfloatArray NewFloatArray (JNIEnv *env, jsize len)
2535 exceptionptr=proto_java_lang_NegativeArraySizeException;
2538 j = builtin_newarray_float(len);
2539 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2544 jdoubleArray NewDoubleArray (JNIEnv *env, jsize len)
2546 java_doublearray *j;
2548 exceptionptr=proto_java_lang_NegativeArraySizeException;
2551 j = builtin_newarray_double(len);
2552 if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2557 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
2559 if (isCopy) *isCopy = JNI_FALSE;
2564 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
2566 if (isCopy) *isCopy = JNI_FALSE;
2571 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
2573 if (isCopy) *isCopy = JNI_FALSE;
2578 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
2580 if (isCopy) *isCopy = JNI_FALSE;
2585 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
2587 if (isCopy) *isCopy = JNI_FALSE;
2592 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
2594 if (isCopy) *isCopy = JNI_FALSE;
2599 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
2601 if (isCopy) *isCopy = JNI_FALSE;
2606 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
2608 if (isCopy) *isCopy = JNI_FALSE;
2614 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
2620 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
2626 void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
2632 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
2638 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
2644 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
2650 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
2656 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
2661 void GetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *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 GetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *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 GetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2681 if (start<0 || len<0 || start+len>array->header.size)
2682 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2684 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2688 void GetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2690 if (start<0 || len<0 || start+len>array->header.size)
2691 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2693 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2697 void GetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2699 if (start<0 || len<0 || start+len>array->header.size)
2700 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2702 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2706 void GetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2708 if (start<0 || len<0 || start+len>array->header.size)
2709 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2711 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2715 void GetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2717 if (start<0 || len<0 || start+len>array->header.size)
2718 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2720 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2724 void GetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2726 if (start<0 || len<0 || start+len>array->header.size)
2727 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2729 memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2733 void SetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2735 if (start<0 || len<0 || start+len>array->header.size)
2736 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2738 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2742 void SetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2744 if (start<0 || len<0 || start+len>array->header.size)
2745 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2747 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2751 void SetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2753 if (start<0 || len<0 || start+len>array->header.size)
2754 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2756 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2761 void SetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2763 if (start<0 || len<0 || start+len>array->header.size)
2764 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2766 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2770 void SetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2772 if (start<0 || len<0 || start+len>array->header.size)
2773 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2775 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2779 void SetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2781 if (start<0 || len<0 || start+len>array->header.size)
2782 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2784 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2788 void SetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2790 if (start<0 || len<0 || start+len>array->header.size)
2791 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2793 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2797 void SetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2799 if (start<0 || len<0 || start+len>array->header.size)
2800 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2802 memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2805 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
2807 log_text("JNI-Call: RegisterNatives");
2812 jint UnregisterNatives (JNIEnv* env, jclass clazz)
2814 log_text("JNI-Call: UnregisterNatives");
2818 /******************************* monitor operations ********************************/
2820 jint MonitorEnter (JNIEnv* env, jobject obj)
2822 builtin_monitorenter(obj);
2827 jint MonitorExit (JNIEnv* env, jobject obj)
2829 builtin_monitorexit(obj);
2834 /************************************* JavaVM interface ****************************/
2836 #error CPP mode not supported yet
2838 jint GetJavaVM (JNIEnv* env, JavaVM **vm)
2840 log_text("JNI-Call: GetJavaVM");
2844 #endif /*__cplusplus*/
2846 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
2848 log_text("JNI-Call: GetStringRegion");
2852 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
2854 log_text("JNI-Call: GetStringUTFRegion");
2858 /****************** obtain direct pointer to array elements ***********************/
2860 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
2862 java_objectheader *s = (java_objectheader*) array;
2863 arraydescriptor *desc = s->vftbl->arraydesc;
2865 if (!desc) return NULL;
2867 return ((u1*)s) + desc->dataoffset;
2871 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
2873 log_text("JNI-Call: ReleasePrimitiveArrayCritical");
2878 /********* returns a pointer to an array of Unicode characters of the string *******/
2880 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
2882 log_text("JNI-Call: GetStringCritical");
2884 return GetStringChars(env,string,isCopy);
2887 /**************** native code no longer needs access to chars **********************/
2889 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
2891 log_text("JNI-Call: ReleaseStringCritical");
2893 ReleaseStringChars(env,string,cstring);
2897 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
2899 log_text("JNI-Call: NewWeakGlobalRef");
2905 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
2907 log_text("JNI-Call: DeleteWeakGlobalRef");
2913 /******************************* check for pending exception ***********************/
2916 jboolean ExceptionCheck(JNIEnv* env)
2918 log_text("JNI-Call: ExceptionCheck");
2920 return exceptionptr ? JNI_TRUE : JNI_FALSE;
2928 jint DestroyJavaVM(JavaVM *vm)
2930 log_text("DestroyJavaVM called");
2936 jint AttachCurrentThread(JavaVM *vm, void **par1, void *par2)
2938 log_text("AttachCurrentThread called");
2944 jint DetachCurrentThread(JavaVM *vm)
2946 log_text("DetachCurrentThread called");
2952 jint GetEnv(JavaVM *vm, void **environment, jint jniversion)
2954 *environment = &env;
2960 jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
2962 log_text("AttachCurrentThreadAsDaemon called");
2977 /********************************* JNI invocation table ******************************/
2979 struct _JavaVM javaVMTable={
2984 &AttachCurrentThread,
2985 &DetachCurrentThread,
2987 &AttachCurrentThreadAsDaemon
2990 JavaVM javaVM = &javaVMTable;
2993 /********************************* JNI function table ******************************/
2995 struct JNI_Table envTable = {
3003 &FromReflectedMethod,
3004 &FromReflectedField,
3022 &EnsureLocalCapacity,
3034 &CallBooleanMethodV,
3035 &CallBooleanMethodA,
3060 &CallNonvirtualObjectMethod,
3061 &CallNonvirtualObjectMethodV,
3062 &CallNonvirtualObjectMethodA,
3063 &CallNonvirtualBooleanMethod,
3064 &CallNonvirtualBooleanMethodV,
3065 &CallNonvirtualBooleanMethodA,
3066 &CallNonvirtualByteMethod,
3067 &CallNonvirtualByteMethodV,
3068 &CallNonvirtualByteMethodA,
3069 &CallNonvirtualCharMethod,
3070 &CallNonvirtualCharMethodV,
3071 &CallNonvirtualCharMethodA,
3072 &CallNonvirtualShortMethod,
3073 &CallNonvirtualShortMethodV,
3074 &CallNonvirtualShortMethodA,
3075 &CallNonvirtualIntMethod,
3076 &CallNonvirtualIntMethodV,
3077 &CallNonvirtualIntMethodA,
3078 &CallNonvirtualLongMethod,
3079 &CallNonvirtualLongMethodV,
3080 &CallNonvirtualLongMethodA,
3081 &CallNonvirtualFloatMethod,
3082 &CallNonvirtualFloatMethodV,
3083 &CallNonvirtualFloatMethodA,
3084 &CallNonvirtualDoubleMethod,
3085 &CallNonvirtualDoubleMethodV,
3086 &CallNonvirtualDoubleMethodA,
3087 &CallNonvirtualVoidMethod,
3088 &CallNonvirtualVoidMethodV,
3089 &CallNonvirtualVoidMethodA,
3110 &CallStaticObjectMethod,
3111 &CallStaticObjectMethodV,
3112 &CallStaticObjectMethodA,
3113 &CallStaticBooleanMethod,
3114 &CallStaticBooleanMethodV,
3115 &CallStaticBooleanMethodA,
3116 &CallStaticByteMethod,
3117 &CallStaticByteMethodV,
3118 &CallStaticByteMethodA,
3119 &CallStaticCharMethod,
3120 &CallStaticCharMethodV,
3121 &CallStaticCharMethodA,
3122 &CallStaticShortMethod,
3123 &CallStaticShortMethodV,
3124 &CallStaticShortMethodA,
3125 &CallStaticIntMethod,
3126 &CallStaticIntMethodV,
3127 &CallStaticIntMethodA,
3128 &CallStaticLongMethod,
3129 &CallStaticLongMethodV,
3130 &CallStaticLongMethodA,
3131 &CallStaticFloatMethod,
3132 &CallStaticFloatMethodV,
3133 &CallStaticFloatMethodA,
3134 &CallStaticDoubleMethod,
3135 &CallStaticDoubleMethodV,
3136 &CallStaticDoubleMethodA,
3137 &CallStaticVoidMethod,
3138 &CallStaticVoidMethodV,
3139 &CallStaticVoidMethodA,
3141 &GetStaticObjectField,
3142 &GetStaticBooleanField,
3143 &GetStaticByteField,
3144 &GetStaticCharField,
3145 &GetStaticShortField,
3147 &GetStaticLongField,
3148 &GetStaticFloatField,
3149 &GetStaticDoubleField,
3150 &SetStaticObjectField,
3151 &SetStaticBooleanField,
3152 &SetStaticByteField,
3153 &SetStaticCharField,
3154 &SetStaticShortField,
3156 &SetStaticLongField,
3157 &SetStaticFloatField,
3158 &SetStaticDoubleField,
3162 &ReleaseStringChars,
3164 &GetStringUTFLength,
3166 &ReleaseStringUTFChars,
3169 &GetObjectArrayElement,
3170 &SetObjectArrayElement,
3179 &GetBooleanArrayElements,
3180 &GetByteArrayElements,
3181 &GetCharArrayElements,
3182 &GetShortArrayElements,
3183 &GetIntArrayElements,
3184 &GetLongArrayElements,
3185 &GetFloatArrayElements,
3186 &GetDoubleArrayElements,
3187 &ReleaseBooleanArrayElements,
3188 &ReleaseByteArrayElements,
3189 &ReleaseCharArrayElements,
3190 &ReleaseShortArrayElements,
3191 &ReleaseIntArrayElements,
3192 &ReleaseLongArrayElements,
3193 &ReleaseFloatArrayElements,
3194 &ReleaseDoubleArrayElements,
3195 &GetBooleanArrayRegion,
3196 &GetByteArrayRegion,
3197 &GetCharArrayRegion,
3198 &GetShortArrayRegion,
3200 &GetLongArrayRegion,
3201 &GetFloatArrayRegion,
3202 &GetDoubleArrayRegion,
3203 &SetBooleanArrayRegion,
3204 &SetByteArrayRegion,
3205 &SetCharArrayRegion,
3206 &SetShortArrayRegion,
3208 &SetLongArrayRegion,
3209 &SetFloatArrayRegion,
3210 &SetDoubleArrayRegion,
3217 &GetStringUTFRegion,
3218 &GetPrimitiveArrayCritical,
3219 &ReleasePrimitiveArrayCritical,
3221 &ReleaseStringCritical,
3223 &DeleteWeakGlobalRef,
3228 JNIEnv env = &envTable;
3237 jobject *jni_method_invokeNativeHelper(JNIEnv *env,struct methodinfo *methodID,jobject obj, java_objectarray *params) {
3244 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
3247 argcount=get_parametercount(methodID);
3249 if (obj && (!builtin_instanceof((java_objectheader*)obj,methodID->class))) {
3250 (*env)->ThrowNew(env,loader_load(utf_new_char("java/lang/IllegalArgumentException")),
3251 "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
3258 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
3259 log_text("Too many arguments. invokeNativeHelper does not support that");
3263 if ( ((!params) && (argcount!=0)) ||
3264 (params && (params->header.size!=argcount))
3266 exceptionptr = native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
3271 if (!(methodID->flags & ACC_STATIC) && (!obj)) {
3272 (*env)->ThrowNew(env,loader_load(utf_new_char("java/lang/NullPointerException")),
3273 "Static mismatch in Java_java_lang_reflect_Method_invokeNative");
3277 if ((methodID->flags & ACC_STATIC) && (obj)) obj=0;
3279 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
3281 retT=fill_callblock_objA(obj,methodID->descriptor,blk,params);
3284 case 'V': (void)asm_calljavafunction2(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3285 retVal=NULL; /*native_new_and_init(loader_load(utf_new_char("java/lang/Void")));*/
3289 intVal=(s4)asm_calljavafunction2(methodID,
3290 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3291 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Integer")));
3292 CallVoidMethod(env,retVal,
3293 class_resolvemethod(retVal->vftbl->class,
3294 utf_new_char("<init>"),utf_new_char("(I)V")),intVal);
3299 intVal=(s4)asm_calljavafunction2(methodID,
3300 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3301 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Byte")));
3302 CallVoidMethod(env,retVal,
3303 class_resolvemethod(retVal->vftbl->class,
3304 utf_new_char("<init>"),utf_new_char("(B)V")),intVal);
3309 intVal=(s4)asm_calljavafunction2(methodID,
3310 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3311 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Character")));
3312 CallVoidMethod(env,retVal,
3313 class_resolvemethod(retVal->vftbl->class,
3314 utf_new_char("<init>"),utf_new_char("(C)V")),intVal);
3319 intVal=(s4)asm_calljavafunction2(methodID,
3320 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3321 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Short")));
3322 CallVoidMethod(env,retVal,
3323 class_resolvemethod(retVal->vftbl->class,
3324 utf_new_char("<init>"),utf_new_char("(S)V")),intVal);
3329 intVal=(s4)asm_calljavafunction2(methodID,
3330 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3331 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Boolean")));
3332 CallVoidMethod(env,retVal,
3333 class_resolvemethod(retVal->vftbl->class,
3334 utf_new_char("<init>"),utf_new_char("(Z)V")),intVal);
3339 intVal=asm_calljavafunction2long(methodID,
3340 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3341 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Long")));
3342 CallVoidMethod(env,retVal,
3343 class_resolvemethod(retVal->vftbl->class,
3344 utf_new_char("<init>"),utf_new_char("(J)V")),intVal);
3349 floatVal=asm_calljavafunction2double(methodID,
3350 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3351 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Float")));
3352 CallVoidMethod(env,retVal,
3353 class_resolvemethod(retVal->vftbl->class,
3354 utf_new_char("<init>"),utf_new_char("(F)V")),floatVal);
3359 floatVal=asm_calljavafunction2double(methodID,
3360 argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3361 retVal=builtin_new(loader_load_sysclass(NULL,utf_new_char("java/lang/Double")));
3362 CallVoidMethod(env,retVal,
3363 class_resolvemethod(retVal->vftbl->class,
3364 utf_new_char("<init>"),utf_new_char("(D)V")),floatVal);
3368 case 'L': /* fall through */
3369 case '[': retVal=asm_calljavafunction2(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
3372 /* if this happens the acception has already been set by fill_callblock_objA*/
3373 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3377 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3380 java_objectheader *exceptionToWrap=exceptionptr;
3381 classinfo *ivtec=loader_load_sysclass(NULL,utf_new_char("java/lang/reflect/InvocationTargetException"));
3382 java_objectheader* ivte=builtin_new(ivtec);
3383 asm_calljavafunction(class_resolvemethod(ivtec,utf_new_char("<init>"),utf_new_char("(Ljava/lang/Throwable;)V")),
3384 ivte,exceptionToWrap,0,0);
3385 if (exceptionptr!=NULL) panic("jni.c: error while creating InvocationTargetException wrapper");
3395 * These are local overrides for various environment variables in Emacs.
3396 * Please do not remove this and leave it at the end of the file, where
3397 * Emacs will automagically detect them.
3398 * ---------------------------------------------------------------------
3401 * indent-tabs-mode: t