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 1173 2004-06-16 14:56:18Z jowenn $
44 #include "threads/thread.h"
45 #include "toolbox/logging.h"
46 #include "toolbox/memory.h"
47 #include "nat/java_lang_Byte.h"
48 #include "nat/java_lang_Character.h"
49 #include "nat/java_lang_Short.h"
50 #include "nat/java_lang_Integer.h"
51 #include "nat/java_lang_Boolean.h"
52 #include "nat/java_lang_Long.h"
53 #include "nat/java_lang_Float.h"
54 #include "nat/java_lang_Double.h"
55 #include "nat/java_lang_Throwable.h"
58 #define JNI_VERSION 0x00010002
61 #define PTR_TO_ITEM(ptr) ((u8)(size_t)(ptr))
63 static utf* utf_char = 0;
64 static utf* utf_bool = 0;
65 static utf* utf_byte =0;
66 static utf* utf_short = 0;
67 static utf* utf_int = 0;
68 static utf* utf_long = 0;
69 static utf* utf_float = 0;
70 static utf* utf_double = 0;
73 /********************* accessing instance-fields **********************************/
75 #define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
76 #define getField(obj,typ,var) *((typ*) ((long int) obj + (long int) var->offset))
77 #define setfield_critical(clazz,obj,name,sig,jdatatype,val) setField(obj,jdatatype,getFieldID_critical(env,clazz,name,sig),val);
81 u4 get_parametercount(methodinfo *m)
83 utf *descr = m->descriptor; /* method-descriptor */
84 char *utf_ptr = descr->text; /* current position in utf-text */
85 char *desc_end = utf_end(descr); /* points behind utf string */
86 u4 parametercount = 0;
91 /* determine number of parameters */
92 while (*utf_ptr != ')') {
93 get_type(&utf_ptr, desc_end, true);
97 return parametercount;
102 void fill_callblock(void *obj, utf *descr, jni_callblock blk[], va_list data, char ret)
104 char *utf__ptr = descr->text; /* current position in utf-text */
105 char **utf_ptr = &utf__ptr;
106 char *desc_end = utf_end(descr); /* points behind utf string */
112 log_text("fill_callblock");
119 /* determine number of parameters */
121 blk[0].itemtype = TYPE_ADR;
122 blk[0].item = PTR_TO_ITEM(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);
141 blk[cnt].itemtype = TYPE_INT;
142 dummy = va_arg(data, u4);
143 /*printf("fill_callblock: pos:%d, value:%d\n",cnt,dummy);*/
144 blk[cnt].item = (u8) dummy;
148 blk[cnt].itemtype = TYPE_LNG;
149 blk[cnt].item = (u8) va_arg(data, jlong);
153 blk[cnt].itemtype = TYPE_FLT;
154 *((jfloat *) (&blk[cnt].item)) = (jfloat) va_arg(data, jdouble);
158 blk[cnt].itemtype = TYPE_DBL;
159 *((jdouble *) (&blk[cnt].item)) = (jdouble) va_arg(data, jdouble);
163 panic ("V not allowed as function parameter");
167 while (utf_nextu2(utf_ptr) != ';')
168 blk[cnt].itemtype = TYPE_ADR;
169 blk[cnt].item = PTR_TO_ITEM(va_arg(data, void*));
176 /* char *start = *utf_ptr; */
178 while ((ch = utf_nextu2(utf_ptr)) == '[')
180 while (utf_nextu2(utf_ptr) != ';') {}
183 ch = utf_nextu2(utf_ptr);
184 blk[cnt].itemtype = TYPE_ADR;
185 blk[cnt].item = PTR_TO_ITEM(va_arg(data, void*));
192 /*the standard doesn't say anything about return value checking, but it appears to be usefull*/
193 c = utf_nextu2(utf_ptr);
194 c = utf_nextu2(utf_ptr);
195 /*printf("%c %c\n",ret,c);*/
197 if (!((c == 'L') || (c == '[')))
198 log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
200 log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
204 /* XXX it could be considered if we should do typechecking here in the future */
205 char fill_callblock_objA(void *obj, utf *descr, jni_callblock blk[], java_objectarray* params)
207 char *utf__ptr = descr->text; /* current position in utf-text */
208 char **utf_ptr = &utf__ptr;
209 char *desc_end = utf_end(descr); /* points behind utf string */
216 #if defined(USE_THREADS) && !defined(NATIVE_THREADS)
220 utf_char=utf_new_char("java/lang/Character");
221 utf_bool=utf_new_char("java/lang/Boolean");
222 utf_byte=utf_new_char("java/lang/Byte");
223 utf_short=utf_new_char("java/lang/Short");
224 utf_int=utf_new_char("java/lang/Integer");
225 utf_long=utf_new_char("java/lang/Long");
226 utf_float=utf_new_char("java/lang/Float");
227 utf_double=utf_new_char("java/lang/Double");
229 #if defined(USE_THREADS) && !defined(NATIVE_THREADS)
234 log_text("fill_callblock");
241 /* determine number of parameters */
243 blk[0].itemtype = TYPE_ADR;
244 blk[0].item = PTR_TO_ITEM(obj);
252 while (**utf_ptr != ')') {
253 if (*utf_ptr >= desc_end)
254 panic("illegal method descriptor");
256 /* primitive types */
257 switch (utf_nextu2(utf_ptr)) {
259 param = params->data[cnts];
261 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
264 if (param->vftbl->class->name == utf_byte) {
265 blk[cnt].itemtype = TYPE_INT;
266 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
269 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
275 param = params->data[cnts];
277 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
280 if (param->vftbl->class->name == utf_char) {
281 blk[cnt].itemtype = TYPE_INT;
282 blk[cnt].item = (u8) ((java_lang_Character *) param)->value;
285 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
291 param = params->data[cnts];
293 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
296 if (param->vftbl->class->name == utf_short) {
297 blk[cnt].itemtype = TYPE_INT;
298 blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
301 if (param->vftbl->class->name == utf_byte) {
302 blk[cnt].itemtype = TYPE_INT;
303 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
306 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
313 param = params->data[cnts];
315 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
318 if (param->vftbl->class->name == utf_bool) {
319 blk[cnt].itemtype = TYPE_INT;
320 blk[cnt].item = (u8) ((java_lang_Boolean *) param)->value;
323 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
329 /*log_text("fill_callblock_objA: param 'I'");*/
330 param = params->data[cnts];
332 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
335 if (param->vftbl->class->name == utf_int) {
336 blk[cnt].itemtype = TYPE_INT;
337 blk[cnt].item = (u8) ((java_lang_Integer *) param)->value;
338 /*printf("INT VALUE :%d\n",((struct java_lang_Integer * )param)->value);*/
340 if (param->vftbl->class->name == utf_short) {
341 blk[cnt].itemtype = TYPE_INT;
342 blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
345 if (param->vftbl->class->name == utf_byte) {
346 blk[cnt].itemtype = TYPE_INT;
347 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
350 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
358 param = params->data[cnts];
360 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
363 if (param->vftbl->class->name == utf_long) {
364 blk[cnt].itemtype = TYPE_LNG;
365 blk[cnt].item = (u8) ((java_lang_Long *) param)->value;
368 if (param->vftbl->class->name == utf_int) {
369 blk[cnt].itemtype = TYPE_LNG;
370 blk[cnt].item = (u8) ((java_lang_Integer *) param)->value;
373 if (param->vftbl->class->name == utf_short) {
374 blk[cnt].itemtype = TYPE_LNG;
375 blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
378 if (param->vftbl->class->name == utf_byte) {
379 blk[cnt].itemtype = TYPE_LNG;
380 blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
382 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
392 param = params->data[cnts];
394 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
398 if (param->vftbl->class->name == utf_float) {
399 blk[cnt].itemtype = TYPE_FLT;
400 *((jfloat *) (&blk[cnt].item)) = (jfloat) ((java_lang_Float *) param)->value;
403 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
409 param = params->data[cnts];
411 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
415 if (param->vftbl->class->name == utf_double) {
416 blk[cnt].itemtype = TYPE_DBL;
417 *((jdouble *) (&blk[cnt].item)) = (jdouble) ((java_lang_Float *) param)->value;
420 if (param->vftbl->class->name == utf_float) {
421 blk[cnt].itemtype = TYPE_DBL;
422 *((jdouble *) (&blk[cnt].item)) = (jdouble) ((java_lang_Float *) param)->value;
425 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
432 panic("V not allowed as function parameter");
437 char *start = (*utf_ptr) - 1;
440 while (utf_nextu2(utf_ptr) != ';')
441 end = (*utf_ptr) + 1;
443 if (!builtin_instanceof(params->data[cnts], class_from_descriptor(start, end, 0, CLASSLOAD_LOAD))) {
444 if (params->data[cnts] != 0) {
445 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
450 blk[cnt].itemtype = TYPE_ADR;
451 blk[cnt].item = PTR_TO_ITEM(params->data[cnts]);
457 char *start = (*utf_ptr) - 1;
461 while ((ch = utf_nextu2(utf_ptr)) == '[')
463 while (utf_nextu2(utf_ptr) != ';') {}
466 end = (*utf_ptr) - 1;
467 ch = utf_nextu2(utf_ptr);
469 if (!builtin_arrayinstanceof(params->data[cnts], class_from_descriptor(start, end, 0, CLASSLOAD_LOAD)->vftbl)) {
470 *exceptionptr = new_exception("java/lang/IllegalArgumentException");
474 blk[cnt].itemtype = TYPE_ADR;
475 blk[cnt].item = PTR_TO_ITEM(params->data[cnts]);
483 c = utf_nextu2(utf_ptr);
484 c = utf_nextu2(utf_ptr);
485 return c; /*return type needed usage of the right lowlevel methods*/
502 jmethodID get_virtual(jobject obj,jmethodID methodID) {
503 if (obj->vftbl->class==methodID->class) return methodID;
504 return class_resolvemethod (obj->vftbl->class, methodID->name, methodID->descriptor);
507 jmethodID get_nonvirtual(jclass clazz,jmethodID methodID) {
508 if (clazz==methodID->class) return methodID;
509 /*class_resolvemethod -> classfindmethod? (JOWENN)*/
510 return class_resolvemethod (clazz, methodID->name, methodID->descriptor);
515 jobject callObjectMethod (jobject obj, jmethodID methodID, va_list args)
522 log_text("JNI-Call: CallObjectMethodV");
523 utf_display(methodID->name);
524 utf_display(methodID->descriptor);
525 printf("\nParmaeter count: %d\n",argcount);
526 utf_display(obj->vftbl->class->name);
531 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
535 argcount = get_parametercount(methodID);
537 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
538 ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
539 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
543 if (obj && !builtin_instanceof(obj, methodID->class)) {
544 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
549 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
550 log_text("Too many arguments. CallObjectMethod does not support that");
554 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
556 fill_callblock(obj, methodID->descriptor, blk, args, 'O');
558 /* printf("parameter: obj: %p",blk[0].item); */
559 ret = asm_calljavafunction2(methodID,
561 (argcount + 1) * sizeof(jni_callblock),
564 MFREE(blk, jni_callblock, argcount + 1);
565 /* printf("(CallObjectMethodV)-->%p\n",ret); */
571 core function for integer class methods (bool, byte, short, integer)
572 This is basically needed for i386
574 jint callIntegerMethod(jobject obj, jmethodID methodID, char retType, va_list args)
580 /* printf("%p, %c\n",retType,methodID,retType);*/
583 log_text("JNI-Call: CallObjectMethodV");
584 utf_display(methodID->name);
585 utf_display(methodID->descriptor);
586 printf("\nParmaeter count: %d\n",argcount);
587 utf_display(obj->vftbl->class->name);
591 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
595 argcount = get_parametercount(methodID);
597 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
598 ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
599 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
603 if (obj && !builtin_instanceof(obj, methodID->class)) {
604 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
610 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
611 log_text("Too many arguments. CallIntegerMethod does not support that");
615 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
617 fill_callblock(obj, methodID->descriptor, blk, args, retType);
619 /* printf("parameter: obj: %p",blk[0].item); */
620 ret = (jint) asm_calljavafunction2(methodID,
622 (argcount + 1) * sizeof(jni_callblock),
625 MFREE(blk, jni_callblock, argcount + 1);
626 /* printf("(CallObjectMethodV)-->%p\n",ret); */
632 /*core function for long class functions*/
633 jlong callLongMethod(jobject obj, jmethodID methodID, va_list args)
640 log_text("JNI-Call: CallObjectMethodV");
641 utf_display(methodID->name);
642 utf_display(methodID->descriptor);
643 printf("\nParmaeter count: %d\n",argcount);
644 utf_display(obj->vftbl->class->name);
648 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
652 argcount = get_parametercount(methodID);
654 if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
655 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
656 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
660 if (obj && !builtin_instanceof(obj,methodID->class)) {
661 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
667 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
668 log_text("Too many arguments. CallObjectMethod does not support that");
672 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
674 fill_callblock(obj, methodID->descriptor, blk, args, 'L');
676 /* printf("parameter: obj: %p",blk[0].item); */
677 ret = asm_calljavafunction2long(methodID,
679 (argcount + 1) * sizeof(jni_callblock),
682 MFREE(blk, jni_callblock, argcount + 1);
683 /* printf("(CallObjectMethodV)-->%p\n",ret); */
689 /*core function for float class methods (float,double)*/
690 jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,char retType)
692 int argcount = get_parametercount(methodID);
697 log_text("JNI-Call: CallObjectMethodV");
698 utf_display(methodID->name);
699 utf_display(methodID->descriptor);
700 printf("\nParmaeter count: %d\n",argcount);
701 utf_display(obj->vftbl->class->name);
706 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
707 log_text("Too many arguments. CallObjectMethod does not support that");
711 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
713 fill_callblock(obj, methodID->descriptor, blk, args, retType);
715 /* printf("parameter: obj: %p",blk[0].item); */
716 ret = asm_calljavafunction2double(methodID,
718 (argcount + 1) * sizeof(jni_callblock),
721 MFREE(blk, jni_callblock, argcount + 1);
722 /* printf("(CallObjectMethodV)-->%p\n",ret); */
728 /*************************** function: jclass_findfield ****************************
730 searches for field with specified name and type in a 'classinfo'-structur
731 if no such field is found NULL is returned
733 ************************************************************************************/
735 fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
738 /* printf(" FieldCount: %d\n",c->fieldscount);
739 utf_display(c->name); */
740 for (i = 0; i < c->fieldscount; i++) {
741 /* utf_display(c->fields[i].name);
743 utf_display(c->fields[i].descriptor);
745 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
746 return &(c->fields[i]);
749 if (c->super) return jclass_findfield(c->super,name,desc);
754 /********************* returns version of native method interface *****************/
756 jint GetVersion (JNIEnv* env)
762 /****************** loads a class from a buffer of raw class data *****************/
764 jclass DefineClass(JNIEnv* env, const char *name, jobject loader, const jbyte *buf, jsize len)
771 #if defined(USE_THREADS)
772 #if defined(NATIVE_THREADS)
782 starttime = getcputime();
784 clazz = class_new(utf_new_char((char *) name));
786 /* build a classbuffer with the given data */
787 cb = NEW(classbuffer);
790 cb->data = (u1 *) buf;
791 cb->pos = cb->data - 1;
793 class_load_intern(cb);
796 FREE(cb, classbuffer);
799 if (getloadingtime) {
800 stoptime = getcputime();
801 loadingtime += (stoptime - starttime);
804 #if defined(USE_THREADS)
805 #if defined(NATIVE_THREADS)
816 /* XXX link the class here? */
823 clazz->classloader = loader;
829 /*************** loads locally defined class with the specified name **************/
831 jclass FindClass(JNIEnv* env, const char *name)
835 c = class_new(utf_new_char_classname((char *) name));
851 /***********************************************************************************
853 converts java.lang.reflect.Method or
854 java.lang.reflect.Constructor object to a method ID
856 **********************************************************************************/
858 jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
860 /* log_text("JNI-Call: FromReflectedMethod"); */
866 /*************** return superclass of the class represented by sub ****************/
868 jclass GetSuperclass(JNIEnv* env, jclass sub)
872 c = ((classinfo*) sub)->super;
876 use_class_as_object(c);
882 /*********************** check whether sub can be cast to sup ********************/
884 jboolean IsAssignableForm(JNIEnv* env, jclass sub, jclass sup)
886 return builtin_isanysubclass(sub, sup);
890 /***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
892 jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
894 /* log_text("JNI-Call: ToReflectedField"); */
900 /***************** throw java.lang.Throwable object ******************************/
902 jint Throw(JNIEnv* env, jthrowable obj)
904 *exceptionptr = (java_objectheader*) obj;
910 /*******************************************************************************
912 create exception object from the class clazz with the
913 specified message and cause it to be thrown
915 *******************************************************************************/
917 jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
919 java_lang_Throwable *o;
921 /* instantiate exception object */
922 o = (java_lang_Throwable *) native_new_and_init((classinfo*) clazz);
926 o->detailMessage = (java_lang_String *) javastring_new_char((char *) msg);
928 *exceptionptr = (java_objectheader *) o;
934 /************************* check if exception occured *****************************/
936 jthrowable ExceptionOccurred (JNIEnv* env)
938 return (jthrowable) *exceptionptr;
941 /********** print exception and a backtrace of the stack (for debugging) **********/
943 void ExceptionDescribe (JNIEnv* env)
945 utf_display((*exceptionptr)->vftbl->class->name);
951 /******************* clear any exception currently being thrown *******************/
953 void ExceptionClear (JNIEnv* env)
955 *exceptionptr = NULL;
959 /********** raises a fatal error and does not expect the VM to recover ************/
961 void FatalError (JNIEnv* env, const char *msg)
966 /******************* creates a new local reference frame **************************/
968 jint PushLocalFrame(JNIEnv* env, jint capacity)
975 /**************** Pops off the current local reference frame **********************/
977 jobject PopLocalFrame(JNIEnv* env, jobject result)
985 /** Creates a new global reference to the object referred to by the obj argument **/
987 jobject NewGlobalRef(JNIEnv* env, jobject lobj)
992 /************* Deletes the global reference pointed to by globalRef **************/
994 void DeleteGlobalRef (JNIEnv* env, jobject gref)
1000 /*************** Deletes the local reference pointed to by localRef ***************/
1002 void DeleteLocalRef (JNIEnv* env, jobject localRef)
1007 /********** Tests whether two references refer to the same Java object ************/
1009 jboolean IsSameObject (JNIEnv* env, jobject obj1, jobject obj2)
1011 return (obj1==obj2);
1014 /***** Creates a new local reference that refers to the same object as ref *******/
1016 jobject NewLocalRef (JNIEnv* env, jobject ref)
1021 /***********************************************************************************
1023 Ensures that at least a given number of local references can
1024 be created in the current thread
1026 **********************************************************************************/
1028 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
1030 return 0; /* return 0 on success */
1034 /********* Allocates a new Java object without invoking a constructor *************/
1036 jobject AllocObject (JNIEnv* env, jclass clazz)
1038 java_objectheader *o = builtin_new(clazz);
1043 /***********************************************************************************
1045 Constructs a new Java object
1046 arguments that are to be passed to the constructor are placed after methodID
1048 ***********************************************************************************/
1050 jobject NewObject (JNIEnv* env, jclass clazz, jmethodID methodID, ...)
1052 java_objectheader *o;
1054 int argcount=get_parametercount(methodID);
1058 /* log_text("JNI-Call: NewObject"); */
1061 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
1062 log_text("Too many arguments. NewObject does not support that");
1067 o = builtin_new (clazz); /* create object */
1069 if (!o) return NULL;
1071 va_start(vaargs,methodID);
1072 for (i=0;i<argcount;i++) {
1073 args[i]=va_arg(vaargs,void*);
1076 asm_calljavafunction(methodID,o,args[0],args[1],args[2]);
1082 /***********************************************************************************
1084 Constructs a new Java object
1085 arguments that are to be passed to the constructor are placed in va_list args
1087 ***********************************************************************************/
1089 jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
1091 /* log_text("JNI-Call: NewObjectV"); */
1097 /***********************************************************************************
1099 Constructs a new Java object
1100 arguments that are to be passed to the constructor are placed in
1101 args array of jvalues
1103 ***********************************************************************************/
1105 jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
1107 /* log_text("JNI-Call: NewObjectA"); */
1113 /************************ returns the class of an object **************************/
1115 jclass GetObjectClass(JNIEnv* env, jobject obj)
1117 classinfo *c = obj->vftbl->class;
1119 use_class_as_object(c);
1125 /************* tests whether an object is an instance of a class ******************/
1127 jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz)
1129 return builtin_instanceof(obj,clazz);
1133 /***************** converts a java.lang.reflect.Field to a field ID ***************/
1135 jfieldID FromReflectedField(JNIEnv* env, jobject field)
1137 log_text("JNI-Call: FromReflectedField");
1143 /**********************************************************************************
1145 converts a method ID to a java.lang.reflect.Method or
1146 java.lang.reflect.Constructor object
1148 **********************************************************************************/
1150 jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
1152 log_text("JNI-Call: ToReflectedMethod");
1158 /**************** returns the method ID for an instance method ********************/
1160 jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, const char *sig)
1164 m = class_resolvemethod (
1166 utf_new_char ((char*) name),
1167 utf_new_char ((char*) sig)
1170 if (!m) *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1171 else if (m->flags & ACC_STATIC) {
1173 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1179 /******************** JNI-functions for calling instance methods ******************/
1181 jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1186 /* log_text("JNI-Call: CallObjectMethod");*/
1188 va_start(vaargs, methodID);
1189 ret = callObjectMethod(obj, methodID, vaargs);
1196 jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1198 return callObjectMethod(obj,methodID,args);
1202 jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1204 log_text("JNI-Call: CallObjectMethodA");
1212 jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1217 /* log_text("JNI-Call: CallBooleanMethod");*/
1219 va_start(vaargs,methodID);
1220 ret = (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',vaargs);
1226 jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1228 return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',args);
1232 jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1234 log_text("JNI-Call: CallBooleanMethodA");
1239 jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1244 /* log_text("JNI-Call: CallVyteMethod");*/
1246 va_start(vaargs,methodID);
1247 ret = callIntegerMethod(obj,get_virtual(obj,methodID),'B',vaargs);
1253 jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1255 /* log_text("JNI-Call: CallByteMethodV");*/
1256 return callIntegerMethod(obj,methodID,'B',args);
1260 jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1262 log_text("JNI-Call: CallByteMethodA");
1268 jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1273 /* log_text("JNI-Call: CallCharMethod");*/
1275 va_start(vaargs,methodID);
1276 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'C', vaargs);
1283 jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1285 /* log_text("JNI-Call: CallCharMethodV");*/
1286 return callIntegerMethod(obj,get_virtual(obj,methodID),'C',args);
1290 jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1292 log_text("JNI-Call: CallCharMethodA");
1298 jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1303 /* log_text("JNI-Call: CallShortMethod");*/
1305 va_start(vaargs, methodID);
1306 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'S', vaargs);
1313 jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1315 return callIntegerMethod(obj, get_virtual(obj, methodID), 'S', args);
1319 jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1321 log_text("JNI-Call: CallShortMethodA");
1328 jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1333 va_start(vaargs,methodID);
1334 ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'I', vaargs);
1341 jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1343 return callIntegerMethod(obj, get_virtual(obj, methodID), 'I', args);
1347 jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1349 log_text("JNI-Call: CallIntMethodA");
1356 jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1358 log_text("JNI-Call: CallLongMethod");
1364 jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1366 log_text("JNI-Call: CallLongMethodV");
1372 jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1374 log_text("JNI-Call: CallLongMethodA");
1381 jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1386 /* log_text("JNI-Call: CallFloatMethod");*/
1388 va_start(vaargs,methodID);
1389 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'F');
1396 jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1398 log_text("JNI-Call: CallFloatMethodV");
1399 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'F');
1403 jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1405 log_text("JNI-Call: CallFloatMethodA");
1412 jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1417 /* log_text("JNI-Call: CallDoubleMethod");*/
1419 va_start(vaargs,methodID);
1420 ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'D');
1427 jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1429 log_text("JNI-Call: CallDoubleMethodV");
1430 return callFloatMethod(obj, get_virtual(obj, methodID), args, 'D');
1434 jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
1436 log_text("JNI-Call: CallDoubleMethodA");
1442 void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1446 /* log_text("JNI-Call: CallVoidMethod");*/
1448 va_start(vaargs,methodID);
1449 (void) callIntegerMethod(obj, get_virtual(obj, methodID), 'V', vaargs);
1454 void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1456 log_text("JNI-Call: CallVoidMethodV");
1457 (void)callIntegerMethod(obj,get_virtual(obj,methodID),'V',args);
1461 void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1463 log_text("JNI-Call: CallVoidMethodA");
1468 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1470 log_text("JNI-Call: CallNonvirtualObjectMethod");
1476 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1478 log_text("JNI-Call: CallNonvirtualObjectMethodV");
1484 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1486 log_text("JNI-Call: CallNonvirtualObjectMethodA");
1493 jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1498 /* log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
1500 va_start(vaargs,methodID);
1501 ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',vaargs);
1508 jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1510 /* log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
1511 return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',args);
1515 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1517 log_text("JNI-Call: CallNonvirtualBooleanMethodA");
1524 jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1529 /* log_text("JNI-Call: CallNonvirutalByteMethod");*/
1531 va_start(vaargs,methodID);
1532 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',vaargs);
1538 jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1540 /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
1541 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',args);
1546 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1548 log_text("JNI-Call: CallNonvirtualByteMethodA");
1555 jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1560 /* log_text("JNI-Call: CallNonVirtualCharMethod");*/
1562 va_start(vaargs,methodID);
1563 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',vaargs);
1569 jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1571 /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
1572 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',args);
1576 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1578 log_text("JNI-Call: CallNonvirtualCharMethodA");
1585 jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1590 /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
1592 va_start(vaargs,methodID);
1593 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',vaargs);
1599 jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1601 /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
1602 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',args);
1606 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1608 log_text("JNI-Call: CallNonvirtualShortMethodA");
1615 jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1621 /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
1623 va_start(vaargs,methodID);
1624 ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',vaargs);
1630 jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1632 /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
1633 return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',args);
1637 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1639 log_text("JNI-Call: CallNonvirtualIntMethodA");
1646 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1648 log_text("JNI-Call: CallNonvirtualLongMethod");
1654 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1656 log_text("JNI-Call: CallNonvirtualLongMethodV");
1662 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1664 log_text("JNI-Call: CallNonvirtualLongMethodA");
1671 jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1676 /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
1679 va_start(vaargs,methodID);
1680 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'F');
1687 jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1689 log_text("JNI-Call: CallNonvirtualFloatMethodV");
1690 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'F');
1694 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1696 log_text("JNI-Call: CallNonvirtualFloatMethodA");
1703 jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1707 log_text("JNI-Call: CallNonvirtualDoubleMethod");
1709 va_start(vaargs,methodID);
1710 ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'D');
1717 jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1719 /* log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
1720 return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'D');
1724 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1726 log_text("JNI-Call: CallNonvirtualDoubleMethodA");
1733 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1737 /* log_text("JNI-Call: CallNonvirtualVoidMethod");*/
1739 va_start(vaargs,methodID);
1740 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',vaargs);
1746 void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1748 /* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
1750 (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',args);
1755 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1757 log_text("JNI-Call: CallNonvirtualVoidMethodA");
1760 /************************* JNI-functions for accessing fields ************************/
1762 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1766 /* log_text("========================= searching for:");
1769 f = jclass_findfield(clazz,
1770 utf_new_char ((char*) name),
1771 utf_new_char ((char*) sig)
1775 /* utf_display(clazz->name);
1778 *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
1783 /*************************** retrieve fieldid, abort on error ************************/
1785 jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig)
1787 jfieldID id = GetFieldID(env, clazz, name, sig);
1791 utf_display(clazz->name);
1792 log_text("\nfield:");
1797 panic("setfield_critical failed");
1802 jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
1804 return getField(obj,jobject,fieldID);
1807 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
1809 return getField(obj,jboolean,fieldID);
1813 jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
1815 return getField(obj,jbyte,fieldID);
1819 jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
1821 return getField(obj,jchar,fieldID);
1825 jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
1827 return getField(obj,jshort,fieldID);
1831 jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
1833 return getField(obj,jint,fieldID);
1837 jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
1839 return getField(obj,jlong,fieldID);
1843 jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
1845 return getField(obj,jfloat,fieldID);
1849 jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
1851 return getField(obj,jdouble,fieldID);
1854 void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
1856 setField(obj,jobject,fieldID,val);
1860 void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
1862 setField(obj,jboolean,fieldID,val);
1866 void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
1868 setField(obj,jbyte,fieldID,val);
1872 void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
1874 setField(obj,jchar,fieldID,val);
1878 void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
1880 setField(obj,jshort,fieldID,val);
1884 void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
1886 setField(obj,jint,fieldID,val);
1890 void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
1892 setField(obj,jlong,fieldID,val);
1896 void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
1898 setField(obj,jfloat,fieldID,val);
1902 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
1904 setField(obj,jdouble,fieldID,val);
1908 /**************** JNI-functions for calling static methods **********************/
1910 jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
1914 m = class_resolvemethod(clazz,
1915 utf_new_char((char *) name),
1916 utf_new_char((char *) sig));
1918 if (!m) *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1919 else if (!(m->flags & ACC_STATIC)) {
1921 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
1928 jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1933 /* log_text("JNI-Call: CallStaticObjectMethod");*/
1935 va_start(vaargs, methodID);
1936 ret = callObjectMethod(0, methodID, vaargs);
1943 jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1945 /* log_text("JNI-Call: CallStaticObjectMethodV"); */
1947 return callObjectMethod(0,methodID,args);
1951 jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1953 log_text("JNI-Call: CallStaticObjectMethodA");
1959 jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1964 va_start(vaargs, methodID);
1965 ret = (jboolean) callIntegerMethod(0, methodID, 'Z', vaargs);
1972 jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1974 return (jboolean) callIntegerMethod(0, methodID, 'Z', args);
1978 jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1980 log_text("JNI-Call: CallStaticBooleanMethodA");
1986 jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1991 /* log_text("JNI-Call: CallStaticByteMethod");*/
1993 va_start(vaargs, methodID);
1994 ret = (jbyte) callIntegerMethod(0, methodID, 'B', vaargs);
2001 jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2003 return (jbyte) callIntegerMethod(0, methodID, 'B', args);
2007 jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2009 log_text("JNI-Call: CallStaticByteMethodA");
2015 jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2020 /* log_text("JNI-Call: CallStaticByteMethod");*/
2022 va_start(vaargs, methodID);
2023 ret = (jchar) callIntegerMethod(0, methodID, 'C', vaargs);
2030 jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2032 return (jchar) callIntegerMethod(0, methodID, 'C', args);
2036 jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2038 log_text("JNI-Call: CallStaticCharMethodA");
2045 jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2050 /* log_text("JNI-Call: CallStaticByteMethod");*/
2052 va_start(vaargs, methodID);
2053 ret = (jshort) callIntegerMethod(0, methodID, 'S', vaargs);
2060 jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2062 /*log_text("JNI-Call: CallStaticShortMethodV");*/
2063 return (jshort) callIntegerMethod(0, methodID, 'S', args);
2067 jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2069 log_text("JNI-Call: CallStaticShortMethodA");
2076 jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2081 /* log_text("JNI-Call: CallStaticIntMethod");*/
2083 va_start(vaargs, methodID);
2084 ret = callIntegerMethod(0, methodID, 'I', vaargs);
2091 jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2093 log_text("JNI-Call: CallStaticIntMethodV");
2095 return callIntegerMethod(0, methodID, 'I', args);
2099 jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2101 log_text("JNI-Call: CallStaticIntMethodA");
2108 jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2113 /* log_text("JNI-Call: CallStaticLongMethod");*/
2115 va_start(vaargs, methodID);
2116 ret = callLongMethod(0, methodID, vaargs);
2123 jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2125 log_text("JNI-Call: CallStaticLongMethodV");
2127 return callLongMethod(0,methodID,args);
2131 jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2133 log_text("JNI-Call: CallStaticLongMethodA");
2140 jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2145 /* log_text("JNI-Call: CallStaticLongMethod");*/
2147 va_start(vaargs, methodID);
2148 ret = callFloatMethod(0, methodID, vaargs, 'F');
2155 jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2158 return callFloatMethod(0, methodID, args, 'F');
2163 jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2165 log_text("JNI-Call: CallStaticFloatMethodA");
2172 jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
2177 /* log_text("JNI-Call: CallStaticDoubleMethod");*/
2179 va_start(vaargs,methodID);
2180 ret = callFloatMethod(0, methodID, vaargs, 'D');
2187 jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
2189 log_text("JNI-Call: CallStaticDoubleMethodV");
2191 return callFloatMethod(0, methodID, args, 'D');
2195 jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
2197 log_text("JNI-Call: CallStaticDoubleMethodA");
2203 void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
2207 /* log_text("JNI-Call: CallStaticVoidMethod");*/
2209 va_start(vaargs, methodID);
2210 (void) callIntegerMethod(0, methodID, 'V', vaargs);
2215 void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
2217 log_text("JNI-Call: CallStaticVoidMethodV");
2218 (void)callIntegerMethod(0, methodID, 'V', args);
2222 void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
2224 log_text("JNI-Call: CallStaticVoidMethodA");
2228 /****************** JNI-functions for accessing static fields ********************/
2230 jfieldID GetStaticFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
2234 f = jclass_findfield(clazz,
2235 utf_new_char ((char*) name),
2236 utf_new_char ((char*) sig)
2239 if (!f) *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
2245 jobject GetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2248 return fieldID->value.a;
2252 jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2255 return fieldID->value.i;
2259 jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2262 return fieldID->value.i;
2266 jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2269 return fieldID->value.i;
2273 jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2276 return fieldID->value.i;
2280 jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2283 return fieldID->value.i;
2287 jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2290 return fieldID->value.l;
2294 jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2297 return fieldID->value.f;
2301 jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
2304 return fieldID->value.d;
2309 void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
2312 fieldID->value.a = value;
2316 void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
2319 fieldID->value.i = value;
2323 void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
2326 fieldID->value.i = value;
2330 void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
2333 fieldID->value.i = value;
2337 void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
2340 fieldID->value.i = value;
2344 void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
2347 fieldID->value.i = value;
2351 void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
2354 fieldID->value.l = value;
2358 void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
2361 fieldID->value.f = value;
2365 void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
2368 fieldID->value.d = value;
2372 /***** create new java.lang.String object from an array of Unicode characters ****/
2374 jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
2377 java_lang_String *s;
2380 s = (java_lang_String*) builtin_new (class_java_lang_String);
2381 a = builtin_newarray_char (len);
2383 /* javastring or characterarray could not be created */
2384 if ( (!a) || (!s) ) return NULL;
2387 for (i=0; i<len; i++) a->data[i] = buf[i];
2396 static char emptyString[]="";
2397 static jchar emptyStringJ[]={0,0};
2399 /******************* returns the length of a Java string ***************************/
2401 jsize GetStringLength (JNIEnv *env, jstring str)
2403 return ((java_lang_String*) str)->count;
2407 /******************** convertes javastring to u2-array ****************************/
2409 u2 *javastring_tou2 (jstring so)
2411 java_lang_String *s = (java_lang_String*) so;
2416 if (!s) return NULL;
2419 if (!a) return NULL;
2421 /* allocate memory */
2422 stringbuffer = MNEW( u2 , s->count + 1 );
2425 for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
2427 /* terminate string */
2428 stringbuffer[i] = '\0';
2430 return stringbuffer;
2433 /********* returns a pointer to an array of Unicode characters of the string *******/
2435 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
2437 jchar *jc=javastring_tou2(str);
2440 if (isCopy) *isCopy=JNI_TRUE;
2443 if (isCopy) *isCopy=JNI_TRUE;
2444 return emptyStringJ;
2447 /**************** native code no longer needs access to chars **********************/
2449 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
2451 if (chars==emptyStringJ) return;
2452 MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count+1);
2455 /************ create new java.lang.String object from utf8-characterarray **********/
2457 jstring NewStringUTF (JNIEnv *env, const char *utf)
2459 /* log_text("NewStringUTF called");*/
2460 return (jstring) javastring_new(utf_new_char((char *) utf));
2463 /****************** returns the utf8 length in bytes of a string *******************/
2465 jsize GetStringUTFLength (JNIEnv *env, jstring string)
2467 java_lang_String *s = (java_lang_String*) string;
2469 return (jsize) u2_utflength(s->value->data, s->count);
2473 /************ converts a Javastring to an array of UTF-8 characters ****************/
2475 const char* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
2479 u = javastring_toutf((java_lang_String *) string, false);
2482 *isCopy = JNI_FALSE;
2492 /***************** native code no longer needs access to utf ***********************/
2494 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
2496 /*we don't release utf chars right now, perhaps that should be done later. Since there is always one reference
2497 the garbage collector will never get them*/
2499 log_text("JNI-Call: ReleaseStringUTFChars");
2500 utf_display(utf_new_char(chars));
2504 /************************** array operations ***************************************/
2506 jsize GetArrayLength(JNIEnv *env, jarray array)
2512 jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
2514 java_objectarray *j;
2517 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2521 j = builtin_anewarray(len, clazz);
2527 jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
2531 if (index < array->header.size)
2532 j = array->data[index];
2534 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2540 void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
2542 if (index >= array->header.size)
2543 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2546 /* check if the class of value is a subclass of the element class of the array */
2547 if (!builtin_canstore((java_objectarray *) array, (java_objectheader *) val))
2548 *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
2551 array->data[index] = val;
2557 jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
2559 java_booleanarray *j;
2562 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2566 j = builtin_newarray_boolean(len);
2572 jbyteArray NewByteArray(JNIEnv *env, jsize len)
2577 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2581 j = builtin_newarray_byte(len);
2587 jcharArray NewCharArray(JNIEnv *env, jsize len)
2592 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2596 j = builtin_newarray_char(len);
2602 jshortArray NewShortArray(JNIEnv *env, jsize len)
2607 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2611 j = builtin_newarray_short(len);
2617 jintArray NewIntArray(JNIEnv *env, jsize len)
2622 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2626 j = builtin_newarray_int(len);
2632 jlongArray NewLongArray(JNIEnv *env, jsize len)
2637 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2641 j = builtin_newarray_long(len);
2647 jfloatArray NewFloatArray(JNIEnv *env, jsize len)
2652 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2656 j = builtin_newarray_float(len);
2662 jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
2664 java_doublearray *j;
2667 *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
2671 j = builtin_newarray_double(len);
2677 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
2679 if (isCopy) *isCopy = JNI_FALSE;
2684 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
2686 if (isCopy) *isCopy = JNI_FALSE;
2691 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
2693 if (isCopy) *isCopy = JNI_FALSE;
2698 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
2700 if (isCopy) *isCopy = JNI_FALSE;
2705 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
2707 if (isCopy) *isCopy = JNI_FALSE;
2712 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
2714 if (isCopy) *isCopy = JNI_FALSE;
2719 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
2721 if (isCopy) *isCopy = JNI_FALSE;
2726 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
2728 if (isCopy) *isCopy = JNI_FALSE;
2734 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
2740 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
2746 void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
2752 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
2758 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
2764 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
2770 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
2776 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
2782 void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2784 if (start < 0 || len < 0 || start + len > array->header.size)
2785 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2788 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2792 void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2794 if (start < 0 || len < 0 || start + len > array->header.size)
2795 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2798 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2802 void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2804 if (start < 0 || len < 0 || start + len > array->header.size)
2805 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2808 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2812 void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2814 if (start < 0 || len < 0 || start + len > array->header.size)
2815 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2818 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2822 void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2824 if (start < 0 || len < 0 || start + len > array->header.size)
2825 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2828 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2832 void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2834 if (start < 0 || len < 0 || start + len > array->header.size)
2835 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2838 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2842 void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2844 if (start < 0 || len < 0 || start + len > array->header.size)
2845 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2848 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2852 void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2854 if (start < 0 || len < 0 || start+len>array->header.size)
2855 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2858 memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
2862 void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2864 if (start < 0 || len < 0 || start + len > array->header.size)
2865 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2868 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2872 void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2874 if (start < 0 || len < 0 || start + len > array->header.size)
2875 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2878 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2882 void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2884 if (start < 0 || len < 0 || start + len > array->header.size)
2885 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2888 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2893 void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2895 if (start < 0 || len < 0 || start + len > array->header.size)
2896 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2899 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2903 void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2905 if (start < 0 || len < 0 || start + len > array->header.size)
2906 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2909 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2914 void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2916 if (start < 0 || len < 0 || start + len > array->header.size)
2917 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2920 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2925 void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2927 if (start < 0 || len < 0 || start + len > array->header.size)
2928 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2931 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2936 void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2938 if (start < 0 || len < 0 || start + len > array->header.size)
2939 *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
2942 memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
2946 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
2948 log_text("JNI-Call: RegisterNatives");
2953 jint UnregisterNatives (JNIEnv* env, jclass clazz)
2955 log_text("JNI-Call: UnregisterNatives");
2959 /******************************* monitor operations ********************************/
2961 jint MonitorEnter (JNIEnv* env, jobject obj)
2963 builtin_monitorenter(obj);
2968 jint MonitorExit (JNIEnv* env, jobject obj)
2970 builtin_monitorexit(obj);
2975 /************************************* JavaVM interface ****************************/
2977 #error CPP mode not supported yet
2979 jint GetJavaVM (JNIEnv* env, JavaVM **vm)
2981 log_text("JNI-Call: GetJavaVM");
2985 #endif /*__cplusplus*/
2987 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
2989 log_text("JNI-Call: GetStringRegion");
2993 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
2995 log_text("JNI-Call: GetStringUTFRegion");
2999 /************** obtain direct pointer to array elements ***********************/
3001 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
3003 java_objectheader *s = (java_objectheader*) array;
3004 arraydescriptor *desc = s->vftbl->arraydesc;
3006 if (!desc) return NULL;
3008 return ((u1*)s) + desc->dataoffset;
3012 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
3014 log_text("JNI-Call: ReleasePrimitiveArrayCritical");
3019 /**** returns a pointer to an array of Unicode characters of the string *******/
3021 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
3023 log_text("JNI-Call: GetStringCritical");
3025 return GetStringChars(env,string,isCopy);
3028 /*********** native code no longer needs access to chars **********************/
3030 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
3032 log_text("JNI-Call: ReleaseStringCritical");
3034 ReleaseStringChars(env,string,cstring);
3038 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
3040 log_text("JNI-Call: NewWeakGlobalRef");
3046 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
3048 log_text("JNI-Call: DeleteWeakGlobalRef");
3054 /******************************* check for pending exception ***********************/
3057 jboolean ExceptionCheck(JNIEnv* env)
3059 log_text("JNI-Call: ExceptionCheck");
3061 return *exceptionptr ? JNI_TRUE : JNI_FALSE;
3069 jint DestroyJavaVM(JavaVM *vm)
3071 log_text("DestroyJavaVM called");
3077 jint AttachCurrentThread(JavaVM *vm, void **par1, void *par2)
3079 log_text("AttachCurrentThread called");
3085 jint DetachCurrentThread(JavaVM *vm)
3087 log_text("DetachCurrentThread called");
3093 jint GetEnv(JavaVM *vm, void **environment, jint jniversion)
3095 *environment = &env;
3101 jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
3103 log_text("AttachCurrentThreadAsDaemon called");
3109 /********************************* JNI invocation table ******************************/
3111 struct _JavaVM javaVMTable={
3116 &AttachCurrentThread,
3117 &DetachCurrentThread,
3119 &AttachCurrentThreadAsDaemon
3122 JavaVM javaVM = &javaVMTable;
3125 /********************************* JNI function table ******************************/
3127 struct JNI_Table envTable = {
3135 &FromReflectedMethod,
3136 &FromReflectedField,
3154 &EnsureLocalCapacity,
3166 &CallBooleanMethodV,
3167 &CallBooleanMethodA,
3192 &CallNonvirtualObjectMethod,
3193 &CallNonvirtualObjectMethodV,
3194 &CallNonvirtualObjectMethodA,
3195 &CallNonvirtualBooleanMethod,
3196 &CallNonvirtualBooleanMethodV,
3197 &CallNonvirtualBooleanMethodA,
3198 &CallNonvirtualByteMethod,
3199 &CallNonvirtualByteMethodV,
3200 &CallNonvirtualByteMethodA,
3201 &CallNonvirtualCharMethod,
3202 &CallNonvirtualCharMethodV,
3203 &CallNonvirtualCharMethodA,
3204 &CallNonvirtualShortMethod,
3205 &CallNonvirtualShortMethodV,
3206 &CallNonvirtualShortMethodA,
3207 &CallNonvirtualIntMethod,
3208 &CallNonvirtualIntMethodV,
3209 &CallNonvirtualIntMethodA,
3210 &CallNonvirtualLongMethod,
3211 &CallNonvirtualLongMethodV,
3212 &CallNonvirtualLongMethodA,
3213 &CallNonvirtualFloatMethod,
3214 &CallNonvirtualFloatMethodV,
3215 &CallNonvirtualFloatMethodA,
3216 &CallNonvirtualDoubleMethod,
3217 &CallNonvirtualDoubleMethodV,
3218 &CallNonvirtualDoubleMethodA,
3219 &CallNonvirtualVoidMethod,
3220 &CallNonvirtualVoidMethodV,
3221 &CallNonvirtualVoidMethodA,
3242 &CallStaticObjectMethod,
3243 &CallStaticObjectMethodV,
3244 &CallStaticObjectMethodA,
3245 &CallStaticBooleanMethod,
3246 &CallStaticBooleanMethodV,
3247 &CallStaticBooleanMethodA,
3248 &CallStaticByteMethod,
3249 &CallStaticByteMethodV,
3250 &CallStaticByteMethodA,
3251 &CallStaticCharMethod,
3252 &CallStaticCharMethodV,
3253 &CallStaticCharMethodA,
3254 &CallStaticShortMethod,
3255 &CallStaticShortMethodV,
3256 &CallStaticShortMethodA,
3257 &CallStaticIntMethod,
3258 &CallStaticIntMethodV,
3259 &CallStaticIntMethodA,
3260 &CallStaticLongMethod,
3261 &CallStaticLongMethodV,
3262 &CallStaticLongMethodA,
3263 &CallStaticFloatMethod,
3264 &CallStaticFloatMethodV,
3265 &CallStaticFloatMethodA,
3266 &CallStaticDoubleMethod,
3267 &CallStaticDoubleMethodV,
3268 &CallStaticDoubleMethodA,
3269 &CallStaticVoidMethod,
3270 &CallStaticVoidMethodV,
3271 &CallStaticVoidMethodA,
3273 &GetStaticObjectField,
3274 &GetStaticBooleanField,
3275 &GetStaticByteField,
3276 &GetStaticCharField,
3277 &GetStaticShortField,
3279 &GetStaticLongField,
3280 &GetStaticFloatField,
3281 &GetStaticDoubleField,
3282 &SetStaticObjectField,
3283 &SetStaticBooleanField,
3284 &SetStaticByteField,
3285 &SetStaticCharField,
3286 &SetStaticShortField,
3288 &SetStaticLongField,
3289 &SetStaticFloatField,
3290 &SetStaticDoubleField,
3294 &ReleaseStringChars,
3296 &GetStringUTFLength,
3298 &ReleaseStringUTFChars,
3301 &GetObjectArrayElement,
3302 &SetObjectArrayElement,
3311 &GetBooleanArrayElements,
3312 &GetByteArrayElements,
3313 &GetCharArrayElements,
3314 &GetShortArrayElements,
3315 &GetIntArrayElements,
3316 &GetLongArrayElements,
3317 &GetFloatArrayElements,
3318 &GetDoubleArrayElements,
3319 &ReleaseBooleanArrayElements,
3320 &ReleaseByteArrayElements,
3321 &ReleaseCharArrayElements,
3322 &ReleaseShortArrayElements,
3323 &ReleaseIntArrayElements,
3324 &ReleaseLongArrayElements,
3325 &ReleaseFloatArrayElements,
3326 &ReleaseDoubleArrayElements,
3327 &GetBooleanArrayRegion,
3328 &GetByteArrayRegion,
3329 &GetCharArrayRegion,
3330 &GetShortArrayRegion,
3332 &GetLongArrayRegion,
3333 &GetFloatArrayRegion,
3334 &GetDoubleArrayRegion,
3335 &SetBooleanArrayRegion,
3336 &SetByteArrayRegion,
3337 &SetCharArrayRegion,
3338 &SetShortArrayRegion,
3340 &SetLongArrayRegion,
3341 &SetFloatArrayRegion,
3342 &SetDoubleArrayRegion,
3349 &GetStringUTFRegion,
3350 &GetPrimitiveArrayCritical,
3351 &ReleasePrimitiveArrayCritical,
3353 &ReleaseStringCritical,
3355 &DeleteWeakGlobalRef,
3359 JNIEnv env = &envTable;
3362 jobject *jni_method_invokeNativeHelper(JNIEnv *env, struct methodinfo *methodID, jobject obj, java_objectarray *params)
3369 if (methodID == 0) {
3370 *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
3374 argcount = get_parametercount(methodID);
3376 if (obj && (!builtin_instanceof((java_objectheader *) obj, methodID->class))) {
3377 *exceptionptr = new_exception_message(string_java_lang_IllegalArgumentException,
3378 "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
3385 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
3386 log_text("Too many arguments. invokeNativeHelper does not support that");
3390 if (((!params) && (argcount != 0)) || (params && (params->header.size != argcount))) {
3391 *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
3396 if (!(methodID->flags & ACC_STATIC) && (!obj)) {
3397 *exceptionptr = new_exception_message(string_java_lang_NullPointerException,
3398 "Static mismatch in Java_java_lang_reflect_Method_invokeNative");
3402 if ((methodID->flags & ACC_STATIC) && (obj)) obj = 0;
3404 blk = MNEW(jni_callblock, 4 /*argcount+2*/);
3406 retT = fill_callblock_objA(obj, methodID->descriptor, blk, params);
3410 (void) asm_calljavafunction2(methodID,
3412 (argcount + 1) * sizeof(jni_callblock),
3414 retVal = NULL; /*native_new_and_init(loader_load(utf_new_char("java/lang/Void")));*/
3419 intVal = (s4) asm_calljavafunction2(methodID,
3421 (argcount + 1) * sizeof(jni_callblock),
3423 retVal = builtin_new(class_new(utf_new_char("java/lang/Integer")));
3426 class_resolvemethod(retVal->vftbl->class,
3427 utf_new_char("<init>"),
3428 utf_new_char("(I)V")),
3435 intVal = (s4) asm_calljavafunction2(methodID,
3437 (argcount + 1) * sizeof(jni_callblock),
3439 retVal = builtin_new(class_new(utf_new_char("java/lang/Byte")));
3442 class_resolvemethod(retVal->vftbl->class,
3443 utf_new_char("<init>"),
3444 utf_new_char("(B)V")),
3451 intVal = (s4) asm_calljavafunction2(methodID,
3453 (argcount + 1) * sizeof(jni_callblock),
3455 retVal = builtin_new(class_new(utf_new_char("java/lang/Character")));
3458 class_resolvemethod(retVal->vftbl->class,
3459 utf_new_char("<init>"),
3460 utf_new_char("(C)V")),
3467 intVal = (s4) asm_calljavafunction2(methodID,
3469 (argcount + 1) * sizeof(jni_callblock),
3471 retVal = builtin_new(class_new(utf_new_char("java/lang/Short")));
3474 class_resolvemethod(retVal->vftbl->class,
3475 utf_new_char("<init>"),
3476 utf_new_char("(S)V")),
3483 intVal = (s4) asm_calljavafunction2(methodID,
3485 (argcount + 1) * sizeof(jni_callblock),
3487 retVal = builtin_new(class_new(utf_new_char("java/lang/Boolean")));
3490 class_resolvemethod(retVal->vftbl->class,
3491 utf_new_char("<init>"),
3492 utf_new_char("(Z)V")),
3499 intVal = asm_calljavafunction2long(methodID,
3501 (argcount + 1) * sizeof(jni_callblock),
3503 retVal = builtin_new(class_new(utf_new_char("java/lang/Long")));
3506 class_resolvemethod(retVal->vftbl->class,
3507 utf_new_char("<init>"),
3508 utf_new_char("(J)V")),
3515 floatVal = asm_calljavafunction2double(methodID,
3517 (argcount + 1) * sizeof(jni_callblock),
3519 retVal = builtin_new(class_new(utf_new_char("java/lang/Float")));
3522 class_resolvemethod(retVal->vftbl->class,
3523 utf_new_char("<init>"),
3524 utf_new_char("(F)V")),
3531 floatVal = asm_calljavafunction2double(methodID,
3533 (argcount + 1) * sizeof(jni_callblock),
3535 retVal = builtin_new(class_new(utf_new_char("java/lang/Double")));
3538 class_resolvemethod(retVal->vftbl->class,
3539 utf_new_char("<init>"),
3540 utf_new_char("(D)V")),
3545 case 'L': /* fall through */
3547 retVal = asm_calljavafunction2(methodID,
3549 (argcount + 1) * sizeof(jni_callblock),
3554 /* if this happens the acception has already been set by fill_callblock_objA*/
3555 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3556 return (jobject *) 0;
3559 MFREE(blk, jni_callblock, 4 /*argcount+2*/);
3561 if (*exceptionptr) {
3562 java_objectheader *exceptionToWrap = *exceptionptr;
3564 java_objectheader *ivte;
3566 *exceptionptr = NULL;
3567 ivtec = class_new(utf_new_char("java/lang/reflect/InvocationTargetException"));
3568 ivte = builtin_new(ivtec);
3569 asm_calljavafunction(class_resolvemethod(ivtec,
3570 utf_new_char("<init>"),
3571 utf_new_char("(Ljava/lang/Throwable;)V")),
3577 if (*exceptionptr != NULL)
3578 panic("jni.c: error while creating InvocationTargetException wrapper");
3580 *exceptionptr = ivte;
3583 return (jobject *) retVal;
3588 * These are local overrides for various environment variables in Emacs.
3589 * Please do not remove this and leave it at the end of the file, where
3590 * Emacs will automagically detect them.
3591 * ---------------------------------------------------------------------
3594 * indent-tabs-mode: t