-/* native/jni.c - implementation of the Java Native Interface functions
+/* src/native/jni.c - implementation of the Java Native Interface functions
- Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
- R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
- C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
- Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
+ E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
+ J. Wenninger, Institut f. Computersprachen - TU Wien
This file is part of CACAO.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA.
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
- Contact: cacao@complang.tuwien.ac.at
+ Contact: cacao@cacaojvm.org
Authors: Rainhard Grafl
Roman Obermaisser
Changes: Joseph Wenninger
Martin Platter
Christian Thalinger
+ Edwin Steiner
- $Id: jni.c 1969 2005-03-01 14:09:25Z motse $
+ $Id: jni.c 4567 2006-03-07 10:48:24Z twisti $
*/
+#include "config.h"
+
+#include <assert.h>
#include <string.h>
+#include "vm/types.h"
+
#include "mm/boehm.h"
#include "mm/memory.h"
#include "native/jni.h"
#include "native/native.h"
+
+#include "native/include/gnu_classpath_Pointer.h"
+
+#if SIZEOF_VOID_P == 8
+# include "native/include/gnu_classpath_Pointer64.h"
+#else
+# include "native/include/gnu_classpath_Pointer32.h"
+#endif
+
+#include "native/include/java_lang_Object.h"
#include "native/include/java_lang_Byte.h"
#include "native/include/java_lang_Character.h"
#include "native/include/java_lang_Short.h"
#include "native/include/java_lang_Float.h"
#include "native/include/java_lang_Double.h"
#include "native/include/java_lang_Throwable.h"
+#include "native/include/java_lang_reflect_Method.h"
+#include "native/include/java_lang_reflect_Constructor.h"
+#include "native/include/java_lang_reflect_Field.h"
+
+#include "native/include/java_lang_Class.h" /* for java_lang_VMClass.h */
+#include "native/include/java_lang_VMClass.h"
+#include "native/include/java_lang_VMClassLoader.h"
+#include "native/include/java_nio_Buffer.h"
+#include "native/include/java_nio_DirectByteBufferImpl.h"
+
+#if defined(ENABLE_JVMTI)
+# include "native/jvmti/jvmti.h"
+#endif
#if defined(USE_THREADS)
# if defined(NATIVE_THREADS)
#include "vm/builtin.h"
#include "vm/exceptions.h"
#include "vm/global.h"
+#include "vm/initialize.h"
#include "vm/loader.h"
#include "vm/options.h"
+#include "vm/resolve.h"
#include "vm/statistics.h"
#include "vm/stringlocal.h"
-#include "vm/tables.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/jit.h"
+#include "vm/statistics.h"
+#include "vm/vm.h"
-/* XXX TWISTI hack: define it extern so they can be found in this file */
-extern const struct JNIInvokeInterface JNI_JavaVMTable;
-extern struct JNINativeInterface JNI_JNIEnvTable;
+/* global variables ***********************************************************/
-/* pointers to VM and the environment needed by GetJavaVM and GetEnv */
-static JavaVM ptr_jvm = (JavaVM) &JNI_JavaVMTable;
-static void* ptr_env = (void*) &JNI_JNIEnvTable;
+/* global reference table *****************************************************/
+static java_objectheader **global_ref_table;
-#define PTR_TO_ITEM(ptr) ((u8)(size_t)(ptr))
+/* jmethodID and jclass caching variables for NewGlobalRef and DeleteGlobalRef*/
+static classinfo *ihmclass = NULL;
+static methodinfo *putmid = NULL;
+static methodinfo *getmid = NULL;
+static methodinfo *removemid = NULL;
-/* global reference table */
-static jobject *global_ref_table;
-static bool initrunning=false;
-/* jmethodID and jclass caching variables for NewGlobalRef and DeleteGlobalRef*/
-static jmethodID getmid = NULL;
-static jmethodID putmid = NULL;
-static jclass intclass = NULL;
-static jmethodID intvalue = NULL;
-static jmethodID newint = NULL;
-static jclass ihmclass = NULL;
-static jmethodID removemid = NULL;
+/* direct buffer stuff ********************************************************/
+static classinfo *class_java_nio_Buffer;
+static classinfo *class_java_nio_DirectByteBufferImpl;
+static classinfo *class_java_nio_DirectByteBufferImpl_ReadWrite;
+#if SIZEOF_VOID_P == 8
+static classinfo *class_gnu_classpath_Pointer64;
+#else
+static classinfo *class_gnu_classpath_Pointer32;
+#endif
-/********************* accessing instance-fields **********************************/
+static methodinfo *dbbirw_init;
-#define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
-#define getField(obj,typ,var) *((typ*) ((long int) obj + (long int) var->offset))
-#define setfield_critical(clazz,obj,name,sig,jdatatype,val) setField(obj,jdatatype,getFieldID_critical(env,clazz,name,sig),val);
+/* local reference table ******************************************************/
+#if !defined(USE_THREADS)
+localref_table *_no_threads_localref_table;
+#endif
-u4 get_parametercount(methodinfo *m)
-{
- utf *descr = m->descriptor; /* method-descriptor */
- char *utf_ptr = descr->text; /* current position in utf-text */
- char *desc_end = utf_end(descr); /* points behind utf string */
- u4 parametercount = 0;
- /* skip '(' */
- utf_nextu2(&utf_ptr);
+/* accessing instance fields macros *******************************************/
- /* determine number of parameters */
- while (*utf_ptr != ')') {
- get_type(&utf_ptr, desc_end, true);
- parametercount++;
- }
+#define SET_FIELD(o,type,f,value) \
+ *((type *) ((ptrint) (o) + (ptrint) ((fieldinfo *) (f))->offset)) = (type) (value)
- return parametercount;
-}
+#define GET_FIELD(o,type,f) \
+ *((type *) ((ptrint) (o) + (ptrint) ((fieldinfo *) (f))->offset))
+/* some forward declarations **************************************************/
-void fill_callblock(void *obj, utf *descr, jni_callblock blk[], va_list data, char ret)
-{
- char *utf__ptr = descr->text; /* current position in utf-text */
- char **utf_ptr = &utf__ptr;
- char *desc_end = utf_end(descr); /* points behind utf string */
- int cnt;
- u4 dummy;
- char c;
+jobject NewLocalRef(JNIEnv *env, jobject ref);
- /*
- log_text("fill_callblock");
- utf_display(descr);
- log_text("====");
- */
- /* skip '(' */
- utf_nextu2(utf_ptr);
- /* determine number of parameters */
- if (obj) {
- blk[0].itemtype = TYPE_ADR;
- blk[0].item = PTR_TO_ITEM(obj);
- cnt = 1;
- } else cnt = 0;
+/* jni_init ********************************************************************
- while (**utf_ptr != ')') {
- if (*utf_ptr >= desc_end)
- panic("illegal method descriptor");
+ Initialize the JNI subsystem.
- switch (utf_nextu2(utf_ptr)) {
- /* primitive types */
- case 'B':
- case 'C':
- case 'S':
- case 'Z':
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) va_arg(data, int);
- break;
+*******************************************************************************/
- case 'I':
- blk[cnt].itemtype = TYPE_INT;
- dummy = va_arg(data, u4);
- /*printf("fill_callblock: pos:%d, value:%d\n",cnt,dummy);*/
- blk[cnt].item = (u8) dummy;
- break;
+bool jni_init(void)
+{
+ /* initalize global reference table */
- case 'J':
- blk[cnt].itemtype = TYPE_LNG;
- blk[cnt].item = (u8) va_arg(data, jlong);
- break;
+ if (!(ihmclass =
+ load_class_bootstrap(utf_new_char("java/util/IdentityHashMap"))))
+ return false;
+
+ global_ref_table = GCNEW(jobject);
+
+ if (!(*global_ref_table = native_new_and_init(ihmclass)))
+ return false;
+
+ if (!(getmid = class_resolvemethod(ihmclass, utf_get,
+ utf_java_lang_Object__java_lang_Object)))
+ return false;
+
+ if (!(putmid = class_resolvemethod(ihmclass, utf_put,
+ utf_new_char("(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"))))
+ return false;
+
+ if (!(removemid =
+ class_resolvemethod(ihmclass, utf_remove,
+ utf_java_lang_Object__java_lang_Object)))
+ return false;
+
+
+ /* direct buffer stuff */
+
+ if (!(class_java_nio_Buffer =
+ load_class_bootstrap(utf_new_char("java/nio/Buffer"))) ||
+ !link_class(class_java_nio_Buffer))
+ return false;
+
+ if (!(class_java_nio_DirectByteBufferImpl =
+ load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl"))) ||
+ !link_class(class_java_nio_DirectByteBufferImpl))
+ return false;
+
+ if (!(class_java_nio_DirectByteBufferImpl_ReadWrite =
+ load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl$ReadWrite"))) ||
+ !link_class(class_java_nio_DirectByteBufferImpl_ReadWrite))
+ return false;
+
+ if (!(dbbirw_init =
+ class_resolvemethod(class_java_nio_DirectByteBufferImpl_ReadWrite,
+ utf_init,
+ utf_new_char("(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V"))))
+ return false;
+
+#if SIZEOF_VOID_P == 8
+ if (!(class_gnu_classpath_Pointer64 =
+ load_class_bootstrap(utf_new_char("gnu/classpath/Pointer64"))) ||
+ !link_class(class_gnu_classpath_Pointer64))
+ return false;
+#else
+ if (!(class_gnu_classpath_Pointer32 =
+ load_class_bootstrap(utf_new_char("gnu/classpath/Pointer32"))) ||
+ !link_class(class_gnu_classpath_Pointer32))
+ return false;
+#endif
- case 'F':
- blk[cnt].itemtype = TYPE_FLT;
- *((jfloat *) (&blk[cnt].item)) = (jfloat) va_arg(data, jdouble);
- break;
+ return true;
+}
- case 'D':
- blk[cnt].itemtype = TYPE_DBL;
- *((jdouble *) (&blk[cnt].item)) = (jdouble) va_arg(data, jdouble);
- break;
- case 'V':
- panic ("V not allowed as function parameter");
- break;
-
- case 'L':
- while (utf_nextu2(utf_ptr) != ';')
- blk[cnt].itemtype = TYPE_ADR;
- blk[cnt].item = PTR_TO_ITEM(va_arg(data, void*));
- break;
-
- case '[':
- {
- /* XXX */
- /* arrayclass */
-/* char *start = *utf_ptr; */
- char ch;
- while ((ch = utf_nextu2(utf_ptr)) == '[')
- if (ch == 'L') {
- while (utf_nextu2(utf_ptr) != ';') {}
- }
-
- ch = utf_nextu2(utf_ptr);
- blk[cnt].itemtype = TYPE_ADR;
- blk[cnt].item = PTR_TO_ITEM(va_arg(data, void*));
- break;
- }
- }
- cnt++;
- }
+/* _Jv_jni_vmargs_from_objectarray *********************************************
- /*the standard doesn't say anything about return value checking, but it appears to be usefull*/
- c = utf_nextu2(utf_ptr);
- c = utf_nextu2(utf_ptr);
- /*printf("%c %c\n",ret,c);*/
- if (ret == 'O') {
- if (!((c == 'L') || (c == '[')))
- log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
- } else if (ret != c)
- log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
-}
+ XXX
+*******************************************************************************/
-/* XXX it could be considered if we should do typechecking here in the future */
-char fill_callblock_objA(void *obj, utf *descr, jni_callblock blk[], java_objectarray* params)
+static bool _Jv_jni_vmargs_from_objectarray(java_objectheader *o,
+ methoddesc *descr,
+ vm_arg *vmargs,
+ java_objectarray *params)
{
- char *utf__ptr = descr->text; /* current position in utf-text */
- char **utf_ptr = &utf__ptr;
- char *desc_end = utf_end(descr); /* points behind utf string */
+ java_objectheader *param;
+ s4 paramcount;
+ typedesc *paramtypes;
+ classinfo *c;
+ s4 i;
+ s4 j;
- jobject param;
- int cnt;
- int cnts;
- char c;
+ paramcount = descr->paramcount;
+ paramtypes = descr->paramtypes;
- /*
- log_text("fill_callblock");
- utf_display(descr);
- log_text("====");
- */
- /* skip '(' */
- utf_nextu2(utf_ptr);
+ /* if method is non-static fill first block and skip `this' pointer */
- /* determine number of parameters */
- if (obj) {
- blk[0].itemtype = TYPE_ADR;
- blk[0].item = PTR_TO_ITEM(obj);
- cnt=1;
+ i = 0;
- } else {
- cnt = 0;
- }
+ if (o != NULL) {
+ /* this pointer */
+ vmargs[0].type = TYPE_ADR;
+ vmargs[0].data = (u8) (ptrint) o;
- cnts = 0;
- while (**utf_ptr != ')') {
- if (*utf_ptr >= desc_end)
- panic("illegal method descriptor");
+ paramtypes++;
+ paramcount--;
+ i++;
+ }
+ for (j = 0; j < paramcount; i++, j++, paramtypes++) {
+ switch (paramtypes->type) {
/* primitive types */
- switch (utf_nextu2(utf_ptr)) {
- case 'B':
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- if (param->vftbl->class->name == utf_java_lang_Byte) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
+ case TYPE_INT:
+ case TYPE_LONG:
+ case TYPE_FLOAT:
+ case TYPE_DOUBLE:
+ param = params->data[j];
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- break;
+ if (param == NULL)
+ goto illegal_arg;
- case 'C':
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- if (param->vftbl->class->name == utf_java_lang_Character) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Character *) param)->value;
+ /* internally used data type */
+ vmargs[i].type = paramtypes->type;
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- break;
+ /* convert the value according to its declared type */
- case 'S':
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- if (param->vftbl->class->name == utf_java_lang_Short) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
-
- } else {
- if (param->vftbl->class->name == utf_java_lang_Byte) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
-
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- }
- break;
+ c = param->vftbl->class;
- case 'Z':
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- if (param->vftbl->class->name == utf_java_lang_Boolean) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Boolean *) param)->value;
+ switch (paramtypes->decltype) {
+ case PRIMITIVETYPE_BOOLEAN:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Boolean *) param)->value;
+ else
+ goto illegal_arg;
+ break;
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- break;
+ case PRIMITIVETYPE_BYTE:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
+ else
+ goto illegal_arg;
+ break;
- case 'I':
- /*log_text("fill_callblock_objA: param 'I'");*/
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- if (param->vftbl->class->name == utf_java_lang_Integer) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Integer *) param)->value;
- /*printf("INT VALUE :%d\n",((struct java_lang_Integer * )param)->value);*/
- } else {
- if (param->vftbl->class->name == utf_java_lang_Short) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
-
- } else {
- if (param->vftbl->class->name == utf_java_lang_Byte) {
- blk[cnt].itemtype = TYPE_INT;
- blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
-
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- }
- }
- break;
+ case PRIMITIVETYPE_CHAR:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Character *) param)->value;
+ else
+ goto illegal_arg;
+ break;
+
+ case PRIMITIVETYPE_SHORT:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Short *) param)->value;
+ else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
+ else
+ goto illegal_arg;
+ break;
+
+ case PRIMITIVETYPE_INT:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Integer *) param)->value;
+ else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Short *) param)->value;
+ else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
+ else
+ goto illegal_arg;
+ break;
+
+ case PRIMITIVETYPE_LONG:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Long *) param)->value;
+ else if (c == primitivetype_table[PRIMITIVETYPE_INT].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Integer *) param)->value;
+ else if (c == primitivetype_table[PRIMITIVETYPE_SHORT].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Short *) param)->value;
+ else if (c == primitivetype_table[PRIMITIVETYPE_BYTE].class_wrap)
+ vmargs[i].data = (s8) ((java_lang_Byte *) param)->value;
+ else
+ goto illegal_arg;
+ break;
+
+ case PRIMITIVETYPE_FLOAT:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ *((jfloat *) (&vmargs[i].data)) = (jfloat) ((java_lang_Float *) param)->value;
+ else
+ goto illegal_arg;
+ break;
+
+ case PRIMITIVETYPE_DOUBLE:
+ if (c == primitivetype_table[paramtypes->decltype].class_wrap)
+ *((jdouble *) (&vmargs[i].data)) = (jdouble) ((java_lang_Double *) param)->value;
+ else if (c == primitivetype_table[PRIMITIVETYPE_FLOAT].class_wrap)
+ *((jfloat *) (&vmargs[i].data)) = (jfloat) ((java_lang_Float *) param)->value;
+ else
+ goto illegal_arg;
+ break;
- case 'J':
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
+ default:
+ goto illegal_arg;
}
- if (param->vftbl->class->name == utf_java_lang_Long) {
- blk[cnt].itemtype = TYPE_LNG;
- blk[cnt].item = (u8) ((java_lang_Long *) param)->value;
-
- } else {
- if (param->vftbl->class->name == utf_java_lang_Integer) {
- blk[cnt].itemtype = TYPE_LNG;
- blk[cnt].item = (u8) ((java_lang_Integer *) param)->value;
-
- } else {
- if (param->vftbl->class->name == utf_java_lang_Short) {
- blk[cnt].itemtype = TYPE_LNG;
- blk[cnt].item = (u8) ((java_lang_Short *) param)->value;
-
- } else {
- if (param->vftbl->class->name == utf_java_lang_Byte) {
- blk[cnt].itemtype = TYPE_LNG;
- blk[cnt].item = (u8) ((java_lang_Byte *) param)->value;
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
+ break;
+
+ case TYPE_ADDRESS:
+ if (!resolve_class_from_typedesc(paramtypes, true, true, &c))
+ return false;
+
+ if (params->data[j] != 0) {
+ if (paramtypes->arraydim > 0) {
+ if (!builtin_arrayinstanceof(params->data[j], c))
+ goto illegal_arg;
+
+ } else {
+ if (!builtin_instanceof(params->data[j], c))
+ goto illegal_arg;
}
}
+ vmargs[i].type = TYPE_ADR;
+ vmargs[i].data = (u8) (ptrint) params->data[j];
+ break;
- }
- break;
+ default:
+ goto illegal_arg;
+ }
+ }
- case 'F':
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
+/* if (rettype) */
+/* *rettype = descr->returntype.decltype; */
- if (param->vftbl->class->name == utf_java_lang_Float) {
- blk[cnt].itemtype = TYPE_FLT;
- *((jfloat *) (&blk[cnt].item)) = (jfloat) ((java_lang_Float *) param)->value;
+ return true;
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- break;
+illegal_arg:
+ exceptions_throw_illegalargumentexception();
+ return false;
+}
- case 'D':
- param = params->data[cnts];
- if (param == 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- if (param->vftbl->class->name == utf_java_lang_Double) {
- blk[cnt].itemtype = TYPE_DBL;
- *((jdouble *) (&blk[cnt].item)) = (jdouble) ((java_lang_Float *) param)->value;
+/* _Jv_jni_CallObjectMethod ****************************************************
- } else {
- if (param->vftbl->class->name == utf_java_lang_Float) {
- blk[cnt].itemtype = TYPE_DBL;
- *((jdouble *) (&blk[cnt].item)) = (jdouble) ((java_lang_Float *) param)->value;
+ Internal function to call Java Object methods.
- } else {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- }
- break;
+*******************************************************************************/
- case 'V':
- panic("V not allowed as function parameter");
- break;
+static java_objectheader *_Jv_jni_CallObjectMethod(java_objectheader *o,
+ vftbl_t *vftbl,
+ methodinfo *m, va_list ap)
+{
+ methodinfo *resm;
+ java_objectheader *ro;
- case 'L':
- {
- char *start = (*utf_ptr) - 1;
- /*char *end = NULL;
+ STATISTICS(jniinvokation());
- while (utf_nextu2(utf_ptr) != ';')
- end = (*utf_ptr) + 1;*/
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
+ }
- if (!builtin_instanceof(params->data[cnts], class_from_descriptor(start, desc_end, utf_ptr, CLASSLOAD_LOAD))) {
- if (params->data[cnts] != 0) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
- }
- blk[cnt].itemtype = TYPE_ADR;
- blk[cnt].item = PTR_TO_ITEM(params->data[cnts]);
- break;
- }
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- case '[':
- {
- char *start = (*utf_ptr) - 1;
- /*char *end;
-
- char ch;
- while ((ch = utf_nextu2(utf_ptr)) == '[')
- if (ch == 'L') {
- while (utf_nextu2(utf_ptr) != ';') {}
- }
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
- end = (*utf_ptr) - 1;
- ch = utf_nextu2(utf_ptr); */
+ if (o != NULL)
+ o = NULL;
- if (!builtin_arrayinstanceof(params->data[cnts], class_from_descriptor(start, desc_end, utf_ptr, CLASSLOAD_LOAD)->vftbl)) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
+ /* for convenience */
- blk[cnt].itemtype = TYPE_ADR;
- blk[cnt].item = PTR_TO_ITEM(params->data[cnts]);
- break;
- }
- }
- cnt++;
- cnts++;
+ resm = m;
+
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
+
+ resm = method_vftbl_lookup(vftbl, m);
}
- c = utf_nextu2(utf_ptr);
- c = utf_nextu2(utf_ptr);
- return c; /*return type needed usage of the right lowlevel methods*/
-}
+ STATISTICS(jnicallXmethodnvokation());
+ ro = vm_call_method_valist(resm, o, ap);
-jmethodID get_virtual(jobject obj,jmethodID methodID) {
- if (obj->vftbl->class==methodID->class) return methodID;
- return class_resolvemethod (obj->vftbl->class, methodID->name, methodID->descriptor);
+ return ro;
}
-jmethodID get_nonvirtual(jclass clazz,jmethodID methodID) {
- if (clazz==methodID->class) return methodID;
-/*class_resolvemethod -> classfindmethod? (JOWENN)*/
- return class_resolvemethod (clazz, methodID->name, methodID->descriptor);
-}
+/* _Jv_jni_CallObjectMethodA ***************************************************
+ Internal function to call Java Object methods.
-jobject callObjectMethod (jobject obj, jmethodID methodID, va_list args)
-{
- int argcount;
- jni_callblock *blk;
- jobject ret;
+*******************************************************************************/
+static java_objectheader *_Jv_jni_CallObjectMethodA(java_objectheader *o,
+ vftbl_t *vftbl,
+ methodinfo *m, jvalue *args)
+{
+ methodinfo *resm;
+ java_objectheader *ro;
+ STATISTICS(jniinvokation());
- if (methodID == 0) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return 0;
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
}
- argcount = get_parametercount(methodID);
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
- ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return 0;
- }
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
- if (obj && !builtin_instanceof(obj, methodID->class)) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return 0;
- }
+ if (o != NULL)
+ o = NULL;
-#ifdef arglimit
+ /* for convenience */
- if (argcount > 3) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- log_text("Too many arguments. CallObjectMethod does not support that");
- return 0;
+ resm = m;
+
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
+
+ resm = method_vftbl_lookup(vftbl, m);
}
-#endif
- blk = MNEW(jni_callblock, /*4 */argcount+2);
+ STATISTICS(jnicallXmethodnvokation());
- fill_callblock(obj, methodID->descriptor, blk, args, 'O');
- /* printf("parameter: obj: %p",blk[0].item); */
- ret = asm_calljavafunction2(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- MFREE(blk, jni_callblock, argcount + 1);
- /* printf("(CallObjectMethodV)-->%p\n",ret); */
+ ro = vm_call_method_jvalue(resm, o, args);
- return ret;
+ return ro;
}
-/*
- core function for integer class methods (bool, byte, short, integer)
- This is basically needed for i386
-*/
-jint callIntegerMethod(jobject obj, jmethodID methodID, char retType, va_list args)
-{
- int argcount;
- jni_callblock *blk;
- jint ret;
-
-/* printf("%p, %c\n",retType,methodID,retType);*/
-
- /*
- log_text("JNI-Call: CallObjectMethodV");
- utf_display(methodID->name);
- utf_display(methodID->descriptor);
- printf("\nParmaeter count: %d\n",argcount);
- utf_display(obj->vftbl->class->name);
- printf("\n");
- */
- if (methodID == 0) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
+/* _Jv_jni_CallIntMethod *******************************************************
+
+ Internal function to call Java integer class methods (boolean,
+ byte, char, short, int).
+
+*******************************************************************************/
+
+static jint _Jv_jni_CallIntMethod(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, va_list ap)
+{
+ methodinfo *resm;
+ jint i;
+
+ STATISTICS(jniinvokation());
+
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
return 0;
}
- argcount = get_parametercount(methodID);
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
- ((!(methodID->flags & ACC_STATIC)) && (obj != 0)) )) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return 0;
- }
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
- if (obj && !builtin_instanceof(obj, methodID->class)) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return 0;
- }
+ if (o != NULL)
+ o = NULL;
-#ifdef arglimit
- if (argcount > 3) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- log_text("Too many arguments. CallIntegerMethod does not support that");
- return 0;
- }
-#endif
+ /* for convenience */
+
+ resm = m;
- blk = MNEW(jni_callblock, /*4 */ argcount+2);
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
- fill_callblock(obj, methodID->descriptor, blk, args, retType);
+ resm = method_vftbl_lookup(vftbl, m);
+ }
- /* printf("parameter: obj: %p",blk[0].item); */
- ret = asm_calljavafunction2int(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
+ STATISTICS(jnicallXmethodnvokation());
- MFREE(blk, jni_callblock, argcount + 1);
- /* printf("(CallObjectMethodV)-->%p\n",ret); */
+ i = vm_call_method_int_valist(resm, o, ap);
- return ret;
+ return i;
}
-/*core function for long class functions*/
-jlong callLongMethod(jobject obj, jmethodID methodID, va_list args)
+/* _Jv_jni_CallIntMethodA ******************************************************
+
+ Internal function to call Java integer class methods (boolean,
+ byte, char, short, int).
+
+*******************************************************************************/
+
+static jint _Jv_jni_CallIntMethodA(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, jvalue *args)
{
- int argcount;
- jni_callblock *blk;
- jlong ret;
+ methodinfo *resm;
+ jint i;
-/*
- log_text("JNI-Call: CallObjectMethodV");
- utf_display(methodID->name);
- utf_display(methodID->descriptor);
- printf("\nParmaeter count: %d\n",argcount);
- utf_display(obj->vftbl->class->name);
- printf("\n");
-*/
- if (methodID == 0) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
+ STATISTICS(jniinvokation());
+
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
return 0;
}
+
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- argcount = get_parametercount(methodID);
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
- if (!( ((methodID->flags & ACC_STATIC) && (obj == 0)) ||
- ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return 0;
- }
+ if (o != NULL)
+ o = NULL;
- if (obj && !builtin_instanceof(obj,methodID->class)) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return 0;
- }
+ /* for convenience */
-#ifdef arglimit
- if (argcount > 3) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- log_text("Too many arguments. CallObjectMethod does not support that");
- return 0;
- }
-#endif
+ resm = m;
- blk = MNEW(jni_callblock,/* 4 */argcount+2);
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
- fill_callblock(obj, methodID->descriptor, blk, args, 'J');
+ resm = method_vftbl_lookup(vftbl, m);
+ }
- /* printf("parameter: obj: %p",blk[0].item); */
- ret = asm_calljavafunction2long(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
+ STATISTICS(jnicallXmethodnvokation());
- MFREE(blk, jni_callblock, argcount + 1);
- /* printf("(CallObjectMethodV)-->%p\n",ret); */
+ i = vm_call_method_int_jvalue(resm, o, args);
- return ret;
+ return i;
}
-/*core function for float class methods (float,double)*/
-jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,char retType)
+/* _Jv_jni_CallLongMethod ******************************************************
+
+ Internal function to call Java long methods.
+
+*******************************************************************************/
+
+static jlong _Jv_jni_CallLongMethod(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, va_list ap)
{
- int argcount = get_parametercount(methodID);
- jni_callblock *blk;
- jdouble ret;
+ methodinfo *resm;
+ jlong l;
- /*
- log_text("JNI-Call: CallObjectMethodV");
- utf_display(methodID->name);
- utf_display(methodID->descriptor);
- printf("\nParmaeter count: %d\n",argcount);
- utf_display(obj->vftbl->class->name);
- printf("\n");
- */
+ STATISTICS(jniinvokation());
-#ifdef arglimit
- if (argcount > 3) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- log_text("Too many arguments. CallObjectMethod does not support that");
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
return 0;
}
-#endif
- blk = MNEW(jni_callblock, /*4 */ argcount+2);
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- fill_callblock(obj, methodID->descriptor, blk, args, retType);
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
- /* printf("parameter: obj: %p",blk[0].item); */
- ret = asm_calljavafunction2double(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
+ if (o != NULL)
+ o = NULL;
- MFREE(blk, jni_callblock, argcount + 1);
- /* printf("(CallObjectMethodV)-->%p\n",ret); */
-
- return ret;
-}
+ /* for convenience */
+ resm = m;
-/*************************** function: jclass_findfield ****************************
-
- searches for field with specified name and type in a 'classinfo'-structur
- if no such field is found NULL is returned
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
-************************************************************************************/
+ resm = method_vftbl_lookup(vftbl, m);
+ }
-fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
-{
- s4 i;
-/* printf(" FieldCount: %d\n",c->fieldscount);
- utf_display(c->name); */
- for (i = 0; i < c->fieldscount; i++) {
-/* utf_display(c->fields[i].name);
- printf("\n");
- utf_display(c->fields[i].descriptor);
- printf("\n");*/
- if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
- return &(c->fields[i]);
- }
+ STATISTICS(jnicallXmethodnvokation());
- if (c->super) return jclass_findfield(c->super,name,desc);
+ l = vm_call_method_long_valist(resm, o, ap);
- return NULL;
+ return l;
}
-/* GetVersion ******************************************************************
+/* _Jv_jni_CallFloatMethod *****************************************************
- Returns the major version number in the higher 16 bits and the
- minor version number in the lower 16 bits.
+ Internal function to call Java float methods.
*******************************************************************************/
-jint GetVersion(JNIEnv *env)
+static jfloat _Jv_jni_CallFloatMethod(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, va_list ap)
{
- /* GNU classpath currently supports JNI 1.2 */
+ methodinfo *resm;
+ jfloat f;
- return JNI_VERSION_1_2;
-}
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
-/* Class Operations ***********************************************************/
+ if (o != NULL)
+ o = NULL;
-/* DefineClass *****************************************************************
+ /* for convenience */
- Loads a class from a buffer of raw class data. The buffer
- containing the raw class data is not referenced by the VM after the
- DefineClass call returns, and it may be discarded if desired.
+ resm = m;
-*******************************************************************************/
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
-jclass DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize bufLen)
-{
- jclass c;
- jclass r;
- classbuffer *cb;
+ resm = method_vftbl_lookup(vftbl, m);
+ }
- c = class_new(utf_new_char_classname((char *) name));
+ STATISTICS(jnicallXmethodnvokation());
-#if defined(USE_THREADS)
- /* enter a monitor on the class */
+ f = vm_call_method_float_valist(resm, o, ap);
- builtin_monitorenter((java_objectheader *) c);
-#endif
+ return f;
+}
- /* measure time */
- if (getloadingtime)
- loadingtime_start();
- /* build a classbuffer with the given data */
- cb = NEW(classbuffer);
- cb->class = c;
- cb->size = bufLen;
- cb->data = (u1 *) buf;
- cb->pos = cb->data - 1;
+/* _Jv_jni_CallDoubleMethod ****************************************************
- r = class_load_intern(cb);
+ Internal function to call Java double methods.
- /* if return value is NULL, we had a problem and the class is not loaded */
- if (!r) {
- c->loaded = false;
+*******************************************************************************/
- /* now free the allocated memory, otherwise we could ran into a DOS */
- class_remove(c);
- }
+static jdouble _Jv_jni_CallDoubleMethod(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, va_list ap)
+{
+ methodinfo *resm;
+ jdouble d;
- /* free memory */
- FREE(cb, classbuffer);
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- /* measure time */
- if (getloadingtime)
- loadingtime_stop();
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
-#if defined(USE_THREADS)
- /* leave the monitor */
+ if (o != NULL)
+ o = NULL;
- builtin_monitorexit((java_objectheader *) c);
-#endif
+ /* for convenience */
+
+ resm = m;
- /* XXX link the class here? */
-/* if (class_link(c)) */
-/* return NULL; */
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
- if (r) {
- c->classloader = loader;
- use_class_as_object(r);
+ resm = method_vftbl_lookup(vftbl, m);
}
- return r;
+ d = vm_call_method_double_valist(resm, o, ap);
+
+ return d;
}
-/* FindClass *******************************************************************
+/* _Jv_jni_CallVoidMethod ******************************************************
- This function loads a locally-defined class. It searches the
- directories and zip files specified by the CLASSPATH environment
- variable for the class with the specified name.
+ Internal function to call Java void methods.
*******************************************************************************/
-jclass FindClass(JNIEnv *env, const char *name)
-{
- classinfo *c;
-
- c = class_new(utf_new_char_classname((char *) name));
+static void _Jv_jni_CallVoidMethod(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, va_list ap)
+{
+ methodinfo *resm;
- if (!class_load(c) || !class_link(c))
- return NULL;
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return;
+ }
- use_class_as_object(c);
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- return c;
-}
-
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
-/*******************************************************************************
+ if (o != NULL)
+ o = NULL;
- converts java.lang.reflect.Method or
- java.lang.reflect.Constructor object to a method ID
-
-*******************************************************************************/
-
-jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
-{
- log_text("JNI-Call: FromReflectedMethod: IMPLEMENT ME!!!");
+ /* for convenience */
- return 0;
+ resm = m;
+
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
+
+ resm = method_vftbl_lookup(vftbl, m);
+ }
+
+ STATISTICS(jnicallXmethodnvokation());
+
+ (void) vm_call_method_valist(resm, o, ap);
}
-/* GetSuperclass ***************************************************************
+/* _Jv_jni_CallVoidMethodA *****************************************************
- If clazz represents any class other than the class Object, then
- this function returns the object that represents the superclass of
- the class specified by clazz.
+ Internal function to call Java void methods.
*******************************************************************************/
-
-jclass GetSuperclass(JNIEnv* env, jclass sub)
-{
- classinfo *c;
- c = ((classinfo *) sub)->super;
+static void _Jv_jni_CallVoidMethodA(java_objectheader *o, vftbl_t *vftbl,
+ methodinfo *m, jvalue *args)
+{
+ methodinfo *resm;
- if (!c)
- return NULL;
+ if (m == NULL) {
+ exceptions_throw_nullpointerexception();
+ return;
+ }
- use_class_as_object(c);
+ /* Class initialization is done by the JIT compiler. This is ok
+ since a static method always belongs to the declaring class. */
- return c;
-}
-
-
-/* IsAssignableFrom ************************************************************
+ if (m->flags & ACC_STATIC) {
+ /* For static methods we reset the object. */
- Determines whether an object of sub can be safely cast to sup.
+ if (o != NULL)
+ o = NULL;
-*******************************************************************************/
+ /* for convenience */
-jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
-{
- return builtin_isanysubclass(sub, sup);
-}
+ resm = m;
+ } else {
+ /* For instance methods we make a virtual function table lookup. */
-/***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
+ resm = method_vftbl_lookup(vftbl, m);
+ }
-jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
-{
- log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!!!");
+ STATISTICS(jnicallXmethodnvokation());
- return NULL;
+ (void) vm_call_method_jvalue(resm, o, args);
}
-/* Throw ***********************************************************************
+/* _Jv_jni_invokeNative ********************************************************
- Causes a java.lang.Throwable object to be thrown.
+ Invoke a method on the given object with the given arguments.
+
+ For instance methods OBJ must be != NULL and the method is looked up
+ in the vftbl of the object.
+
+ For static methods, OBJ is ignored.
*******************************************************************************/
-jint Throw(JNIEnv *env, jthrowable obj)
+java_objectheader *_Jv_jni_invokeNative(methodinfo *m, java_objectheader *o,
+ java_objectarray *params)
{
- *exceptionptr = (java_objectheader *) obj;
-
- return JNI_OK;
-}
+ methodinfo *resm;
+ vm_arg *vmargs;
+ java_objectheader *ro;
+ s4 argcount;
+ s4 paramcount;
+ if (!m) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
+ }
-/* ThrowNew ********************************************************************
+ argcount = m->parseddesc->paramcount;
+ paramcount = argcount;
- Constructs an exception object from the specified class with the message
- specified by message and causes that exception to be thrown.
+ /* if method is non-static, remove the `this' pointer */
-*******************************************************************************/
+ if (!(m->flags & ACC_STATIC))
+ paramcount--;
-jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
-{
- java_lang_Throwable *o;
+ /* For instance methods the object has to be an instance of the
+ class the method belongs to. For static methods the obj
+ parameter is ignored. */
+
+ if (!(m->flags & ACC_STATIC) && o && (!builtin_instanceof(o, m->class))) {
+ *exceptionptr =
+ new_exception_message(string_java_lang_IllegalArgumentException,
+ "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
+ return NULL;
+ }
+
+ /* check if we got the right number of arguments */
+
+ if (((params == NULL) && (paramcount != 0)) ||
+ (params && (params->header.size != paramcount)))
+ {
+ *exceptionptr =
+ new_exception(string_java_lang_IllegalArgumentException);
+ return NULL;
+ }
+
+ /* for instance methods we need an object */
+
+ if (!(m->flags & ACC_STATIC) && (o == NULL)) {
+ *exceptionptr =
+ new_exception_message(string_java_lang_NullPointerException,
+ "Static mismatch in Java_java_lang_reflect_Method_invokeNative");
+ return NULL;
+ }
+
+ /* for static methods, zero object to make subsequent code simpler */
+ if (m->flags & ACC_STATIC)
+ o = NULL;
+
+ if (o != NULL) {
+ /* for instance methods we must do a vftbl lookup */
+ resm = method_vftbl_lookup(o->vftbl, m);
+
+ } else {
+ /* for static methods, just for convenience */
+ resm = m;
+ }
+
+ vmargs = MNEW(vm_arg, argcount);
+
+ if (!_Jv_jni_vmargs_from_objectarray(o, resm->parseddesc, vmargs, params))
+ return NULL;
+
+ switch (resm->parseddesc->returntype.decltype) {
+ case TYPE_VOID:
+ (void) vm_call_method_vmarg(resm, argcount, vmargs);
+
+ ro = NULL;
+ break;
+
+ case PRIMITIVETYPE_BOOLEAN: {
+ s4 i;
+ java_lang_Boolean *bo;
+
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Boolean);
+
+ /* setting the value of the object direct */
+
+ bo = (java_lang_Boolean *) ro;
+ bo->value = i;
+ }
+ break;
+
+ case PRIMITIVETYPE_BYTE: {
+ s4 i;
+ java_lang_Byte *bo;
+
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Byte);
+
+ /* setting the value of the object direct */
+
+ bo = (java_lang_Byte *) ro;
+ bo->value = i;
+ }
+ break;
+
+ case PRIMITIVETYPE_CHAR: {
+ s4 i;
+ java_lang_Character *co;
+
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Character);
+
+ /* setting the value of the object direct */
+
+ co = (java_lang_Character *) ro;
+ co->value = i;
+ }
+ break;
+
+ case PRIMITIVETYPE_SHORT: {
+ s4 i;
+ java_lang_Short *so;
+
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Short);
+
+ /* setting the value of the object direct */
+
+ so = (java_lang_Short *) ro;
+ so->value = i;
+ }
+ break;
+
+ case PRIMITIVETYPE_INT: {
+ s4 i;
+ java_lang_Integer *io;
+
+ i = vm_call_method_int_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Integer);
+
+ /* setting the value of the object direct */
+
+ io = (java_lang_Integer *) ro;
+ io->value = i;
+ }
+ break;
+
+ case PRIMITIVETYPE_LONG: {
+ s8 l;
+ java_lang_Long *lo;
+
+ l = vm_call_method_long_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Long);
+
+ /* setting the value of the object direct */
+
+ lo = (java_lang_Long *) ro;
+ lo->value = l;
+ }
+ break;
+
+ case PRIMITIVETYPE_FLOAT: {
+ float f;
+ java_lang_Float *fo;
+
+ f = vm_call_method_float_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Float);
+
+ /* setting the value of the object direct */
+
+ fo = (java_lang_Float *) ro;
+ fo->value = f;
+ }
+ break;
+
+ case PRIMITIVETYPE_DOUBLE: {
+ double d;
+ java_lang_Double *_do;
+
+ d = vm_call_method_double_vmarg(resm, argcount, vmargs);
+
+ ro = builtin_new(class_java_lang_Double);
+
+ /* setting the value of the object direct */
+
+ _do = (java_lang_Double *) ro;
+ _do->value = d;
+ }
+ break;
+
+ case TYPE_ADR:
+ ro = vm_call_method_vmarg(resm, argcount, vmargs);
+ break;
+
+ default:
+ /* if this happens the exception has already been set by
+ fill_callblock_from_objectarray */
+
+ MFREE(vmargs, vm_arg, argcount);
+
+ return NULL;
+ }
+
+ MFREE(vmargs, vm_arg, argcount);
+
+ if (*exceptionptr) {
+ java_objectheader *cause;
+
+ cause = *exceptionptr;
+
+ /* clear exception pointer, we are calling JIT code again */
+
+ *exceptionptr = NULL;
+
+ *exceptionptr =
+ new_exception_throwable(string_java_lang_reflect_InvocationTargetException,
+ (java_lang_Throwable *) cause);
+ }
+
+ return ro;
+}
+
+
+/* GetVersion ******************************************************************
+
+ Returns the major version number in the higher 16 bits and the
+ minor version number in the lower 16 bits.
+
+*******************************************************************************/
+
+jint GetVersion(JNIEnv *env)
+{
+ STATISTICS(jniinvokation());
+
+ /* we support JNI 1.4 */
+
+ return JNI_VERSION_1_4;
+}
+
+
+/* Class Operations ***********************************************************/
+
+/* DefineClass *****************************************************************
+
+ Loads a class from a buffer of raw class data. The buffer
+ containing the raw class data is not referenced by the VM after the
+ DefineClass call returns, and it may be discarded if desired.
+
+*******************************************************************************/
+
+jclass DefineClass(JNIEnv *env, const char *name, jobject loader,
+ const jbyte *buf, jsize bufLen)
+{
+ java_lang_ClassLoader *cl;
+ java_lang_String *s;
+ java_bytearray *ba;
+ jclass c;
+
+ STATISTICS(jniinvokation());
+
+ cl = (java_lang_ClassLoader *) loader;
+ s = javastring_new_char(name);
+ ba = (java_bytearray *) buf;
+
+ c = (jclass) Java_java_lang_VMClassLoader_defineClass(env, NULL, cl, s, ba,
+ 0, bufLen, NULL);
+
+ return (jclass) NewLocalRef(env, (jobject) c);
+}
+
+
+/* FindClass *******************************************************************
+
+ This function loads a locally-defined class. It searches the
+ directories and zip files specified by the CLASSPATH environment
+ variable for the class with the specified name.
+
+*******************************************************************************/
+
+jclass FindClass(JNIEnv *env, const char *name)
+{
+ utf *u;
+ classinfo *cc;
+ classinfo *c;
+
+ STATISTICS(jniinvokation());
+
+ u = utf_new_char_classname((char *) name);
+
+ /* Check stacktrace for classloader, if one found use it,
+ otherwise use the system classloader. */
+
+ /* Quote from the JNI documentation:
+
+ In the Java 2 Platform, FindClass locates the class loader
+ associated with the current native method. If the native code
+ belongs to a system class, no class loader will be
+ involved. Otherwise, the proper class loader will be invoked to
+ load and link the named class. When FindClass is called through
+ the Invocation Interface, there is no current native method or
+ its associated class loader. In that case, the result of
+ ClassLoader.getBaseClassLoader is used." */
+
+#if defined(__ALPHA__) || defined(__ARM__) || defined(__I386__) || defined(__MIPS__) || defined(__POWERPC__) || defined(__X86_64__)
+ /* these JITs support stacktraces, and so does the interpreter */
+
+ cc = stacktrace_getCurrentClass();
+#else
+# if defined(ENABLE_INTRP)
+ /* the interpreter supports stacktraces, even if the JIT does not */
+
+ if (opt_intrp)
+ cc = stacktrace_getCurrentClass();
+ else
+# endif
+ cc = NULL;
+#endif
+
+ /* if no Java method was found, use the system classloader */
+
+ if (cc == NULL)
+ c = load_class_from_sysloader(u);
+ else
+ c = load_class_from_classloader(u, cc->classloader);
+
+ if (c == NULL)
+ return NULL;
+
+ if (!link_class(c))
+ return NULL;
+
+ return (jclass) NewLocalRef(env, (jobject) c);
+}
+
+
+/* GetSuperclass ***************************************************************
+
+ If clazz represents any class other than the class Object, then
+ this function returns the object that represents the superclass of
+ the class specified by clazz.
+
+*******************************************************************************/
+
+jclass GetSuperclass(JNIEnv *env, jclass sub)
+{
+ classinfo *c;
+
+ STATISTICS(jniinvokation());
+
+ c = ((classinfo *) sub)->super.cls;
+
+ if (!c)
+ return NULL;
+
+ return (jclass) NewLocalRef(env, (jobject) c);
+}
+
+
+/* IsAssignableFrom ************************************************************
+
+ Determines whether an object of sub can be safely cast to sup.
+
+*******************************************************************************/
+
+jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
+{
+ STATISTICS(jniinvokation());
+
+ return Java_java_lang_VMClass_isAssignableFrom(env,
+ NULL,
+ (java_lang_Class *) sup,
+ (java_lang_Class *) sub);
+}
+
+
+/* Throw ***********************************************************************
+
+ Causes a java.lang.Throwable object to be thrown.
+
+*******************************************************************************/
+
+jint Throw(JNIEnv *env, jthrowable obj)
+{
+ STATISTICS(jniinvokation());
+
+ *exceptionptr = (java_objectheader *) obj;
+
+ return JNI_OK;
+}
+
+
+/* ThrowNew ********************************************************************
+
+ Constructs an exception object from the specified class with the
+ message specified by message and causes that exception to be
+ thrown.
+
+*******************************************************************************/
+
+jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
+{
+ java_lang_Throwable *o;
+ java_lang_String *s;
+
+ STATISTICS(jniinvokation());
+
+ s = (java_lang_String *) javastring_new_char(msg);
/* instantiate exception object */
o = (java_lang_Throwable *) native_new_and_init_string((classinfo *) clazz,
- (java_lang_String *) javastring_new_char(msg));
+ s);
if (!o)
return -1;
jthrowable ExceptionOccurred(JNIEnv *env)
{
- return (jthrowable) *exceptionptr;
+ java_objectheader *e;
+
+ STATISTICS(jniinvokation());
+
+ e = *exceptionptr;
+
+ return NewLocalRef(env, (jthrowable) e);
}
java_objectheader *e;
methodinfo *m;
+ STATISTICS(jniinvokation());
+
e = *exceptionptr;
if (e) {
/* print the stacktrace */
- asm_calljavafunction(m, e, NULL, NULL, NULL);
+ (void) vm_call_method(m, e);
}
}
Clears any exception that is currently being thrown. If no
exception is currently being thrown, this routine has no effect.
-*******************************************************************************/
+*******************************************************************************/
+
+void ExceptionClear(JNIEnv *env)
+{
+ STATISTICS(jniinvokation());
+
+ *exceptionptr = NULL;
+}
+
+
+/* FatalError ******************************************************************
+
+ Raises a fatal error and does not expect the VM to recover. This
+ function does not return.
+
+*******************************************************************************/
+
+void FatalError(JNIEnv *env, const char *msg)
+{
+ STATISTICS(jniinvokation());
+
+ throw_cacao_exception_exit(string_java_lang_InternalError, msg);
+}
+
+
+/* PushLocalFrame **************************************************************
+
+ Creates a new local reference frame, in which at least a given
+ number of local references can be created.
+
+*******************************************************************************/
+
+jint PushLocalFrame(JNIEnv* env, jint capacity)
+{
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: PushLocalFrame: IMPLEMENT ME!");
+
+ assert(0);
+
+ return 0;
+}
+
+/* PopLocalFrame ***************************************************************
+
+ Pops off the current local reference frame, frees all the local
+ references, and returns a local reference in the previous local
+ reference frame for the given result object.
+
+*******************************************************************************/
+
+jobject PopLocalFrame(JNIEnv* env, jobject result)
+{
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: PopLocalFrame: IMPLEMENT ME!");
+
+ assert(0);
+
+ /* add local reference and return the value */
+
+ return NewLocalRef(env, NULL);
+}
+
+
+/* DeleteLocalRef **************************************************************
+
+ Deletes the local reference pointed to by localRef.
+
+*******************************************************************************/
+
+void DeleteLocalRef(JNIEnv *env, jobject localRef)
+{
+ java_objectheader *o;
+ localref_table *lrt;
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ o = (java_objectheader *) localRef;
+
+ /* get local reference table (thread specific) */
+
+ lrt = LOCALREFTABLE;
+
+ /* remove the reference */
+
+ for (i = 0; i < lrt->capacity; i++) {
+ if (lrt->refs[i] == o) {
+ lrt->refs[i] = NULL;
+ lrt->used--;
+
+ return;
+ }
+ }
+
+ /* this should not happen */
+
+/* if (opt_checkjni) */
+/* FatalError(env, "Bad global or local ref passed to JNI"); */
+ log_text("JNI-DeleteLocalRef: Bad global or local ref passed to JNI");
+}
+
+
+/* IsSameObject ****************************************************************
+
+ Tests whether two references refer to the same Java object.
+
+*******************************************************************************/
+
+jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
+{
+ STATISTICS(jniinvokation());
+
+ if (ref1 == ref2)
+ return JNI_TRUE;
+ else
+ return JNI_FALSE;
+}
+
+
+/* NewLocalRef *****************************************************************
+
+ Creates a new local reference that refers to the same object as ref.
+
+*******************************************************************************/
+
+jobject NewLocalRef(JNIEnv *env, jobject ref)
+{
+ localref_table *lrt;
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ if (ref == NULL)
+ return NULL;
+
+ /* get local reference table (thread specific) */
+
+ lrt = LOCALREFTABLE;
+
+ /* check if we have space for the requested reference */
+
+ if (lrt->used == lrt->capacity) {
+/* throw_cacao_exception_exit(string_java_lang_InternalError, */
+/* "Too many local references"); */
+ fprintf(stderr, "Too many local references");
+ assert(0);
+ }
+
+ /* insert the reference */
+
+ for (i = 0; i < lrt->capacity; i++) {
+ if (lrt->refs[i] == NULL) {
+ lrt->refs[i] = (java_objectheader *) ref;
+ lrt->used++;
+
+ return ref;
+ }
+ }
+
+ /* should not happen, just to be sure */
+
+ assert(0);
+
+ /* keep compiler happy */
+
+ return NULL;
+}
+
+
+/* EnsureLocalCapacity *********************************************************
+
+ Ensures that at least a given number of local references can be
+ created in the current thread
+
+*******************************************************************************/
+
+jint EnsureLocalCapacity(JNIEnv* env, jint capacity)
+{
+ localref_table *lrt;
+
+ STATISTICS(jniinvokation());
+
+ /* get local reference table (thread specific) */
+
+ lrt = LOCALREFTABLE;
+
+ /* check if capacity elements are available in the local references table */
+
+ if ((lrt->used + capacity) > lrt->capacity) {
+ *exceptionptr = new_exception(string_java_lang_OutOfMemoryError);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/* AllocObject *****************************************************************
+
+ Allocates a new Java object without invoking any of the
+ constructors for the object. Returns a reference to the object.
+
+*******************************************************************************/
+
+jobject AllocObject(JNIEnv *env, jclass clazz)
+{
+ classinfo *c;
+ java_objectheader *o;
+
+ STATISTICS(jniinvokation());
+
+ c = (classinfo *) clazz;
+
+ if ((c->flags & ACC_INTERFACE) || (c->flags & ACC_ABSTRACT)) {
+ *exceptionptr =
+ new_exception_utfmessage(string_java_lang_InstantiationException,
+ c->name);
+ return NULL;
+ }
+
+ o = builtin_new(c);
+
+ return NewLocalRef(env, o);
+}
+
+
+/* NewObject *******************************************************************
+
+ Programmers place all arguments that are to be passed to the
+ constructor immediately following the methodID
+ argument. NewObject() accepts these arguments and passes them to
+ the Java method that the programmer wishes to invoke.
+
+*******************************************************************************/
+
+jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+
+ STATISTICS(jniinvokation());
+
+ m = (methodinfo *) methodID;
+
+ /* create object */
+
+ o = builtin_new(clazz);
+
+ if (o == NULL)
+ return NULL;
+
+ /* call constructor */
+
+ va_start(ap, methodID);
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return NewLocalRef(env, o);
+}
+
+
+/* NewObjectV ******************************************************************
+
+ Programmers place all arguments that are to be passed to the
+ constructor in an args argument of type va_list that immediately
+ follows the methodID argument. NewObjectV() accepts these
+ arguments, and, in turn, passes them to the Java method that the
+ programmer wishes to invoke.
+
+*******************************************************************************/
+
+jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+
+ STATISTICS(jniinvokation());
+
+ m = (methodinfo *) methodID;
+
+ /* create object */
+
+ o = builtin_new(clazz);
+
+ if (o == NULL)
+ return NULL;
+
+ /* call constructor */
+
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, args);
+
+ return NewLocalRef(env, o);
+}
+
+
+/* NewObjectA *****************************************************************
+
+ Programmers place all arguments that are to be passed to the
+ constructor in an args array of jvalues that immediately follows
+ the methodID argument. NewObjectA() accepts the arguments in this
+ array, and, in turn, passes them to the Java method that the
+ programmer wishes to invoke.
+
+*******************************************************************************/
+
+jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+
+ STATISTICS(jniinvokation());
+
+ m = (methodinfo *) methodID;
+
+ /* create object */
+
+ o = builtin_new(clazz);
+
+ if (o == NULL)
+ return NULL;
+
+ /* call constructor */
+
+ _Jv_jni_CallVoidMethodA(o, o->vftbl, m, args);
+
+ return NewLocalRef(env, o);
+}
+
+
+/* GetObjectClass **************************************************************
+
+ Returns the class of an object.
+
+*******************************************************************************/
+
+jclass GetObjectClass(JNIEnv *env, jobject obj)
+{
+ java_objectheader *o;
+ classinfo *c;
+
+ STATISTICS(jniinvokation());
+
+ o = (java_objectheader *) obj;
+
+ if ((o == NULL) || (o->vftbl == NULL))
+ return NULL;
+
+ c = o->vftbl->class;
+
+ return (jclass) NewLocalRef(env, (jobject) c);
+}
+
+
+/* IsInstanceOf ****************************************************************
+
+ Tests whether an object is an instance of a class.
+
+*******************************************************************************/
+
+jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
+{
+ STATISTICS(jniinvokation());
+
+ return Java_java_lang_VMClass_isInstance(env,
+ NULL,
+ (java_lang_Class *) clazz,
+ (java_lang_Object *) obj);
+}
+
+
+/* Reflection Support *********************************************************/
+
+/* FromReflectedMethod *********************************************************
+
+ Converts java.lang.reflect.Method or java.lang.reflect.Constructor
+ object to a method ID.
+
+*******************************************************************************/
+
+jmethodID FromReflectedMethod(JNIEnv *env, jobject method)
+{
+ methodinfo *mi;
+ classinfo *c;
+ s4 slot;
+
+ STATISTICS(jniinvokation());
+
+ if (method == NULL)
+ return NULL;
+
+ if (builtin_instanceof(method, class_java_lang_reflect_Method)) {
+ java_lang_reflect_Method *rm;
+
+ rm = (java_lang_reflect_Method *) method;
+ c = (classinfo *) (rm->declaringClass);
+ slot = rm->slot;
+
+ } else if (builtin_instanceof(method, class_java_lang_reflect_Constructor)) {
+ java_lang_reflect_Constructor *rc;
+
+ rc = (java_lang_reflect_Constructor *) method;
+ c = (classinfo *) (rc->clazz);
+ slot = rc->slot;
+
+ } else
+ return NULL;
+
+ mi = &(c->methods[slot]);
+
+ return (jmethodID) mi;
+}
+
+
+/* FromReflectedField **********************************************************
+
+ Converts a java.lang.reflect.Field to a field ID.
+
+*******************************************************************************/
+
+jfieldID FromReflectedField(JNIEnv* env, jobject field)
+{
+ java_lang_reflect_Field *rf;
+ classinfo *c;
+ fieldinfo *f;
+
+ STATISTICS(jniinvokation());
+
+ rf = (java_lang_reflect_Field *) field;
+
+ if (rf == NULL)
+ return NULL;
+
+ c = (classinfo *) rf->declaringClass;
+
+ f = &(c->fields[rf->slot]);
+
+ return (jfieldID) f;
+}
+
+
+/* ToReflectedMethod ***********************************************************
+
+ Converts a method ID derived from cls to an instance of the
+ java.lang.reflect.Method class or to an instance of the
+ java.lang.reflect.Constructor class.
+
+*******************************************************************************/
+
+jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
+{
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: ToReflectedMethod: IMPLEMENT ME!");
+
+ return NULL;
+}
+
+
+/* ToReflectedField ************************************************************
+
+ Converts a field ID derived from cls to an instance of the
+ java.lang.reflect.Field class.
+
+*******************************************************************************/
+
+jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
+ jboolean isStatic)
+{
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!");
+
+ return NULL;
+}
+
+
+/* Calling Instance Methods ***************************************************/
+
+/* GetMethodID *****************************************************************
+
+ Returns the method ID for an instance (nonstatic) method of a class
+ or interface. The method may be defined in one of the clazz's
+ superclasses and inherited by clazz. The method is determined by
+ its name and signature.
+
+ GetMethodID() causes an uninitialized class to be initialized.
+
+*******************************************************************************/
+
+jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name,
+ const char *sig)
+{
+ classinfo *c;
+ utf *uname;
+ utf *udesc;
+ methodinfo *m;
+
+ STATISTICS(jniinvokation());
+
+ c = (classinfo *) clazz;
+
+ if (!c)
+ return NULL;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return NULL;
+
+ /* try to get the method of the class or one of it's superclasses */
+
+ uname = utf_new_char((char *) name);
+ udesc = utf_new_char((char *) sig);
+
+ m = class_resolvemethod(clazz, uname, udesc);
+
+ if ((m == NULL) || (m->flags & ACC_STATIC)) {
+ exceptions_throw_nosuchmethoderror(c, uname, udesc);
+
+ return NULL;
+ }
+
+ return (jmethodID) m;
+}
+
+
+/* JNI-functions for calling instance methods *********************************/
+
+jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ java_objectheader *ret;
+ va_list ap;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return NewLocalRef(env, ret);
+}
+
+
+jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ java_objectheader *ret;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, args);
+
+ return NewLocalRef(env, ret);
+}
+
+
+jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ java_objectheader *ret;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ ret = _Jv_jni_CallObjectMethodA(o, o->vftbl, m, args);
+
+ return NewLocalRef(env, ret);
+}
+
+
+jboolean CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return b;
+}
+
+
+jboolean CallBooleanMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
+
+ return b;
+}
+
+
+jboolean CallBooleanMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethodA(o, o->vftbl, m, args);
+
+ return b;
+}
+
+
+jbyte CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jbyte b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return b;
+
+}
+
+jbyte CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jbyte b;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
+
+ return b;
+}
+
+
+jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallByteMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jchar c;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ c = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return c;
+}
+
+
+jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jchar c;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ c = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
+
+ return c;
+}
+
+
+jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallCharMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jshort s;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ s = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return s;
+}
+
+
+jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jshort s;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ s = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
+
+ return s;
+}
+
+
+jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallShortMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+
+jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jint i;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ i = _Jv_jni_CallIntMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return i;
+}
+
+
+jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jint i;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ i = _Jv_jni_CallIntMethod(o, o->vftbl, m, args);
+
+ return i;
+}
+
+
+jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallIntMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+
+jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jlong l;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ l = _Jv_jni_CallLongMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return l;
+}
+
+
+jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jlong l;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ l = _Jv_jni_CallLongMethod(o, o->vftbl, m, args);
+
+ return l;
+}
+
+
+jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallLongMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+
+jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jfloat f;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return f;
+}
+
+
+jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jfloat f;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ f = _Jv_jni_CallFloatMethod(o, o->vftbl, m, args);
+
+ return f;
+}
+
+
+jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallFloatMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+
+jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+ jdouble d;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+
+ return d;
+}
+
+
+jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ jdouble d;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ d = _Jv_jni_CallDoubleMethod(o, o->vftbl, m, args);
+
+ return d;
+}
+
+
+jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallDoubleMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+
+void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ methodinfo *m;
+ va_list ap;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, ap);
+ va_end(ap);
+}
+
+
+void CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethod(o, o->vftbl, m, args);
+}
+
+
+void CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+{
+ java_objectheader *o;
+ methodinfo *m;
+
+ o = (java_objectheader *) obj;
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethodA(o, o->vftbl, m, args);
+}
+
+
+
+jobject CallNonvirtualObjectMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ java_objectheader *r;
+ va_list ap;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, ap);
+ va_end(ap);
+
+ return NewLocalRef(env, r);
+}
+
+
+jobject CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ java_objectheader *r;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, args);
+
+ return NewLocalRef(env, r);
+}
+
+
+jobject CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!");
+
+ return NewLocalRef(env, NULL);
+}
+
+
+
+jboolean CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
+ va_end(ap);
+
+ return b;
+}
+
+
+jboolean CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jboolean b;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
+
+ return b;
+}
+
+
+jboolean CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallNonvirtualBooleanMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+jbyte CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jbyte b;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
+ va_end(ap);
+
+ return b;
+}
+
+
+jbyte CallNonvirtualByteMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jbyte b;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
+
+ return b;
+}
+
+
+jbyte CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallNonvirtualByteMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
+
+jchar CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jchar ch;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
+ va_end(ap);
+
+ return ch;
+}
+
+
+jchar CallNonvirtualCharMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jchar ch;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ ch = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
+
+ return ch;
+}
+
+
+jchar CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallNonvirtualCharMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
+
-void ExceptionClear(JNIEnv *env)
+jshort CallNonvirtualShortMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
- *exceptionptr = NULL;
-}
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jshort s;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-/* FatalError ******************************************************************
+ va_start(ap, methodID);
+ s = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
+ va_end(ap);
- Raises a fatal error and does not expect the VM to recover. This
- function does not return.
+ return s;
+}
-*******************************************************************************/
-void FatalError(JNIEnv *env, const char *msg)
+jshort CallNonvirtualShortMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- throw_cacao_exception_exit(string_java_lang_InternalError, msg);
-}
-
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jshort s;
-/******************* creates a new local reference frame **************************/
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-jint PushLocalFrame(JNIEnv* env, jint capacity)
-{
- /* empty */
+ s = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
- return 0;
+ return s;
}
-/**************** Pops off the current local reference frame **********************/
-jobject PopLocalFrame(JNIEnv* env, jobject result)
+jshort CallNonvirtualShortMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: PopLocalFrame");
- /* empty */
+ log_text("JNI-Call: CallNonvirtualShortMethodA: IMPLEMENT ME!");
- return NULL;
+ return 0;
}
-/*************** Deletes the local reference pointed to by localRef ***************/
-void DeleteLocalRef (JNIEnv* env, jobject localRef)
+jint CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
-/* log_text("JNI-Call: DeleteLocalRef");*/
- /* empty */
-}
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jint i;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-/* IsSameObject ****************************************************************
+ va_start(ap, methodID);
+ i = _Jv_jni_CallIntMethod(o, c->vftbl, m, ap);
+ va_end(ap);
- Tests whether two references refer to the same Java object.
+ return i;
+}
-*******************************************************************************/
-jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
+jint CallNonvirtualIntMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- return (ref1 == ref2);
-}
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jint i;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-/***** Creates a new local reference that refers to the same object as ref *******/
+ i = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);
-jobject NewLocalRef (JNIEnv* env, jobject ref)
-{
- return ref;
+ return i;
}
-/***********************************************************************************
- Ensures that at least a given number of local references can
- be created in the current thread
+jint CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallNonvirtualIntMethodA: IMPLEMENT ME!");
+
+ return 0;
+}
+
- **********************************************************************************/
-jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
+jlong CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
- return 0; /* return 0 on success */
-}
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jlong l;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-/* AllocObject *****************************************************************
+ va_start(ap, methodID);
+ l = _Jv_jni_CallLongMethod(o, c->vftbl, m, ap);
+ va_end(ap);
- Allocates a new Java object without invoking any of the constructors for the
- object. Returns a reference to the object.
+ return l;
+}
-*******************************************************************************/
-jobject AllocObject(JNIEnv *env, jclass clazz)
+jlong CallNonvirtualLongMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jlong l;
- if ((clazz->flags & ACC_INTERFACE) || (clazz->flags & ACC_ABSTRACT)) {
- *exceptionptr =
- new_exception_utfmessage(string_java_lang_InstantiationException,
- clazz->name);
- return NULL;
- }
-
- o = builtin_new(clazz);
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- return o;
+ l = _Jv_jni_CallLongMethod(o, c->vftbl, m, args);
+
+ return l;
}
-/* NewObject *******************************************************************
+jlong CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ log_text("JNI-Call: CallNonvirtualLongMethodA: IMPLEMENT ME!");
- Constructs a new Java object. The method ID indicates which constructor
- method to invoke. This ID must be obtained by calling GetMethodID() with
- <init> as the method name and void (V) as the return type.
+ return 0;
+}
-*******************************************************************************/
-jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+
+jfloat CallNonvirtualFloatMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
java_objectheader *o;
- void* args[3];
- int argcount=get_parametercount(methodID);
- int i;
- va_list vaargs;
-
-#ifdef arglimit
- if (argcount > 3) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- log_text("Too many arguments. NewObject does not support that");
- return 0;
- }
-#endif
-
- /* create object */
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jfloat f;
- o = builtin_new(clazz);
-
- if (!o)
- return NULL;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- va_start(vaargs, methodID);
- for (i = 0; i < argcount; i++) {
- args[i] = va_arg(vaargs, void*);
- }
- va_end(vaargs);
+ va_start(ap, methodID);
+ f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, ap);
+ va_end(ap);
- /* call constructor */
+ return f;
+}
- asm_calljavafunction(methodID, o, args[0], args[1], args[2]);
- return o;
-}
+jfloat CallNonvirtualFloatMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jfloat f;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-/***********************************************************************************
+ f = _Jv_jni_CallFloatMethod(o, c->vftbl, m, args);
- Constructs a new Java object
- arguments that are to be passed to the constructor are placed in va_list args
+ return f;
+}
-***********************************************************************************/
-jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
+jfloat CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- /* log_text("JNI-Call: NewObjectV"); */
+ log_text("JNI-Call: CallNonvirtualFloatMethodA: IMPLEMENT ME!");
- return NULL;
+ return 0;
}
-/***********************************************************************************
- Constructs a new Java object
- arguments that are to be passed to the constructor are placed in
- args array of jvalues
+jdouble CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
+ jdouble d;
-***********************************************************************************/
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
-{
- /* log_text("JNI-Call: NewObjectA"); */
+ va_start(ap, methodID);
+ d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, ap);
+ va_end(ap);
- return NULL;
+ return d;
}
-/************************ returns the class of an object **************************/
-
-jclass GetObjectClass(JNIEnv* env, jobject obj)
+jdouble CallNonvirtualDoubleMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- classinfo *c = obj->vftbl->class;
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ jdouble d;
- use_class_as_object(c);
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
- return c;
-}
+ d = _Jv_jni_CallDoubleMethod(o, c->vftbl, m, args);
+ return d;
+}
-/************* tests whether an object is an instance of a class ******************/
-jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz)
+jdouble CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- return builtin_instanceof(obj,clazz);
+ log_text("JNI-Call: CallNonvirtualDoubleMethodA: IMPLEMENT ME!");
+
+ return 0;
}
-/***************** converts a java.lang.reflect.Field to a field ID ***************/
-
-jfieldID FromReflectedField(JNIEnv* env, jobject field)
+
+void CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
- log_text("JNI-Call: FromReflectedField");
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+ va_list ap;
- return 0;
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ _Jv_jni_CallVoidMethod(o, c->vftbl, m, ap);
+ va_end(ap);
}
-/**********************************************************************************
+void CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
- converts a method ID to a java.lang.reflect.Method or
- java.lang.reflect.Constructor object
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
-**********************************************************************************/
+ _Jv_jni_CallVoidMethod(o, c->vftbl, m, args);
+}
-jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
-{
- log_text("JNI-Call: ToReflectedMethod");
- return NULL;
+void CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
+{
+ java_objectheader *o;
+ classinfo *c;
+ methodinfo *m;
+
+ o = (java_objectheader *) obj;
+ c = (classinfo *) clazz;
+ m = (methodinfo *) methodID;
+
+ _Jv_jni_CallVoidMethodA(o, c->vftbl, m, args);
}
-/* GetMethodID *****************************************************************
+/* Accessing Fields of Objects ************************************************/
+
+/* GetFieldID ******************************************************************
- returns the method ID for an instance method
+ Returns the field ID for an instance (nonstatic) field of a
+ class. The field is specified by its name and signature. The
+ Get<type>Field and Set<type>Field families of accessor functions
+ use field IDs to retrieve object fields.
*******************************************************************************/
-jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, const char *sig)
+jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
- jmethodID m;
+ fieldinfo *f;
+ utf *uname;
+ utf *udesc;
- m = class_resolvemethod(clazz,
- utf_new_char((char *) name),
- utf_new_char((char *) sig));
+ STATISTICS(jniinvokation());
- if (!m || (m->flags & ACC_STATIC)) {
- *exceptionptr =
- new_exception_message(string_java_lang_NoSuchMethodError, name);
+ uname = utf_new_char((char *) name);
+ udesc = utf_new_char((char *) sig);
- return 0;
- }
+ f = class_findfield(clazz, uname, udesc);
+
+ if (!f)
+ *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
- return m;
+ return (jfieldID) f;
}
-/******************** JNI-functions for calling instance methods ******************/
+/* Get<type>Field Routines *****************************************************
-jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+ This family of accessor routines returns the value of an instance
+ (nonstatic) field of an object. The field to access is specified by
+ a field ID obtained by calling GetFieldID().
+
+*******************************************************************************/
+
+jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- jobject ret;
- va_list vaargs;
+ java_objectheader *o;
-/* log_text("JNI-Call: CallObjectMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs, methodID);
- ret = callObjectMethod(obj, methodID, vaargs);
- va_end(vaargs);
+ o = GET_FIELD(obj, java_objectheader*, fieldID);
- return ret;
+ return NewLocalRef(env, o);
}
-jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- return callObjectMethod(obj,methodID,args);
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ i = GET_FIELD(obj, s4, fieldID);
+
+ return (jboolean) i;
}
-jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
+jbyte GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- log_text("JNI-Call: CallObjectMethodA");
+ s4 i;
- return NULL;
-}
+ STATISTICS(jniinvokation());
+ i = GET_FIELD(obj, s4, fieldID);
+ return (jbyte) i;
+}
-jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jchar GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- jboolean ret;
- va_list vaargs;
+ s4 i;
-/* log_text("JNI-Call: CallBooleanMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs,methodID);
- ret = (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',vaargs);
- va_end(vaargs);
- return ret;
+ i = GET_FIELD(obj, s4, fieldID);
+ return (jchar) i;
}
-jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+
+jshort GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',args);
+ s4 i;
-}
+ STATISTICS(jniinvokation());
-jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
-{
- log_text("JNI-Call: CallBooleanMethodA");
+ i = GET_FIELD(obj, s4, fieldID);
- return 0;
+ return (jshort) i;
}
-jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
+
+jint GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- jbyte ret;
- va_list vaargs;
+ java_objectheader *o;
+ fieldinfo *f;
+ s4 i;
-/* log_text("JNI-Call: CallVyteMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj,get_virtual(obj,methodID),'B',vaargs);
- va_end(vaargs);
- return ret;
+ o = (java_objectheader *) obj;
+ f = (fieldinfo *) fieldID;
-}
+ i = GET_FIELD(o, s4, f);
-jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
-{
-/* log_text("JNI-Call: CallByteMethodV");*/
- return callIntegerMethod(obj,methodID,'B',args);
+ return i;
}
-jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jlong GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- log_text("JNI-Call: CallByteMethodA");
+ s8 l;
- return 0;
+ STATISTICS(jniinvokation());
+
+ l = GET_FIELD(obj, s8, fieldID);
+
+ return l;
}
-jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jfloat GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- jchar ret;
- va_list vaargs;
+ float f;
-/* log_text("JNI-Call: CallCharMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'C', vaargs);
- va_end(vaargs);
+ f = GET_FIELD(obj, float, fieldID);
- return ret;
+ return f;
}
-jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jdouble GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
-/* log_text("JNI-Call: CallCharMethodV");*/
- return callIntegerMethod(obj,get_virtual(obj,methodID),'C',args);
-}
+ double d;
+ STATISTICS(jniinvokation());
-jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
-{
- log_text("JNI-Call: CallCharMethodA");
+ d = GET_FIELD(obj, double, fieldID);
- return 0;
+ return d;
}
-jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
-{
- jshort ret;
- va_list vaargs;
+/* Set<type>Field Routines *****************************************************
-/* log_text("JNI-Call: CallShortMethod");*/
+ This family of accessor routines sets the value of an instance
+ (nonstatic) field of an object. The field to access is specified by
+ a field ID obtained by calling GetFieldID().
+
+*******************************************************************************/
- va_start(vaargs, methodID);
- ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'S', vaargs);
- va_end(vaargs);
+void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)
+{
+ STATISTICS(jniinvokation());
- return ret;
+ SET_FIELD(obj, java_objectheader*, fieldID, value);
}
-jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value)
{
- return callIntegerMethod(obj, get_virtual(obj, methodID), 'S', args);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s4, fieldID, value);
}
-jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+void SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value)
{
- log_text("JNI-Call: CallShortMethodA");
+ STATISTICS(jniinvokation());
- return 0;
+ SET_FIELD(obj, s4, fieldID, value);
}
-
-jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+void SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value)
{
- jint ret;
- va_list vaargs;
-
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj, get_virtual(obj, methodID), 'I', vaargs);
- va_end(vaargs);
+ STATISTICS(jniinvokation());
- return ret;
+ SET_FIELD(obj, s4, fieldID, value);
}
-jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+void SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value)
{
- return callIntegerMethod(obj, get_virtual(obj, methodID), 'I', args);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s4, fieldID, value);
}
-jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+void SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value)
{
- log_text("JNI-Call: CallIntMethodA");
+ STATISTICS(jniinvokation());
- return 0;
+ SET_FIELD(obj, s4, fieldID, value);
}
-
-jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value)
{
- jlong ret;
- va_list vaargs;
-
- va_start(vaargs,methodID);
- ret = callLongMethod(obj,get_virtual(obj, methodID),vaargs);
- va_end(vaargs);
+ STATISTICS(jniinvokation());
- return ret;
+ SET_FIELD(obj, s8, fieldID, value);
}
-jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+void SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value)
{
- return callLongMethod(obj,get_virtual(obj, methodID),args);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, float, fieldID, value);
}
-jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+void SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value)
{
- log_text("JNI-Call: CallLongMethodA");
+ STATISTICS(jniinvokation());
- return 0;
+ SET_FIELD(obj, double, fieldID, value);
}
+/* Calling Static Methods *****************************************************/
-jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+/* GetStaticMethodID ***********************************************************
+
+ Returns the method ID for a static method of a class. The method is
+ specified by its name and signature.
+
+ GetStaticMethodID() causes an uninitialized class to be
+ initialized.
+
+*******************************************************************************/
+
+jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
- jfloat ret;
- va_list vaargs;
+ classinfo *c;
+ utf *uname;
+ utf *udesc;
+ methodinfo *m;
+
+ STATISTICS(jniinvokation());
+
+ c = (classinfo *) clazz;
+
+ if (!c)
+ return NULL;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return NULL;
+
+ /* try to get the static method of the class */
-/* log_text("JNI-Call: CallFloatMethod");*/
+ uname = utf_new_char((char *) name);
+ udesc = utf_new_char((char *) sig);
- va_start(vaargs,methodID);
- ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'F');
- va_end(vaargs);
+ m = class_resolvemethod(c, uname, udesc);
+
+ if ((m == NULL) || !(m->flags & ACC_STATIC)) {
+ exceptions_throw_nosuchmethoderror(c, uname, udesc);
+
+ return NULL;
+ }
- return ret;
+ return (jmethodID) m;
}
-jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- log_text("JNI-Call: CallFloatMethodV");
- return callFloatMethod(obj, get_virtual(obj, methodID), args, 'F');
+ methodinfo *m;
+ java_objectheader *o;
+ va_list ap;
+
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ o = _Jv_jni_CallObjectMethod(NULL, NULL, m, ap);
+ va_end(ap);
+
+ return NewLocalRef(env, o);
}
-jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- log_text("JNI-Call: CallFloatMethodA");
+ methodinfo *m;
+ java_objectheader *o;
- return 0;
+ m = (methodinfo *) methodID;
+
+ o = _Jv_jni_CallObjectMethod(NULL, NULL, m, args);
+
+ return NewLocalRef(env, o);
}
+jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+{
+ methodinfo *m;
+ java_objectheader *o;
+
+ m = (methodinfo *) methodID;
+
+ o = _Jv_jni_CallObjectMethodA(NULL, NULL, m, args);
-jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+ return NewLocalRef(env, o);
+}
+
+
+jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jdouble ret;
- va_list vaargs;
+ methodinfo *m;
+ va_list ap;
+ jboolean b;
-/* log_text("JNI-Call: CallDoubleMethod");*/
+ m = (methodinfo *) methodID;
- va_start(vaargs,methodID);
- ret = callFloatMethod(obj, get_virtual(obj, methodID), vaargs, 'D');
- va_end(vaargs);
+ va_start(ap, methodID);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
+ va_end(ap);
- return ret;
+ return b;
}
-jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- log_text("JNI-Call: CallDoubleMethodV");
- return callFloatMethod(obj, get_virtual(obj, methodID), args, 'D');
+ methodinfo *m;
+ jboolean b;
+
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
+
+ return b;
}
-jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallDoubleMethodA");
+ log_text("JNI-Call: CallStaticBooleanMethodA: IMPLEMENT ME!");
+
return 0;
}
-
-void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- va_list vaargs;
+ methodinfo *m;
+ va_list ap;
+ jbyte b;
- va_start(vaargs,methodID);
- (void) callIntegerMethod(obj, get_virtual(obj, methodID), 'V', vaargs);
- va_end(vaargs);
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
+ va_end(ap);
+
+ return b;
}
-void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- log_text("JNI-Call: CallVoidMethodV");
- (void)callIntegerMethod(obj,get_virtual(obj,methodID),'V',args);
+ methodinfo *m;
+ jbyte b;
+
+ m = (methodinfo *) methodID;
+
+ b = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
+
+ return b;
}
-void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
+jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallVoidMethodA");
-}
+ log_text("JNI-Call: CallStaticByteMethodA: IMPLEMENT ME!");
+ return 0;
+}
-jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- log_text("JNI-Call: CallNonvirtualObjectMethod");
+ methodinfo *m;
+ va_list ap;
+ jchar c;
- return NULL;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ c = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
+ va_end(ap);
+
+ return c;
}
-jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- log_text("JNI-Call: CallNonvirtualObjectMethodV");
+ methodinfo *m;
+ jchar c;
- return NULL;
+ m = (methodinfo *) methodID;
+
+ c = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
+
+ return c;
}
-jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
+jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallNonvirtualObjectMethodA");
+ log_text("JNI-Call: CallStaticCharMethodA: IMPLEMENT ME!");
- return NULL;
+ return 0;
}
-
-jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jboolean ret;
- va_list vaargs;
+ methodinfo *m;
+ va_list ap;
+ jshort s;
-/* log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
+ m = (methodinfo *) methodID;
- va_start(vaargs,methodID);
- ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',vaargs);
- va_end(vaargs);
- return ret;
+ va_start(ap, methodID);
+ s = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
+ va_end(ap);
+ return s;
}
-jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
-/* log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
- return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',args);
+ methodinfo *m;
+ jshort s;
+
+ m = (methodinfo *) methodID;
+
+ s = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
+
+ return s;
}
-jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
+jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallNonvirtualBooleanMethodA");
+ log_text("JNI-Call: CallStaticShortMethodA: IMPLEMENT ME!");
return 0;
}
-
-jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jbyte ret;
- va_list vaargs;
+ methodinfo *m;
+ va_list ap;
+ jint i;
-/* log_text("JNI-Call: CallNonvirutalByteMethod");*/
+ m = (methodinfo *) methodID;
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',vaargs);
- va_end(vaargs);
- return ret;
+ va_start(ap, methodID);
+ i = _Jv_jni_CallIntMethod(NULL, NULL, m, ap);
+ va_end(ap);
+
+ return i;
}
-jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
- return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',args);
+ methodinfo *m;
+ jint i;
+
+ m = (methodinfo *) methodID;
+
+ i = _Jv_jni_CallIntMethod(NULL, NULL, m, args);
+ return i;
}
-jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallNonvirtualByteMethodA");
+ log_text("JNI-Call: CallStaticIntMethodA: IMPLEMENT ME!");
return 0;
}
-
-jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jchar ret;
- va_list vaargs;
+ methodinfo *m;
+ va_list ap;
+ jlong l;
+
+ m = (methodinfo *) methodID;
-/* log_text("JNI-Call: CallNonVirtualCharMethod");*/
+ va_start(ap, methodID);
+ l = _Jv_jni_CallLongMethod(NULL, NULL, m, ap);
+ va_end(ap);
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',vaargs);
- va_end(vaargs);
- return ret;
+ return l;
}
-jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
+ va_list args)
{
- /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
- return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',args);
+ methodinfo *m;
+ jlong l;
+
+ m = (methodinfo *) methodID;
+
+ l = _Jv_jni_CallLongMethod(NULL, NULL, m, args);
+
+ return l;
}
-jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallNonvirtualCharMethodA");
+ log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!");
return 0;
}
-jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jshort ret;
- va_list vaargs;
+ methodinfo *m;
+ va_list ap;
+ jfloat f;
+
+ m = (methodinfo *) methodID;
- /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
+ va_start(ap, methodID);
+ f = _Jv_jni_CallFloatMethod(NULL, NULL, m, ap);
+ va_end(ap);
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',vaargs);
- va_end(vaargs);
- return ret;
+ return f;
}
-jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
- return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',args);
+ methodinfo *m;
+ jfloat f;
+
+ m = (methodinfo *) methodID;
+
+ f = _Jv_jni_CallFloatMethod(NULL, NULL, m, args);
+
+ return f;
}
-jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallNonvirtualShortMethodA");
+ log_text("JNI-Call: CallStaticFloatMethodA: IMPLEMENT ME!");
return 0;
}
-
-jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
+ methodinfo *m;
+ va_list ap;
+ jdouble d;
- jint ret;
- va_list vaargs;
+ m = (methodinfo *) methodID;
- /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
+ va_start(ap, methodID);
+ d = _Jv_jni_CallDoubleMethod(NULL, NULL, m, ap);
+ va_end(ap);
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',vaargs);
- va_end(vaargs);
- return ret;
+ return d;
}
-jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
- return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',args);
-}
+ methodinfo *m;
+ jdouble d;
+ m = (methodinfo *) methodID;
-jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
-{
- log_text("JNI-Call: CallNonvirtualIntMethodA");
+ d = _Jv_jni_CallDoubleMethod(NULL, NULL, m, args);
- return 0;
+ return d;
}
-
-jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallNonvirtualLongMethod");
+ log_text("JNI-Call: CallStaticDoubleMethodA: IMPLEMENT ME!");
return 0;
}
-jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+void CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- log_text("JNI-Call: CallNonvirtualLongMethodV");
+ methodinfo *m;
+ va_list ap;
- return 0;
+ m = (methodinfo *) methodID;
+
+ va_start(ap, methodID);
+ _Jv_jni_CallVoidMethod(NULL, NULL, m, ap);
+ va_end(ap);
}
-jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+void CallStaticVoidMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- log_text("JNI-Call: CallNonvirtualLongMethodA");
+ methodinfo *m;
- return 0;
-}
+ m = (methodinfo *) methodID;
+ _Jv_jni_CallVoidMethod(NULL, NULL, m, args);
+}
-jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+void CallStaticVoidMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args)
{
- jfloat ret;
- va_list vaargs;
+ methodinfo *m;
- /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
+ m = (methodinfo *) methodID;
+ _Jv_jni_CallVoidMethodA(NULL, NULL, m, args);
+}
- va_start(vaargs,methodID);
- ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'F');
- va_end(vaargs);
- return ret;
-}
+/* Accessing Static Fields ****************************************************/
+/* GetStaticFieldID ************************************************************
-jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
-{
- log_text("JNI-Call: CallNonvirtualFloatMethodV");
- return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'F');
-}
+ Returns the field ID for a static field of a class. The field is
+ specified by its name and signature. The GetStatic<type>Field and
+ SetStatic<type>Field families of accessor functions use field IDs
+ to retrieve static fields.
+*******************************************************************************/
-jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
{
- log_text("JNI-Call: CallNonvirtualFloatMethodA");
+ fieldinfo *f;
- return 0;
+ STATISTICS(jniinvokation());
+
+ f = class_findfield(clazz,
+ utf_new_char((char *) name),
+ utf_new_char((char *) sig));
+
+ if (f == NULL)
+ *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
+
+ return (jfieldID) f;
}
+/* GetStatic<type>Field ********************************************************
+
+ This family of accessor routines returns the value of a static
+ field of an object.
-jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+*******************************************************************************/
+
+jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- jdouble ret;
- va_list vaargs;
- log_text("JNI-Call: CallNonvirtualDoubleMethod");
+ classinfo *c;
+ fieldinfo *f;
- va_start(vaargs,methodID);
- ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'D');
- va_end(vaargs);
- return ret;
+ STATISTICS(jniinvokation());
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return NULL;
-jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
-{
-/* log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
- return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'D');
+ return NewLocalRef(env, f->value.a);
}
-jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- log_text("JNI-Call: CallNonvirtualDoubleMethodA");
+ classinfo *c;
+ fieldinfo *f;
- return 0;
-}
+ STATISTICS(jniinvokation());
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return false;
-void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+ return f->value.i;
+}
+
+
+jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- va_list vaargs;
+ classinfo *c;
+ fieldinfo *f;
-/* log_text("JNI-Call: CallNonvirtualVoidMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs,methodID);
- (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',vaargs);
- va_end(vaargs);
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return 0;
+
+ return f->value.i;
}
-void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
-/* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
+ classinfo *c;
+ fieldinfo *f;
- (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',args);
+ STATISTICS(jniinvokation());
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return 0;
-void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
-{
- log_text("JNI-Call: CallNonvirtualVoidMethodA");
+ return f->value.i;
}
-/************************* JNI-functions for accessing fields ************************/
-jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
+jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- jfieldID f;
+ classinfo *c;
+ fieldinfo *f;
-/* log_text("========================= searching for:");
- log_text(name);
- log_text(sig);*/
- f = jclass_findfield(clazz,
- utf_new_char ((char*) name),
- utf_new_char ((char*) sig)
- );
-
- if (!f) {
- /*utf_display(clazz->name);
- log_text(name);
- log_text(sig);*/
- *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
- }
- return f;
+ STATISTICS(jniinvokation());
+
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return 0;
+
+ return f->value.i;
}
-/*************************** retrieve fieldid, abort on error ************************/
-jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig)
+jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- jfieldID id = GetFieldID(env, clazz, name, sig);
+ classinfo *c;
+ fieldinfo *f;
- if (!id) {
- log_text("class:");
- utf_display(clazz->name);
- log_text("\nfield:");
- log_text(name);
- log_text("sig:");
- log_text(sig);
+ STATISTICS(jniinvokation());
- panic("setfield_critical failed");
- }
- return id;
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
-jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
-{
- /*
- jobject dbg,dretval,*dpretval;
- long int dli1, dli2, dli3;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return 0;
- printf("GetObjectField(1): thread: %s obj: %p name: %s desc: %s \n",GetStringUTFChars(env,
- ((threadobject *) THREADOBJECT)->o
- .thread->name,NULL)
- ,obj,((fieldinfo*)fieldID)->name->text,(fieldID->descriptor)->text);
+ return f->value.i;
+}
- dbg = getField(obj,jobject,fieldID);
- dli1 = (long int) obj;
- dli2 = (long int) fieldID->offset;
- dli3 = dli1+dli2;
- dpretval = (jobject*) dli3;
- dretval = *dpretval;
- jclass tmp;
- jmethodID mid;
- jstring jstr;
- tmp = FindClass(env, "java/lang/Object");
- mid = GetMethodID(env,tmp,"toString","()Ljava/lang/String;");
- jstr = CallObjectMethod(env,dbg,mid);*/
+jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+{
+ classinfo *c;
+ fieldinfo *f;
-/* printf("GetObjectField(2): retval %p (obj: %#lx + offset: %#lx = %#lx (jobject*) %p (jobject) %p\n"
- ,dbg, dli1, dli2, dli3,dpretval, dretval);*/
+ STATISTICS(jniinvokation());
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
-/* return dbg;*/
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return 0;
- return getField(obj,jobject,fieldID);
+ return f->value.l;
}
-jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
+
+jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- return getField(obj,jboolean,fieldID);
-}
+ classinfo *c;
+ fieldinfo *f;
+ STATISTICS(jniinvokation());
-jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
-{
- return getField(obj,jbyte,fieldID);
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return 0.0;
-jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
-{
- return getField(obj,jchar,fieldID);
+ return f->value.f;
}
-jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- return getField(obj,jshort,fieldID);
-}
+ classinfo *c;
+ fieldinfo *f;
+ STATISTICS(jniinvokation());
-jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
-{
- return getField(obj,jint,fieldID);
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return 0.0;
-jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
-{
- return getField(obj,jlong,fieldID);
+ return f->value.d;
}
-jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
-{
- return getField(obj,jfloat,fieldID);
-}
+/* SetStatic<type>Field *******************************************************
+ This family of accessor routines sets the value of a static field
+ of an object.
-jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
-{
- return getField(obj,jdouble,fieldID);
-}
+*******************************************************************************/
-void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
+void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
{
- setField(obj,jobject,fieldID,val);
-}
+ classinfo *c;
+ fieldinfo *f;
+ STATISTICS(jniinvokation());
-void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
-{
- setField(obj,jboolean,fieldID,val);
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
-void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
-{
- setField(obj,jbyte,fieldID,val);
+ f->value.a = value;
}
-void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
+void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
{
- setField(obj,jchar,fieldID,val);
-}
+ classinfo *c;
+ fieldinfo *f;
+ STATISTICS(jniinvokation());
-void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
-{
- setField(obj,jshort,fieldID,val);
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
-void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
-{
- setField(obj,jint,fieldID,val);
+ f->value.i = value;
}
-void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
+void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
{
- setField(obj,jlong,fieldID,val);
-}
+ classinfo *c;
+ fieldinfo *f;
+ STATISTICS(jniinvokation());
-void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
-{
- setField(obj,jfloat,fieldID,val);
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
-void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
-{
- setField(obj,jdouble,fieldID,val);
+ f->value.i = value;
}
-/**************** JNI-functions for calling static methods **********************/
-
-jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
+void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
{
- jmethodID m;
+ classinfo *c;
+ fieldinfo *f;
- m = class_resolvemethod(clazz,
- utf_new_char((char *) name),
- utf_new_char((char *) sig));
+ STATISTICS(jniinvokation());
- if (!m || !(m->flags & ACC_STATIC)) {
- *exceptionptr =
- new_exception_message(string_java_lang_NoSuchMethodError, name);
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
- return NULL;
- }
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
- return m;
+ f->value.i = value;
}
-jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
{
- jobject ret;
- va_list vaargs;
+ classinfo *c;
+ fieldinfo *f;
- /* log_text("JNI-Call: CallStaticObjectMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs, methodID);
- ret = callObjectMethod(0, methodID, vaargs);
- va_end(vaargs);
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
- return ret;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
+
+ f->value.i = value;
}
-jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
{
- /* log_text("JNI-Call: CallStaticObjectMethodV"); */
-
- return callObjectMethod(0,methodID,args);
-}
+ classinfo *c;
+ fieldinfo *f;
+ STATISTICS(jniinvokation());
-jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
-{
- log_text("JNI-Call: CallStaticObjectMethodA");
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
- return NULL;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
+
+ f->value.i = value;
}
-jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
{
- jboolean ret;
- va_list vaargs;
+ classinfo *c;
+ fieldinfo *f;
- va_start(vaargs, methodID);
- ret = (jboolean) callIntegerMethod(0, methodID, 'Z', vaargs);
- va_end(vaargs);
+ STATISTICS(jniinvokation());
- return ret;
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
-jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
-{
- return (jboolean) callIntegerMethod(0, methodID, 'Z', args);
+ f->value.l = value;
}
-jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
{
- log_text("JNI-Call: CallStaticBooleanMethodA");
+ classinfo *c;
+ fieldinfo *f;
- return 0;
+ STATISTICS(jniinvokation());
+
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
+
+ f->value.f = value;
}
-jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
{
- jbyte ret;
- va_list vaargs;
-
- /* log_text("JNI-Call: CallStaticByteMethod");*/
+ classinfo *c;
+ fieldinfo *f;
- va_start(vaargs, methodID);
- ret = (jbyte) callIntegerMethod(0, methodID, 'B', vaargs);
- va_end(vaargs);
+ STATISTICS(jniinvokation());
- return ret;
-}
+ c = (classinfo *) clazz;
+ f = (fieldinfo *) fieldID;
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return;
-jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
-{
- return (jbyte) callIntegerMethod(0, methodID, 'B', args);
+ f->value.d = value;
}
-jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
-{
- log_text("JNI-Call: CallStaticByteMethodA");
+/* String Operations **********************************************************/
- return 0;
-}
+/* NewString *******************************************************************
+ Create new java.lang.String object from an array of Unicode
+ characters.
-jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+*******************************************************************************/
+
+jstring NewString(JNIEnv *env, const jchar *buf, jsize len)
{
- jchar ret;
- va_list vaargs;
+ java_lang_String *s;
+ java_chararray *a;
+ u4 i;
+
+ STATISTICS(jniinvokation());
+
+ s = (java_lang_String *) builtin_new(class_java_lang_String);
+ a = builtin_newarray_char(len);
+
+ /* javastring or characterarray could not be created */
+ if (!a || !s)
+ return NULL;
- /* log_text("JNI-Call: CallStaticByteMethod");*/
+ /* copy text */
+ for (i = 0; i < len; i++)
+ a->data[i] = buf[i];
- va_start(vaargs, methodID);
- ret = (jchar) callIntegerMethod(0, methodID, 'C', vaargs);
- va_end(vaargs);
+ s->value = a;
+ s->offset = 0;
+ s->count = len;
- return ret;
+ return (jstring) NewLocalRef(env, (jobject) s);
}
-jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+static jchar emptyStringJ[]={0,0};
+
+/* GetStringLength *************************************************************
+
+ Returns the length (the count of Unicode characters) of a Java
+ string.
+
+*******************************************************************************/
+
+jsize GetStringLength(JNIEnv *env, jstring str)
{
- return (jchar) callIntegerMethod(0, methodID, 'C', args);
+ return ((java_lang_String *) str)->count;
}
-jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+/******************** convertes javastring to u2-array ****************************/
+
+u2 *javastring_tou2(jstring so)
{
- log_text("JNI-Call: CallStaticCharMethodA");
+ java_lang_String *s;
+ java_chararray *a;
+ u2 *stringbuffer;
+ u4 i;
- return 0;
-}
+ STATISTICS(jniinvokation());
+
+ s = (java_lang_String *) so;
+ if (!s)
+ return NULL;
+ a = s->value;
-jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
-{
- jshort ret;
- va_list vaargs;
+ if (!a)
+ return NULL;
- /* log_text("JNI-Call: CallStaticByteMethod");*/
+ /* allocate memory */
- va_start(vaargs, methodID);
- ret = (jshort) callIntegerMethod(0, methodID, 'S', vaargs);
- va_end(vaargs);
+ stringbuffer = MNEW(u2, s->count + 1);
- return ret;
-}
+ /* copy text */
+ for (i = 0; i < s->count; i++)
+ stringbuffer[i] = a->data[s->offset + i];
+
+ /* terminate string */
-jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
-{
- /*log_text("JNI-Call: CallStaticShortMethodV");*/
- return (jshort) callIntegerMethod(0, methodID, 'S', args);
+ stringbuffer[i] = '\0';
+
+ return stringbuffer;
}
-jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
-{
- log_text("JNI-Call: CallStaticShortMethodA");
+/* GetStringChars **************************************************************
- return 0;
-}
+ Returns a pointer to the array of Unicode characters of the
+ string. This pointer is valid until ReleaseStringchars() is called.
+
+*******************************************************************************/
+const jchar *GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
+{
+ jchar *jc;
+ STATISTICS(jniinvokation());
-jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
-{
- jint ret;
- va_list vaargs;
+ jc = javastring_tou2(str);
+
+ if (jc) {
+ if (isCopy)
+ *isCopy = JNI_TRUE;
- /* log_text("JNI-Call: CallStaticIntMethod");*/
+ return jc;
+ }
- va_start(vaargs, methodID);
- ret = callIntegerMethod(0, methodID, 'I', vaargs);
- va_end(vaargs);
+ if (isCopy)
+ *isCopy = JNI_TRUE;
- return ret;
+ return emptyStringJ;
}
-jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
-{
- log_text("JNI-Call: CallStaticIntMethodV");
+/* ReleaseStringChars **********************************************************
- return callIntegerMethod(0, methodID, 'I', args);
-}
+ Informs the VM that the native code no longer needs access to
+ chars. The chars argument is a pointer obtained from string using
+ GetStringChars().
+*******************************************************************************/
-jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+void ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
{
- log_text("JNI-Call: CallStaticIntMethodA");
+ STATISTICS(jniinvokation());
- return 0;
+ if (chars == emptyStringJ)
+ return;
+
+ MFREE(((jchar *) chars), jchar, ((java_lang_String *) str)->count + 1);
}
+/* NewStringUTF ****************************************************************
-jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+ Constructs a new java.lang.String object from an array of UTF-8 characters.
+
+*******************************************************************************/
+
+jstring NewStringUTF(JNIEnv *env, const char *bytes)
{
- jlong ret;
- va_list vaargs;
+ java_lang_String *s;
- /* log_text("JNI-Call: CallStaticLongMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs, methodID);
- ret = callLongMethod(0, methodID, vaargs);
- va_end(vaargs);
+ s = javastring_new(utf_new_char(bytes));
- return ret;
+ return (jstring) NewLocalRef(env, (jobject) s);
}
-jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
-{
- log_text("JNI-Call: CallStaticLongMethodV");
-
- return callLongMethod(0,methodID,args);
-}
+/****************** returns the utf8 length in bytes of a string *******************/
+jsize GetStringUTFLength (JNIEnv *env, jstring string)
+{
+ java_lang_String *s = (java_lang_String*) string;
-jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
-{
- log_text("JNI-Call: CallStaticLongMethodA");
+ STATISTICS(jniinvokation());
- return 0;
+ return (jsize) u2_utflength(s->value->data, s->count);
}
+/* GetStringUTFChars ***********************************************************
-jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+ Returns a pointer to an array of UTF-8 characters of the
+ string. This array is valid until it is released by
+ ReleaseStringUTFChars().
+
+*******************************************************************************/
+
+const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
{
- jfloat ret;
- va_list vaargs;
+ utf *u;
+
+ STATISTICS(jniinvokation());
- /* log_text("JNI-Call: CallStaticLongMethod");*/
+ if (!string)
+ return "";
- va_start(vaargs, methodID);
- ret = callFloatMethod(0, methodID, vaargs, 'F');
- va_end(vaargs);
+ if (isCopy)
+ *isCopy = JNI_TRUE;
+
+ u = javastring_toutf((java_lang_String *) string, false);
+
+ if (u)
+ return u->text;
- return ret;
+ return "";
}
-jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
-{
+/* ReleaseStringUTFChars *******************************************************
+
+ Informs the VM that the native code no longer needs access to
+ utf. The utf argument is a pointer derived from string using
+ GetStringUTFChars().
+
+*******************************************************************************/
- return callFloatMethod(0, methodID, args, 'F');
+void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
+{
+ STATISTICS(jniinvokation());
+ /* XXX we don't release utf chars right now, perhaps that should be done
+ later. Since there is always one reference the garbage collector will
+ never get them */
}
-jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
-{
- log_text("JNI-Call: CallStaticFloatMethodA");
+/* Array Operations ***********************************************************/
- return 0;
-}
+/* GetArrayLength **************************************************************
+ Returns the number of elements in the array.
+*******************************************************************************/
-jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jsize GetArrayLength(JNIEnv *env, jarray array)
{
- jdouble ret;
- va_list vaargs;
+ java_arrayheader *a;
- /* log_text("JNI-Call: CallStaticDoubleMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs,methodID);
- ret = callFloatMethod(0, methodID, vaargs, 'D');
- va_end(vaargs);
+ a = (java_arrayheader *) array;
- return ret;
+ return a->size;
}
-jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
-{
- log_text("JNI-Call: CallStaticDoubleMethodV");
+/* NewObjectArray **************************************************************
- return callFloatMethod(0, methodID, args, 'D');
-}
+ Constructs a new array holding objects in class elementClass. All
+ elements are initially set to initialElement.
+*******************************************************************************/
-jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)
{
- log_text("JNI-Call: CallStaticDoubleMethodA");
+ java_objectarray *oa;
+ s4 i;
- return 0;
-}
+ STATISTICS(jniinvokation());
+
+ if (length < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
+ oa = builtin_anewarray(length, elementClass);
-void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
-{
- va_list vaargs;
+ if (!oa)
+ return NULL;
- va_start(vaargs, methodID);
- (void) callIntegerMethod(0, methodID, 'V', vaargs);
- va_end(vaargs);
-}
+ /* set all elements to initialElement */
+ for (i = 0; i < length; i++)
+ oa->data[i] = initialElement;
-void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
-{
- log_text("JNI-Call: CallStaticVoidMethodV");
- (void)callIntegerMethod(0, methodID, 'V', args);
+ return (jobjectArray) NewLocalRef(env, (jobject) oa);
}
-void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
+jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
{
- log_text("JNI-Call: CallStaticVoidMethodA");
-}
+ java_objectarray *oa;
+ jobject o;
+ STATISTICS(jniinvokation());
-/****************** JNI-functions for accessing static fields ********************/
+ oa = (java_objectarray *) array;
-jfieldID GetStaticFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
-{
- jfieldID f;
+ if (index >= oa->header.size) {
+ exceptions_throw_arrayindexoutofboundsexception();
+ return NULL;
+ }
- f = jclass_findfield(clazz,
- utf_new_char ((char*) name),
- utf_new_char ((char*) sig)
- );
-
- if (!f) *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
+ o = oa->data[index];
- return f;
+ return NewLocalRef(env, o);
}
-jobject GetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID)
+void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
{
- class_init(clazz);
- return fieldID->value.a;
-}
-
+ java_objectarray *oa;
+ java_objectheader *o;
-jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
-{
- class_init(clazz);
- return fieldID->value.i;
-}
+ STATISTICS(jniinvokation());
+ oa = (java_objectarray *) array;
+ o = (java_objectheader *) val;
-jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
-{
- class_init(clazz);
- return fieldID->value.i;
-}
+ if (index >= oa->header.size) {
+ exceptions_throw_arrayindexoutofboundsexception();
+ return;
+ }
+ /* check if the class of value is a subclass of the element class
+ of the array */
-jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
-{
- class_init(clazz);
- return fieldID->value.i;
-}
+ if (!builtin_canstore(oa, o)) {
+ *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
+ return;
+ }
-jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
-{
- class_init(clazz);
- return fieldID->value.i;
+ oa->data[index] = val;
}
-jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
+jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
{
- class_init(clazz);
- return fieldID->value.i;
-}
+ java_booleanarray *ba;
+ STATISTICS(jniinvokation());
-jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
-{
- class_init(clazz);
- return fieldID->value.l;
-}
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
+ ba = builtin_newarray_boolean(len);
-jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
-{
- class_init(clazz);
- return fieldID->value.f;
+ return (jbooleanArray) NewLocalRef(env, (jobject) ba);
}
-jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
+jbyteArray NewByteArray(JNIEnv *env, jsize len)
{
- class_init(clazz);
- return fieldID->value.d;
-}
-
+ java_bytearray *ba;
+ STATISTICS(jniinvokation());
-void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
-{
- class_init(clazz);
- fieldID->value.a = value;
-}
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
+ ba = builtin_newarray_byte(len);
-void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
-{
- class_init(clazz);
- fieldID->value.i = value;
+ return (jbyteArray) NewLocalRef(env, (jobject) ba);
}
-void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
+jcharArray NewCharArray(JNIEnv *env, jsize len)
{
- class_init(clazz);
- fieldID->value.i = value;
-}
+ java_chararray *ca;
+ STATISTICS(jniinvokation());
-void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
-{
- class_init(clazz);
- fieldID->value.i = value;
-}
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
+ ca = builtin_newarray_char(len);
-void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
-{
- class_init(clazz);
- fieldID->value.i = value;
+ return (jcharArray) NewLocalRef(env, (jobject) ca);
}
-void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
+jshortArray NewShortArray(JNIEnv *env, jsize len)
{
- class_init(clazz);
- fieldID->value.i = value;
-}
+ java_shortarray *sa;
+ STATISTICS(jniinvokation());
-void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
-{
- class_init(clazz);
- fieldID->value.l = value;
-}
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
+ sa = builtin_newarray_short(len);
-void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
-{
- class_init(clazz);
- fieldID->value.f = value;
+ return (jshortArray) NewLocalRef(env, (jobject) sa);
}
-void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
+jintArray NewIntArray(JNIEnv *env, jsize len)
{
- class_init(clazz);
- fieldID->value.d = value;
-}
+ java_intarray *ia;
+ STATISTICS(jniinvokation());
-/***** create new java.lang.String object from an array of Unicode characters ****/
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
-jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
-{
- u4 i;
- java_lang_String *s;
- java_chararray *a;
-
- s = (java_lang_String*) builtin_new (class_java_lang_String);
- a = builtin_newarray_char (len);
+ ia = builtin_newarray_int(len);
- /* javastring or characterarray could not be created */
- if ( (!a) || (!s) ) return NULL;
+ return (jintArray) NewLocalRef(env, (jobject) ia);
+}
- /* copy text */
- for (i=0; i<len; i++) a->data[i] = buf[i];
- s -> value = a;
- s -> offset = 0;
- s -> count = len;
- return (jstring) s;
-}
+jlongArray NewLongArray(JNIEnv *env, jsize len)
+{
+ java_longarray *la;
+ STATISTICS(jniinvokation());
-static char emptyString[]="";
-static jchar emptyStringJ[]={0,0};
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
-/******************* returns the length of a Java string ***************************/
+ la = builtin_newarray_long(len);
-jsize GetStringLength (JNIEnv *env, jstring str)
-{
- return ((java_lang_String*) str)->count;
+ return (jlongArray) NewLocalRef(env, (jobject) la);
}
-/******************** convertes javastring to u2-array ****************************/
-
-u2 *javastring_tou2 (jstring so)
+jfloatArray NewFloatArray(JNIEnv *env, jsize len)
{
- java_lang_String *s = (java_lang_String*) so;
- java_chararray *a;
- u4 i;
- u2 *stringbuffer;
-
- if (!s) return NULL;
+ java_floatarray *fa;
- a = s->value;
- if (!a) return NULL;
+ STATISTICS(jniinvokation());
- /* allocate memory */
- stringbuffer = MNEW( u2 , s->count + 1 );
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
+ }
- /* copy text */
- for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
-
- /* terminate string */
- stringbuffer[i] = '\0';
+ fa = builtin_newarray_float(len);
- return stringbuffer;
+ return (jfloatArray) NewLocalRef(env, (jobject) fa);
}
-/********* returns a pointer to an array of Unicode characters of the string *******/
-const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
-{
- jchar *jc=javastring_tou2(str);
+jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
+{
+ java_doublearray *da;
- if (jc) {
- if (isCopy) *isCopy=JNI_TRUE;
- return jc;
+ STATISTICS(jniinvokation());
+
+ if (len < 0) {
+ exceptions_throw_negativearraysizeexception();
+ return NULL;
}
- if (isCopy) *isCopy=JNI_TRUE;
- return emptyStringJ;
-}
-/**************** native code no longer needs access to chars **********************/
+ da = builtin_newarray_double(len);
-void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
-{
- if (chars==emptyStringJ) return;
- MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count+1);
+ return (jdoubleArray) NewLocalRef(env, (jobject) da);
}
-/* NewStringUTF ****************************************************************
+/* Get<PrimitiveType>ArrayElements *********************************************
- Constructs a new java.lang.String object from an array of UTF-8 characters.
+ A family of functions that returns the body of the primitive array.
*******************************************************************************/
-jstring NewStringUTF(JNIEnv *env, const char *bytes)
+jboolean *GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
+ jboolean *isCopy)
{
- return (jstring) javastring_new(utf_new_char(bytes));
-}
+ java_booleanarray *ba;
+ STATISTICS(jniinvokation());
-/****************** returns the utf8 length in bytes of a string *******************/
+ ba = (java_booleanarray *) array;
-jsize GetStringUTFLength (JNIEnv *env, jstring string)
-{
- java_lang_String *s = (java_lang_String*) string;
+ if (isCopy)
+ *isCopy = JNI_FALSE;
- return (jsize) u2_utflength(s->value->data, s->count);
+ return ba->data;
}
-/************ converts a Javastring to an array of UTF-8 characters ****************/
-
-const char* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
+jbyte *GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy)
{
- utf *u;
+ java_bytearray *ba;
- u = javastring_toutf((java_lang_String *) string, false);
+ STATISTICS(jniinvokation());
- if (isCopy)
+ ba = (java_bytearray *) array;
+
+ if (isCopy)
*isCopy = JNI_FALSE;
-
- if (u)
- return u->text;
- return emptyString;
-
+ return ba->data;
}
-/***************** native code no longer needs access to utf ***********************/
-
-void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
+jchar *GetCharArrayElements(JNIEnv *env, jcharArray array, jboolean *isCopy)
{
- /*we don't release utf chars right now, perhaps that should be done later. Since there is always one reference
- the garbage collector will never get them*/
- /*
- log_text("JNI-Call: ReleaseStringUTFChars");
- utf_display(utf_new_char(chars));
- */
-}
+ java_chararray *ca;
-/************************** array operations ***************************************/
+ STATISTICS(jniinvokation());
-jsize GetArrayLength(JNIEnv *env, jarray array)
-{
- return array->size;
+ ca = (java_chararray *) array;
+
+ if (isCopy)
+ *isCopy = JNI_FALSE;
+
+ return ca->data;
}
-jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
+jshort *GetShortArrayElements(JNIEnv *env, jshortArray array, jboolean *isCopy)
{
- java_objectarray *j;
+ java_shortarray *sa;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
- j = builtin_anewarray(len, clazz);
+ sa = (java_shortarray *) array;
- return j;
+ if (isCopy)
+ *isCopy = JNI_FALSE;
+
+ return sa->data;
}
-jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
+jint *GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy)
{
- jobject j = NULL;
+ java_intarray *ia;
- if (index < array->header.size)
- j = array->data[index];
- else
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
- return j;
+ STATISTICS(jniinvokation());
+
+ ia = (java_intarray *) array;
+
+ if (isCopy)
+ *isCopy = JNI_FALSE;
+
+ return ia->data;
}
-void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
+jlong *GetLongArrayElements(JNIEnv *env, jlongArray array, jboolean *isCopy)
{
- if (index >= array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_longarray *la;
- else {
- /* check if the class of value is a subclass of the element class of the array */
- if (!builtin_canstore((java_objectarray *) array, (java_objectheader *) val))
- *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
+ STATISTICS(jniinvokation());
- else
- array->data[index] = val;
- }
-}
+ la = (java_longarray *) array;
+
+ if (isCopy)
+ *isCopy = JNI_FALSE;
+
+ /* We cast this one to prevent a compiler warning on 64-bit
+ systems since GNU Classpath typedef jlong to long long. */
+ return (jlong *) la->data;
+}
-jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
+jfloat *GetFloatArrayElements(JNIEnv *env, jfloatArray array, jboolean *isCopy)
{
- java_booleanarray *j;
+ java_floatarray *fa;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
+
+ fa = (java_floatarray *) array;
- j = builtin_newarray_boolean(len);
+ if (isCopy)
+ *isCopy = JNI_FALSE;
- return j;
+ return fa->data;
}
-jbyteArray NewByteArray(JNIEnv *env, jsize len)
+jdouble *GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
+ jboolean *isCopy)
{
- java_bytearray *j;
+ java_doublearray *da;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
+
+ da = (java_doublearray *) array;
- j = builtin_newarray_byte(len);
+ if (isCopy)
+ *isCopy = JNI_FALSE;
- return j;
+ return da->data;
}
-jcharArray NewCharArray(JNIEnv *env, jsize len)
+/* Release<PrimitiveType>ArrayElements *****************************************
+
+ A family of functions that informs the VM that the native code no
+ longer needs access to elems. The elems argument is a pointer
+ derived from array using the corresponding
+ Get<PrimitiveType>ArrayElements() function. If necessary, this
+ function copies back all changes made to elems to the original
+ array.
+
+*******************************************************************************/
+
+void ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array,
+ jboolean *elems, jint mode)
{
- java_chararray *j;
+ java_booleanarray *ba;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
- j = builtin_newarray_char(len);
+ ba = (java_booleanarray *) array;
- return j;
+ if (elems != ba->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(ba->data, elems, u1, ba->header.size);
+ break;
+ case 0:
+ MCOPY(ba->data, elems, u1, ba->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jshortArray NewShortArray(JNIEnv *env, jsize len)
+void ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, jbyte *elems,
+ jint mode)
{
- java_shortarray *j;
+ java_bytearray *ba;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
- j = builtin_newarray_short(len);
+ ba = (java_bytearray *) array;
- return j;
+ if (elems != ba->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(ba->data, elems, s1, ba->header.size);
+ break;
+ case 0:
+ MCOPY(ba->data, elems, s1, ba->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jintArray NewIntArray(JNIEnv *env, jsize len)
+void ReleaseCharArrayElements(JNIEnv *env, jcharArray array, jchar *elems,
+ jint mode)
{
- java_intarray *j;
+ java_chararray *ca;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
- j = builtin_newarray_int(len);
+ ca = (java_chararray *) array;
- return j;
+ if (elems != ca->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(ca->data, elems, u2, ca->header.size);
+ break;
+ case 0:
+ MCOPY(ca->data, elems, u2, ca->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jlongArray NewLongArray(JNIEnv *env, jsize len)
+void ReleaseShortArrayElements(JNIEnv *env, jshortArray array, jshort *elems,
+ jint mode)
{
- java_longarray *j;
+ java_shortarray *sa;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
- j = builtin_newarray_long(len);
+ sa = (java_shortarray *) array;
- return j;
+ if (elems != sa->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(sa->data, elems, s2, sa->header.size);
+ break;
+ case 0:
+ MCOPY(sa->data, elems, s2, sa->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jfloatArray NewFloatArray(JNIEnv *env, jsize len)
+void ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems,
+ jint mode)
{
- java_floatarray *j;
+ java_intarray *ia;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
- j = builtin_newarray_float(len);
+ ia = (java_intarray *) array;
- return j;
+ if (elems != ia->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(ia->data, elems, s4, ia->header.size);
+ break;
+ case 0:
+ MCOPY(ia->data, elems, s4, ia->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
+void ReleaseLongArrayElements(JNIEnv *env, jlongArray array, jlong *elems,
+ jint mode)
{
- java_doublearray *j;
+ java_longarray *la;
- if (len < 0) {
- *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
- return NULL;
- }
+ STATISTICS(jniinvokation());
- j = builtin_newarray_double(len);
+ la = (java_longarray *) array;
- return j;
+ /* We cast this one to prevent a compiler warning on 64-bit
+ systems since GNU Classpath typedef jlong to long long. */
+
+ if ((s8 *) elems != la->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(la->data, elems, s8, la->header.size);
+ break;
+ case 0:
+ MCOPY(la->data, elems, s8, la->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
+void ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array, jfloat *elems,
+ jint mode)
{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
-}
+ java_floatarray *fa;
+ STATISTICS(jniinvokation());
-jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
-{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
+ fa = (java_floatarray *) array;
+
+ if (elems != fa->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(fa->data, elems, float, fa->header.size);
+ break;
+ case 0:
+ MCOPY(fa->data, elems, float, fa->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
+void ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array,
+ jdouble *elems, jint mode)
{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
-}
+ java_doublearray *da;
+ STATISTICS(jniinvokation());
-jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
-{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
+ da = (java_doublearray *) array;
+
+ if (elems != da->data) {
+ switch (mode) {
+ case JNI_COMMIT:
+ MCOPY(da->data, elems, double, da->header.size);
+ break;
+ case 0:
+ MCOPY(da->data, elems, double, da->header.size);
+ /* XXX TWISTI how should it be freed? */
+ break;
+ case JNI_ABORT:
+ /* XXX TWISTI how should it be freed? */
+ break;
+ }
+ }
}
-jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
-{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
-}
+/* Get<PrimitiveType>ArrayRegion **********************************************
+ A family of functions that copies a region of a primitive array
+ into a buffer.
-jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
+*******************************************************************************/
+
+void GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
+ jsize len, jboolean *buf)
{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
-}
+ java_booleanarray *ba;
+ STATISTICS(jniinvokation());
-jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
-{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
+ ba = (java_booleanarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &ba->data[start], u1, len);
}
-jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
+void GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
+ jbyte *buf)
{
- if (isCopy) *isCopy = JNI_FALSE;
- return array->data;
-}
+ java_bytearray *ba;
+ STATISTICS(jniinvokation());
+ ba = (java_bytearray *) array;
-void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
-{
- /* empty */
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &ba->data[start], s1, len);
}
-void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
+void GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
+ jchar *buf)
{
- /* empty */
-}
+ java_chararray *ca;
+ STATISTICS(jniinvokation());
-void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
-{
- /* empty */
+ ca = (java_chararray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ca->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &ca->data[start], u2, len);
}
-void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
+void GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
+ jsize len, jshort *buf)
{
- /* empty */
-}
+ java_shortarray *sa;
+ STATISTICS(jniinvokation());
-void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
-{
- /* empty */
+ sa = (java_shortarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > sa->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &sa->data[start], s2, len);
}
-void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
+void GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
+ jint *buf)
{
- /* empty */
-}
+ java_intarray *ia;
+ STATISTICS(jniinvokation());
-void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
-{
- /* empty */
+ ia = (java_intarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ia->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &ia->data[start], s4, len);
}
-void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
+void GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start, jsize len,
+ jlong *buf)
{
- /* empty */
-}
+ java_longarray *la;
+ STATISTICS(jniinvokation());
-void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
-{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ la = (java_longarray *) array;
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
+ if ((start < 0) || (len < 0) || (start + len > la->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &la->data[start], s8, len);
}
-void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
+void GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
+ jsize len, jfloat *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_floatarray *fa;
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ fa = (java_floatarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > fa->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &fa->data[start], float, len);
}
-void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
+void GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
+ jsize len, jdouble *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_doublearray *da;
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ da = (java_doublearray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > da->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(buf, &da->data[start], double, len);
}
-void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
-{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+/* Set<PrimitiveType>ArrayRegion **********************************************
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
-}
+ A family of functions that copies back a region of a primitive
+ array from a buffer.
+*******************************************************************************/
-void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
+void SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
+ jsize len, jboolean *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
-}
+ java_booleanarray *ba;
+ STATISTICS(jniinvokation());
-void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
-{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ ba = (java_booleanarray *) array;
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&ba->data[start], buf, u1, len);
}
-void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
+void SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
+ jbyte *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_bytearray *ba;
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ ba = (java_bytearray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ba->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&ba->data[start], buf, s1, len);
}
-void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
+void SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
+ jchar *buf)
{
- if (start < 0 || len < 0 || start+len>array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_chararray *ca;
- else
- memcpy(buf, &array->data[start], len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ ca = (java_chararray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ca->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&ca->data[start], buf, u2, len);
}
-void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
+void SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
+ jsize len, jshort *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_shortarray *sa;
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ sa = (java_shortarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > sa->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&sa->data[start], buf, s2, len);
}
-void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
+void SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
+ jint *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_intarray *ia;
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ ia = (java_intarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > ia->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&ia->data[start], buf, s4, len);
}
-void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
+void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len,
+ jlong *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_longarray *la;
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ la = (java_longarray *) array;
+ if ((start < 0) || (len < 0) || (start + len > la->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&la->data[start], buf, s8, len);
}
-void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
+void SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
+ jsize len, jfloat *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_floatarray *fa;
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+
+ fa = (java_floatarray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > fa->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&fa->data[start], buf, float, len);
}
-void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
+void SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
+ jsize len, jdouble *buf)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_doublearray *da;
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
+ STATISTICS(jniinvokation());
+ da = (java_doublearray *) array;
+
+ if ((start < 0) || (len < 0) || (start + len > da->header.size))
+ exceptions_throw_arrayindexoutofboundsexception();
+ else
+ MCOPY(&da->data[start], buf, double, len);
}
-void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
-{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+/* Registering Native Methods *************************************************/
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
+/* RegisterNatives *************************************************************
-}
+ Registers native methods with the class specified by the clazz
+ argument. The methods parameter specifies an array of
+ JNINativeMethod structures that contain the names, signatures, and
+ function pointers of the native methods. The nMethods parameter
+ specifies the number of native methods in the array.
+*******************************************************************************/
-void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
+jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
+ jint nMethods)
{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ STATISTICS(jniinvokation());
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
+ log_text("JNI-Call: RegisterNatives: IMPLEMENT ME!!!");
+ return 0;
}
-void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
-{
- if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+/* UnregisterNatives ***********************************************************
- else
- memcpy(&array->data[start], buf, len * sizeof(array->data[0]));
-}
+ Unregisters native methods of a class. The class goes back to the
+ state before it was linked or registered with its native method
+ functions.
+ This function should not be used in normal native code. Instead, it
+ provides special programs a way to reload and relink native
+ libraries.
+
+*******************************************************************************/
-jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
+jint UnregisterNatives(JNIEnv *env, jclass clazz)
{
- log_text("JNI-Call: RegisterNatives");
- return 0;
-}
+ STATISTICS(jniinvokation());
+ /* XXX TWISTI hmm, maybe we should not support that (like kaffe) */
+
+ log_text("JNI-Call: UnregisterNatives: IMPLEMENT ME!!!");
-jint UnregisterNatives (JNIEnv* env, jclass clazz)
-{
- log_text("JNI-Call: UnregisterNatives");
return 0;
}
jint MonitorEnter(JNIEnv *env, jobject obj)
{
+ STATISTICS(jniinvokation());
+
if (!obj) {
- *exceptionptr = new_nullpointerexception();
+ exceptions_throw_nullpointerexception();
return JNI_ERR;
}
jint MonitorExit(JNIEnv *env, jobject obj)
{
+ STATISTICS(jniinvokation());
+
if (!obj) {
- *exceptionptr = new_nullpointerexception();
+ exceptions_throw_nullpointerexception();
return JNI_ERR;
}
jint GetJavaVM(JNIEnv *env, JavaVM **vm)
{
- *vm = &ptr_jvm;
+ STATISTICS(jniinvokation());
+
+ *vm = (JavaVM *) _Jv_jvm;
return 0;
}
-void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
+/* GetStringRegion *************************************************************
+
+ Copies len number of Unicode characters beginning at offset start
+ to the given buffer buf.
+
+ Throws StringIndexOutOfBoundsException on index overflow.
+
+*******************************************************************************/
+
+void GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
{
- log_text("JNI-Call: GetStringRegion");
+ java_lang_String *s;
+ java_chararray *ca;
+
+ STATISTICS(jniinvokation());
+
+ s = (java_lang_String *) str;
+ ca = s->value;
+
+ if ((start < 0) || (len < 0) || (start > s->count) ||
+ (start + len > s->count)) {
+ exceptions_throw_stringindexoutofboundsexception();
+ return;
+ }
+
+ MCOPY(buf, &ca->data[start], u2, len);
}
void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
{
- log_text("JNI-Call: GetStringUTFRegion");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: GetStringUTFRegion: IMPLEMENT ME!");
}
-/************** obtain direct pointer to array elements ***********************/
+/* GetPrimitiveArrayCritical ***************************************************
-void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
+ Obtain a direct pointer to array elements.
+
+*******************************************************************************/
+
+void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)
{
- java_objectheader *s = (java_objectheader*) array;
- arraydescriptor *desc = s->vftbl->arraydesc;
+ java_bytearray *ba;
+ jbyte *bp;
+
+ ba = (java_bytearray *) array;
- if (!desc) return NULL;
+ /* do the same as Kaffe does */
- return ((u1*)s) + desc->dataoffset;
+ bp = GetByteArrayElements(env, ba, isCopy);
+
+ return (void *) bp;
}
-void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
+/* ReleasePrimitiveArrayCritical ***********************************************
+
+ No specific documentation.
+
+*******************************************************************************/
+
+void ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray,
+ jint mode)
{
- log_text("JNI-Call: ReleasePrimitiveArrayCritical");
+ STATISTICS(jniinvokation());
+
+ /* do the same as Kaffe does */
- /* empty */
+ ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray, mode);
}
-/**** returns a pointer to an array of Unicode characters of the string *******/
-const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
+/* GetStringCritical ***********************************************************
+
+ The semantics of these two functions are similar to the existing
+ Get/ReleaseStringChars functions.
+
+*******************************************************************************/
+
+const jchar *GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)
{
- log_text("JNI-Call: GetStringCritical");
+ STATISTICS(jniinvokation());
- return GetStringChars(env,string,isCopy);
+ return GetStringChars(env, string, isCopy);
}
-/*********** native code no longer needs access to chars **********************/
-void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
+void ReleaseStringCritical(JNIEnv *env, jstring string, const jchar *cstring)
{
- log_text("JNI-Call: ReleaseStringCritical");
+ STATISTICS(jniinvokation());
- ReleaseStringChars(env,string,cstring);
+ ReleaseStringChars(env, string, cstring);
}
-jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
+jweak NewWeakGlobalRef(JNIEnv* env, jobject obj)
{
- log_text("JNI-Call: NewWeakGlobalRef");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: NewWeakGlobalRef: IMPLEMENT ME!");
return obj;
}
-void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
+void DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
{
- log_text("JNI-Call: DeleteWeakGlobalRef");
+ STATISTICS(jniinvokation());
- /* empty */
+ log_text("JNI-Call: DeleteWeakGlobalRef: IMPLEMENT ME");
}
-/** Creates a new global reference to the object referred to by the obj argument **/
+/* NewGlobalRef ****************************************************************
+
+ Creates a new global reference to the object referred to by the obj
+ argument.
+
+*******************************************************************************/
jobject NewGlobalRef(JNIEnv* env, jobject lobj)
{
- jobject refcount;
- jint val;
- jobject newval;
+ java_objectheader *o;
+ java_lang_Integer *refcount;
+ java_objectheader *newval;
+
+ STATISTICS(jniinvokation());
- MonitorEnter(env, *global_ref_table);
+#if defined(USE_THREADS)
+ builtin_monitorenter(*global_ref_table);
+#endif
- refcount = CallObjectMethod(env, *global_ref_table, getmid, lobj);
- val = (refcount == NULL) ? 0 : CallIntMethod(env, refcount, intvalue);
- newval = NewObject(env, intclass, newint, val + 1);
+ o = vm_call_method(getmid, *global_ref_table, lobj);
+
+ refcount = (java_lang_Integer *) o;
+
+ if (refcount == NULL) {
+ newval = native_new_and_init_int(class_java_lang_Integer, 1);
+
+ if (newval == NULL) {
+#if defined(USE_THREADS)
+ builtin_monitorexit(*global_ref_table);
+#endif
+ return NULL;
+ }
- if (newval != NULL) {
- CallObjectMethod(env, *global_ref_table, putmid, lobj, newval);
- MonitorExit(env, *global_ref_table);
- return lobj;
+ (void) vm_call_method(putmid, *global_ref_table, lobj, newval);
} else {
- log_text("JNI-NewGlobalRef: unable to create new java.lang.Integer");
- MonitorExit(env, *global_ref_table);
- return NULL;
+ /* we can access the object itself, as we are in a
+ synchronized section */
+
+ refcount->value++;
}
+
+#if defined(USE_THREADS)
+ builtin_monitorexit(*global_ref_table);
+#endif
+
+ return lobj;
}
-/************* Deletes the global reference pointed to by globalRef **************/
-void DeleteGlobalRef(JNIEnv* env, jobject gref)
+/* DeleteGlobalRef *************************************************************
+
+ Deletes the global reference pointed to by globalRef.
+
+*******************************************************************************/
+
+void DeleteGlobalRef(JNIEnv* env, jobject globalRef)
{
- jobject refcount;
- jint val;
+ java_objectheader *o;
+ java_lang_Integer *refcount;
+ s4 val;
+
+ STATISTICS(jniinvokation());
+
+#if defined(USE_THREADS)
+ builtin_monitorenter(*global_ref_table);
+#endif
- MonitorEnter(env, *global_ref_table);
- refcount = CallObjectMethod(env, *global_ref_table, getmid, gref);
+ o = vm_call_method(getmid, *global_ref_table, globalRef);
+
+ refcount = (java_lang_Integer *) o;
if (refcount == NULL) {
log_text("JNI-DeleteGlobalRef: unable to find global reference");
return;
}
- val = CallIntMethod(env, refcount, intvalue);
- val--;
+ /* we can access the object itself, as we are in a synchronized
+ section */
+
+ val = refcount->value - 1;
if (val == 0) {
- CallObjectMethod(env, *global_ref_table, removemid,refcount);
+ (void) vm_call_method(removemid, *global_ref_table, refcount);
} else {
- jobject newval = NewObject(env, intclass, newint, val);
+ /* we do not create a new object, but set the new value into
+ the old one */
- if (newval != NULL) {
- CallObjectMethod(env,*global_ref_table, putmid,newval);
-
- } else {
- log_text("JNI-DeleteGlobalRef: unable to create new java.lang.Integer");
- }
+ refcount->value = val;
}
- MonitorExit(env,*global_ref_table);
+#if defined(USE_THREADS)
+ builtin_monitorexit(*global_ref_table);
+#endif
}
-/* ExceptionCheck *****************************************************************
+/* ExceptionCheck **************************************************************
- check for pending exception
+ Returns JNI_TRUE when there is a pending exception; otherwise,
+ returns JNI_FALSE.
-**********************************************************************************/
+*******************************************************************************/
jboolean ExceptionCheck(JNIEnv *env)
{
+ STATISTICS(jniinvokation());
+
return *exceptionptr ? JNI_TRUE : JNI_FALSE;
}
/* NewDirectByteBuffer *********************************************************
- Allocates and returns a direct java.nio.ByteBuffer referring to the block of
- memory starting at the memory address address and extending capacity bytes.
+ Allocates and returns a direct java.nio.ByteBuffer referring to the
+ block of memory starting at the memory address address and
+ extending capacity bytes.
*******************************************************************************/
jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
{
- log_text("NewDirectByteBuffer: IMPLEMENT ME!");
+ java_objectheader *nbuf;
+#if SIZEOF_VOID_P == 8
+ gnu_classpath_Pointer64 *paddress;
+#else
+ gnu_classpath_Pointer32 *paddress;
+#endif
- return NULL;
+ STATISTICS(jniinvokation());
+
+ /* alocate a gnu.classpath.Pointer{32,64} object */
+
+#if SIZEOF_VOID_P == 8
+ if (!(paddress = (gnu_classpath_Pointer64 *)
+ builtin_new(class_gnu_classpath_Pointer64)))
+#else
+ if (!(paddress = (gnu_classpath_Pointer32 *)
+ builtin_new(class_gnu_classpath_Pointer32)))
+#endif
+ return NULL;
+
+ /* fill gnu.classpath.Pointer{32,64} with address */
+
+ paddress->data = (ptrint) address;
+
+ /* create a java.nio.DirectByteBufferImpl$ReadWrite object */
+
+ nbuf = (*env)->NewObject(env, class_java_nio_DirectByteBufferImpl_ReadWrite,
+ (jmethodID) dbbirw_init, NULL, paddress,
+ (jint) capacity, (jint) capacity, (jint) 0);
+
+ /* add local reference and return the value */
+
+ return NewLocalRef(env, nbuf);
}
/* GetDirectBufferAddress ******************************************************
- Fetches and returns the starting address of the memory region referenced by
- the given direct java.nio.Buffer.
+ Fetches and returns the starting address of the memory region
+ referenced by the given direct java.nio.Buffer.
*******************************************************************************/
void *GetDirectBufferAddress(JNIEnv *env, jobject buf)
{
- log_text("GetDirectBufferAddress: IMPLEMENT ME!");
+ java_nio_DirectByteBufferImpl *nbuf;
+#if SIZEOF_VOID_P == 8
+ gnu_classpath_Pointer64 *address;
+#else
+ gnu_classpath_Pointer32 *address;
+#endif
- return NULL;
+ STATISTICS(jniinvokation());
+
+ if (!builtin_instanceof(buf, class_java_nio_Buffer))
+ return NULL;
+
+ nbuf = (java_nio_DirectByteBufferImpl *) buf;
+
+#if SIZEOF_VOID_P == 8
+ address = (gnu_classpath_Pointer64 *) nbuf->address;
+#else
+ address = (gnu_classpath_Pointer32 *) nbuf->address;
+#endif
+
+ return (void *) address->data;
}
/* GetDirectBufferCapacity *****************************************************
- Fetches and returns the capacity in bytes of the memory region referenced by
- the given direct java.nio.Buffer.
+ Fetches and returns the capacity in bytes of the memory region
+ referenced by the given direct java.nio.Buffer.
*******************************************************************************/
jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
{
- log_text("GetDirectBufferCapacity: IMPLEMENT ME!");
+ java_nio_Buffer *nbuf;
- return 0;
+ STATISTICS(jniinvokation());
+
+ if (!builtin_instanceof(buf, class_java_nio_DirectByteBufferImpl))
+ return -1;
+
+ nbuf = (java_nio_Buffer *) buf;
+
+ return (jlong) nbuf->cap;
}
+/* DestroyJavaVM ***************************************************************
+
+ Unloads a Java VM and reclaims its resources. Only the main thread
+ can unload the VM. The system waits until the main thread is only
+ remaining user thread before it destroys the VM.
+
+*******************************************************************************/
+
jint DestroyJavaVM(JavaVM *vm)
{
- log_text("DestroyJavaVM called");
+ s4 status;
- return 0;
+ STATISTICS(jniinvokation());
+
+ status = vm_destroy(vm);
+
+ return status;
}
-jint AttachCurrentThread(JavaVM *vm, void **par1, void *par2)
-{
- log_text("AttachCurrentThread called");
+/* AttachCurrentThread *********************************************************
- return 0;
-}
+ Attaches the current thread to a Java VM. Returns a JNI interface
+ pointer in the JNIEnv argument.
+ Trying to attach a thread that is already attached is a no-op.
-jint DetachCurrentThread(JavaVM *vm)
-{
- log_text("DetachCurrentThread called");
+ A native thread cannot be attached simultaneously to two Java VMs.
- return 0;
-}
+ When a thread is attached to the VM, the context class loader is
+ the bootstrap loader.
+*******************************************************************************/
-jint GetEnv(JavaVM *vm, void **env, jint version)
+jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
{
- if ((version != JNI_VERSION_1_1) && (version != JNI_VERSION_1_2) &&
- (version != JNI_VERSION_1_4)) {
- *env = NULL;
- return JNI_EVERSION;
- }
+ STATISTICS(jniinvokation());
- /*
- TODO: If the current thread is not attached to the VM...
- if (0) {
- *env = NULL;
- return JNI_EDETACHED;
- }
- */
+ log_text("JNI-Call: AttachCurrentThread: IMPLEMENT ME!");
- *env = &ptr_env;
+#if !defined(HAVE___THREAD)
+/* cacao_thread_attach();*/
+#else
+ #error "No idea how to implement that. Perhaps Stefan knows"
+#endif
- return JNI_OK;
+ *env = _Jv_env;
+
+ return 0;
}
-jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
+jint DetachCurrentThread(JavaVM *vm)
{
- log_text("AttachCurrentThreadAsDaemon called");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: DetachCurrentThread: IMPLEMENT ME!");
return 0;
}
-/************* JNI Initialization ****************************************************/
-jobject jni_init1(JNIEnv* env, jobject lobj) {
-#if defined(USE_THREADS)
- while (initrunning) {yieldThread();} /* wait until init is done */
-#endif
- if (global_ref_table == NULL) {
- jni_init();
- }
-#if defined(USE_THREADS)
- else {
- /* wait until jni_init is done */
- MonitorEnter(env, *global_ref_table) ;
- MonitorExit(env, *global_ref_table);
- }
-#endif
- return NewGlobalRef(env, lobj);
-}
-void jni_init2(JNIEnv* env, jobject gref) {
- log_text("DeleteGlobalref called before NewGlobalref");
-#if defined(USE_THREADS)
- while (initrunning) {yieldThread();} /* wait until init is done */
-#endif
- if (global_ref_table == NULL) {
- jni_init();
- }
-#if defined(USE_THREADS)
- else {
- /* wait until jni_init is done */
- MonitorEnter(env, *global_ref_table) ;
- MonitorExit(env, *global_ref_table);
- }
-#endif
- DeleteGlobalRef(env, gref);
-}
+/* GetEnv **********************************************************************
-void jni_init(){
- jmethodID mid;
+ If the current thread is not attached to the VM, sets *env to NULL,
+ and returns JNI_EDETACHED. If the specified version is not
+ supported, sets *env to NULL, and returns JNI_EVERSION. Otherwise,
+ sets *env to the appropriate interface, and returns JNI_OK.
- initrunning = true;
- log_text("JNI-Init: initialize global_ref_table");
- /* initalize global reference table */
- ihmclass = FindClass(NULL, "java/util/IdentityHashMap");
-
- if (ihmclass == NULL) {
- log_text("JNI-Init: unable to find java.util.IdentityHashMap");
- }
+*******************************************************************************/
- mid = GetMethodID(NULL, ihmclass, "<init>","()V");
- if (mid == NULL) {
- log_text("JNI-Init: unable to find constructor in java.util.IdentityHashMap");
- }
-
- global_ref_table = (jobject*)heap_allocate(sizeof(jobject),true,NULL);
+jint GetEnv(JavaVM *vm, void **env, jint version)
+{
+ STATISTICS(jniinvokation());
- *global_ref_table = NewObject(NULL,ihmclass,mid);
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+ if (thread_getself() == NULL) {
+ *env = NULL;
- if (*global_ref_table == NULL) {
- log_text("JNI-Init: unable to create new global_ref_table");
+ return JNI_EDETACHED;
}
+#endif
- initrunning = false;
+ if ((version == JNI_VERSION_1_1) || (version == JNI_VERSION_1_2) ||
+ (version == JNI_VERSION_1_4)) {
+ *env = _Jv_env;
- getmid = GetMethodID(NULL, ihmclass, "get","(Ljava/lang/Object;)Ljava/lang/Object;");
- if (mid == NULL) {
- log_text("JNI-Init: unable to find method \"get\" in java.util.IdentityHashMap");
+ return JNI_OK;
}
- getmid = GetMethodID(NULL ,ihmclass, "get","(Ljava/lang/Object;)Ljava/lang/Object;");
- if (getmid == NULL) {
- log_text("JNI-Init: unable to find method \"get\" in java.util.IdentityHashMap");
- }
+#if defined(ENABLE_JVMTI)
+ if (version == JVMTI_VERSION_1_0) {
+ *env = (void *) new_jvmtienv();
- putmid = GetMethodID(NULL, ihmclass, "put","(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
- if (putmid == NULL) {
- log_text("JNI-Init: unable to find method \"put\" in java.util.IdentityHashMap");
+ if (env != NULL)
+ return JNI_OK;
}
+#endif
+
+ *env = NULL;
- intclass = FindClass(NULL, "java/lang/Integer");
- if (intclass == NULL) {
- log_text("JNI-Init: unable to find java.lang.Integer");
- }
+ return JNI_EVERSION;
+}
- newint = GetMethodID(NULL, intclass, "<init>","(I)V");
- if (newint == NULL) {
- log_text("JNI-Init: unable to find constructor in java.lang.Integer");
- }
- intvalue = GetMethodID(NULL, intclass, "intValue","()I");
- if (intvalue == NULL) {
- log_text("JNI-Init: unable to find method \"intValue\" in java.lang.Integer");
- }
- removemid = GetMethodID(NULL, ihmclass, "remove","(Ljava/lang/Object;)Ljava/lang/Object;");
- if (removemid == NULL) {
- log_text("JNI-DeleteGlobalRef: unable to find method \"remove\" in java.lang.Object");
- }
-
- /* set NewGlobalRef, DeleteGlobalRef envTable entry to real implementation */
+jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
+{
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: AttachCurrentThreadAsDaemon: IMPLEMENT ME!");
- JNI_JNIEnvTable.NewGlobalRef = &NewGlobalRef;
- JNI_JNIEnvTable.DeleteGlobalRef = &DeleteGlobalRef;
+ return 0;
}
/* JNI invocation table *******************************************************/
-const struct JNIInvokeInterface JNI_JavaVMTable = {
+const struct JNIInvokeInterface _Jv_JNIInvokeInterface = {
NULL,
NULL,
NULL,
/* JNI function table *********************************************************/
-struct JNINativeInterface JNI_JNIEnvTable = {
+struct JNINativeInterface _Jv_JNINativeInterface = {
NULL,
NULL,
NULL,
NULL,
- &GetVersion,
-
- &DefineClass,
- &FindClass,
- &FromReflectedMethod,
- &FromReflectedField,
- &ToReflectedMethod,
- &GetSuperclass,
- &IsAssignableFrom,
- &ToReflectedField,
-
- &Throw,
- &ThrowNew,
- &ExceptionOccurred,
- &ExceptionDescribe,
- &ExceptionClear,
- &FatalError,
- &PushLocalFrame,
- &PopLocalFrame,
-
- &jni_init1, /* &NewGlobalRef, initialize Global_Ref_Table*/
- &jni_init2, /* &DeleteGlobalRef,*/
- &DeleteLocalRef,
- &IsSameObject,
- &NewLocalRef,
- &EnsureLocalCapacity,
-
- &AllocObject,
- &NewObject,
- &NewObjectV,
- &NewObjectA,
-
- &GetObjectClass,
- &IsInstanceOf,
-
- &GetMethodID,
-
- &CallObjectMethod,
- &CallObjectMethodV,
- &CallObjectMethodA,
- &CallBooleanMethod,
- &CallBooleanMethodV,
- &CallBooleanMethodA,
- &CallByteMethod,
- &CallByteMethodV,
- &CallByteMethodA,
- &CallCharMethod,
- &CallCharMethodV,
- &CallCharMethodA,
- &CallShortMethod,
- &CallShortMethodV,
- &CallShortMethodA,
- &CallIntMethod,
- &CallIntMethodV,
- &CallIntMethodA,
- &CallLongMethod,
- &CallLongMethodV,
- &CallLongMethodA,
- &CallFloatMethod,
- &CallFloatMethodV,
- &CallFloatMethodA,
- &CallDoubleMethod,
- &CallDoubleMethodV,
- &CallDoubleMethodA,
- &CallVoidMethod,
- &CallVoidMethodV,
- &CallVoidMethodA,
-
- &CallNonvirtualObjectMethod,
- &CallNonvirtualObjectMethodV,
- &CallNonvirtualObjectMethodA,
- &CallNonvirtualBooleanMethod,
- &CallNonvirtualBooleanMethodV,
- &CallNonvirtualBooleanMethodA,
- &CallNonvirtualByteMethod,
- &CallNonvirtualByteMethodV,
- &CallNonvirtualByteMethodA,
- &CallNonvirtualCharMethod,
- &CallNonvirtualCharMethodV,
- &CallNonvirtualCharMethodA,
- &CallNonvirtualShortMethod,
- &CallNonvirtualShortMethodV,
- &CallNonvirtualShortMethodA,
- &CallNonvirtualIntMethod,
- &CallNonvirtualIntMethodV,
- &CallNonvirtualIntMethodA,
- &CallNonvirtualLongMethod,
- &CallNonvirtualLongMethodV,
- &CallNonvirtualLongMethodA,
- &CallNonvirtualFloatMethod,
- &CallNonvirtualFloatMethodV,
- &CallNonvirtualFloatMethodA,
- &CallNonvirtualDoubleMethod,
- &CallNonvirtualDoubleMethodV,
- &CallNonvirtualDoubleMethodA,
- &CallNonvirtualVoidMethod,
- &CallNonvirtualVoidMethodV,
- &CallNonvirtualVoidMethodA,
-
- &GetFieldID,
-
- &GetObjectField,
- &GetBooleanField,
- &GetByteField,
- &GetCharField,
- &GetShortField,
- &GetIntField,
- &GetLongField,
- &GetFloatField,
- &GetDoubleField,
- &SetObjectField,
- &SetBooleanField,
- &SetByteField,
- &SetCharField,
- &SetShortField,
- &SetIntField,
- &SetLongField,
- &SetFloatField,
- &SetDoubleField,
-
- &GetStaticMethodID,
-
- &CallStaticObjectMethod,
- &CallStaticObjectMethodV,
- &CallStaticObjectMethodA,
- &CallStaticBooleanMethod,
- &CallStaticBooleanMethodV,
- &CallStaticBooleanMethodA,
- &CallStaticByteMethod,
- &CallStaticByteMethodV,
- &CallStaticByteMethodA,
- &CallStaticCharMethod,
- &CallStaticCharMethodV,
- &CallStaticCharMethodA,
- &CallStaticShortMethod,
- &CallStaticShortMethodV,
- &CallStaticShortMethodA,
- &CallStaticIntMethod,
- &CallStaticIntMethodV,
- &CallStaticIntMethodA,
- &CallStaticLongMethod,
- &CallStaticLongMethodV,
- &CallStaticLongMethodA,
- &CallStaticFloatMethod,
- &CallStaticFloatMethodV,
- &CallStaticFloatMethodA,
- &CallStaticDoubleMethod,
- &CallStaticDoubleMethodV,
- &CallStaticDoubleMethodA,
- &CallStaticVoidMethod,
- &CallStaticVoidMethodV,
- &CallStaticVoidMethodA,
-
- &GetStaticFieldID,
-
- &GetStaticObjectField,
- &GetStaticBooleanField,
- &GetStaticByteField,
- &GetStaticCharField,
- &GetStaticShortField,
- &GetStaticIntField,
- &GetStaticLongField,
- &GetStaticFloatField,
- &GetStaticDoubleField,
- &SetStaticObjectField,
- &SetStaticBooleanField,
- &SetStaticByteField,
- &SetStaticCharField,
- &SetStaticShortField,
- &SetStaticIntField,
- &SetStaticLongField,
- &SetStaticFloatField,
- &SetStaticDoubleField,
-
- &NewString,
- &GetStringLength,
- &GetStringChars,
- &ReleaseStringChars,
-
- &NewStringUTF,
- &GetStringUTFLength,
- &GetStringUTFChars,
- &ReleaseStringUTFChars,
-
- &GetArrayLength,
-
- &NewObjectArray,
- &GetObjectArrayElement,
- &SetObjectArrayElement,
-
- &NewBooleanArray,
- &NewByteArray,
- &NewCharArray,
- &NewShortArray,
- &NewIntArray,
- &NewLongArray,
- &NewFloatArray,
- &NewDoubleArray,
-
- &GetBooleanArrayElements,
- &GetByteArrayElements,
- &GetCharArrayElements,
- &GetShortArrayElements,
- &GetIntArrayElements,
- &GetLongArrayElements,
- &GetFloatArrayElements,
- &GetDoubleArrayElements,
-
- &ReleaseBooleanArrayElements,
- &ReleaseByteArrayElements,
- &ReleaseCharArrayElements,
- &ReleaseShortArrayElements,
- &ReleaseIntArrayElements,
- &ReleaseLongArrayElements,
- &ReleaseFloatArrayElements,
- &ReleaseDoubleArrayElements,
-
- &GetBooleanArrayRegion,
- &GetByteArrayRegion,
- &GetCharArrayRegion,
- &GetShortArrayRegion,
- &GetIntArrayRegion,
- &GetLongArrayRegion,
- &GetFloatArrayRegion,
- &GetDoubleArrayRegion,
- &SetBooleanArrayRegion,
- &SetByteArrayRegion,
- &SetCharArrayRegion,
- &SetShortArrayRegion,
- &SetIntArrayRegion,
- &SetLongArrayRegion,
- &SetFloatArrayRegion,
- &SetDoubleArrayRegion,
-
- &RegisterNatives,
- &UnregisterNatives,
-
- &MonitorEnter,
- &MonitorExit,
-
- &GetJavaVM,
+ GetVersion,
+
+ DefineClass,
+ FindClass,
+ FromReflectedMethod,
+ FromReflectedField,
+ ToReflectedMethod,
+ GetSuperclass,
+ IsAssignableFrom,
+ ToReflectedField,
+
+ Throw,
+ ThrowNew,
+ ExceptionOccurred,
+ ExceptionDescribe,
+ ExceptionClear,
+ FatalError,
+ PushLocalFrame,
+ PopLocalFrame,
+
+ NewGlobalRef,
+ DeleteGlobalRef,
+ DeleteLocalRef,
+ IsSameObject,
+ NewLocalRef,
+ EnsureLocalCapacity,
+
+ AllocObject,
+ NewObject,
+ NewObjectV,
+ NewObjectA,
+
+ GetObjectClass,
+ IsInstanceOf,
+
+ GetMethodID,
+
+ CallObjectMethod,
+ CallObjectMethodV,
+ CallObjectMethodA,
+ CallBooleanMethod,
+ CallBooleanMethodV,
+ CallBooleanMethodA,
+ CallByteMethod,
+ CallByteMethodV,
+ CallByteMethodA,
+ CallCharMethod,
+ CallCharMethodV,
+ CallCharMethodA,
+ CallShortMethod,
+ CallShortMethodV,
+ CallShortMethodA,
+ CallIntMethod,
+ CallIntMethodV,
+ CallIntMethodA,
+ CallLongMethod,
+ CallLongMethodV,
+ CallLongMethodA,
+ CallFloatMethod,
+ CallFloatMethodV,
+ CallFloatMethodA,
+ CallDoubleMethod,
+ CallDoubleMethodV,
+ CallDoubleMethodA,
+ CallVoidMethod,
+ CallVoidMethodV,
+ CallVoidMethodA,
+
+ CallNonvirtualObjectMethod,
+ CallNonvirtualObjectMethodV,
+ CallNonvirtualObjectMethodA,
+ CallNonvirtualBooleanMethod,
+ CallNonvirtualBooleanMethodV,
+ CallNonvirtualBooleanMethodA,
+ CallNonvirtualByteMethod,
+ CallNonvirtualByteMethodV,
+ CallNonvirtualByteMethodA,
+ CallNonvirtualCharMethod,
+ CallNonvirtualCharMethodV,
+ CallNonvirtualCharMethodA,
+ CallNonvirtualShortMethod,
+ CallNonvirtualShortMethodV,
+ CallNonvirtualShortMethodA,
+ CallNonvirtualIntMethod,
+ CallNonvirtualIntMethodV,
+ CallNonvirtualIntMethodA,
+ CallNonvirtualLongMethod,
+ CallNonvirtualLongMethodV,
+ CallNonvirtualLongMethodA,
+ CallNonvirtualFloatMethod,
+ CallNonvirtualFloatMethodV,
+ CallNonvirtualFloatMethodA,
+ CallNonvirtualDoubleMethod,
+ CallNonvirtualDoubleMethodV,
+ CallNonvirtualDoubleMethodA,
+ CallNonvirtualVoidMethod,
+ CallNonvirtualVoidMethodV,
+ CallNonvirtualVoidMethodA,
+
+ GetFieldID,
+
+ GetObjectField,
+ GetBooleanField,
+ GetByteField,
+ GetCharField,
+ GetShortField,
+ GetIntField,
+ GetLongField,
+ GetFloatField,
+ GetDoubleField,
+ SetObjectField,
+ SetBooleanField,
+ SetByteField,
+ SetCharField,
+ SetShortField,
+ SetIntField,
+ SetLongField,
+ SetFloatField,
+ SetDoubleField,
+
+ GetStaticMethodID,
+
+ CallStaticObjectMethod,
+ CallStaticObjectMethodV,
+ CallStaticObjectMethodA,
+ CallStaticBooleanMethod,
+ CallStaticBooleanMethodV,
+ CallStaticBooleanMethodA,
+ CallStaticByteMethod,
+ CallStaticByteMethodV,
+ CallStaticByteMethodA,
+ CallStaticCharMethod,
+ CallStaticCharMethodV,
+ CallStaticCharMethodA,
+ CallStaticShortMethod,
+ CallStaticShortMethodV,
+ CallStaticShortMethodA,
+ CallStaticIntMethod,
+ CallStaticIntMethodV,
+ CallStaticIntMethodA,
+ CallStaticLongMethod,
+ CallStaticLongMethodV,
+ CallStaticLongMethodA,
+ CallStaticFloatMethod,
+ CallStaticFloatMethodV,
+ CallStaticFloatMethodA,
+ CallStaticDoubleMethod,
+ CallStaticDoubleMethodV,
+ CallStaticDoubleMethodA,
+ CallStaticVoidMethod,
+ CallStaticVoidMethodV,
+ CallStaticVoidMethodA,
+
+ GetStaticFieldID,
+
+ GetStaticObjectField,
+ GetStaticBooleanField,
+ GetStaticByteField,
+ GetStaticCharField,
+ GetStaticShortField,
+ GetStaticIntField,
+ GetStaticLongField,
+ GetStaticFloatField,
+ GetStaticDoubleField,
+ SetStaticObjectField,
+ SetStaticBooleanField,
+ SetStaticByteField,
+ SetStaticCharField,
+ SetStaticShortField,
+ SetStaticIntField,
+ SetStaticLongField,
+ SetStaticFloatField,
+ SetStaticDoubleField,
+
+ NewString,
+ GetStringLength,
+ GetStringChars,
+ ReleaseStringChars,
+
+ NewStringUTF,
+ GetStringUTFLength,
+ GetStringUTFChars,
+ ReleaseStringUTFChars,
+
+ GetArrayLength,
+
+ NewObjectArray,
+ GetObjectArrayElement,
+ SetObjectArrayElement,
+
+ NewBooleanArray,
+ NewByteArray,
+ NewCharArray,
+ NewShortArray,
+ NewIntArray,
+ NewLongArray,
+ NewFloatArray,
+ NewDoubleArray,
+
+ GetBooleanArrayElements,
+ GetByteArrayElements,
+ GetCharArrayElements,
+ GetShortArrayElements,
+ GetIntArrayElements,
+ GetLongArrayElements,
+ GetFloatArrayElements,
+ GetDoubleArrayElements,
+
+ ReleaseBooleanArrayElements,
+ ReleaseByteArrayElements,
+ ReleaseCharArrayElements,
+ ReleaseShortArrayElements,
+ ReleaseIntArrayElements,
+ ReleaseLongArrayElements,
+ ReleaseFloatArrayElements,
+ ReleaseDoubleArrayElements,
+
+ GetBooleanArrayRegion,
+ GetByteArrayRegion,
+ GetCharArrayRegion,
+ GetShortArrayRegion,
+ GetIntArrayRegion,
+ GetLongArrayRegion,
+ GetFloatArrayRegion,
+ GetDoubleArrayRegion,
+ SetBooleanArrayRegion,
+ SetByteArrayRegion,
+ SetCharArrayRegion,
+ SetShortArrayRegion,
+ SetIntArrayRegion,
+ SetLongArrayRegion,
+ SetFloatArrayRegion,
+ SetDoubleArrayRegion,
+
+ RegisterNatives,
+ UnregisterNatives,
+
+ MonitorEnter,
+ MonitorExit,
+
+ GetJavaVM,
/* new JNI 1.2 functions */
- &GetStringRegion,
- &GetStringUTFRegion,
+ GetStringRegion,
+ GetStringUTFRegion,
- &GetPrimitiveArrayCritical,
- &ReleasePrimitiveArrayCritical,
+ GetPrimitiveArrayCritical,
+ ReleasePrimitiveArrayCritical,
- &GetStringCritical,
- &ReleaseStringCritical,
+ GetStringCritical,
+ ReleaseStringCritical,
- &NewWeakGlobalRef,
- &DeleteWeakGlobalRef,
+ NewWeakGlobalRef,
+ DeleteWeakGlobalRef,
- &ExceptionCheck,
+ ExceptionCheck,
/* new JNI 1.4 functions */
- &NewDirectByteBuffer,
- &GetDirectBufferAddress,
- &GetDirectBufferCapacity
+ NewDirectByteBuffer,
+ GetDirectBufferAddress,
+ GetDirectBufferCapacity
};
jint JNI_GetDefaultJavaVMInitArgs(void *vm_args)
{
- JDK1_1InitArgs *_vm_args = (JDK1_1InitArgs *) vm_args;
+ JavaVMInitArgs *_vm_args;
+
+ _vm_args = (JavaVMInitArgs *) vm_args;
/* GNU classpath currently supports JNI 1.2 */
- _vm_args->version = JNI_VERSION_1_2;
+ switch (_vm_args->version) {
+ case JNI_VERSION_1_1:
+ _vm_args->version = JNI_VERSION_1_1;
+ break;
+
+ case JNI_VERSION_1_2:
+ case JNI_VERSION_1_4:
+ _vm_args->ignoreUnrecognized = JNI_FALSE;
+ _vm_args->options = NULL;
+ _vm_args->nOptions = 0;
+ break;
+ default:
+ return -1;
+ }
+
return 0;
}
*******************************************************************************/
-jint JNI_CreateJavaVM(JavaVM **p_vm, JNIEnv **p_env, void *vm_args)
+jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args)
{
- *p_vm = (JavaVM *) &JNI_JavaVMTable;
- *p_env = (JNIEnv *) &JNI_JNIEnvTable;
-
- return 0;
-}
-
-
-jobject *jni_method_invokeNativeHelper(JNIEnv *env, struct methodinfo *methodID, jobject obj, java_objectarray *params)
-{
- int argcount;
- jni_callblock *blk;
- char retT;
- jobject retVal;
-
- if (methodID == 0) {
- *exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
- return NULL;
- }
-
- argcount = get_parametercount(methodID);
-
- /* the method is an instance method the obj has to be an instance of the
- class the method belongs to. For static methods the obj parameter
- is ignored. */
- if (!(methodID->flags & ACC_STATIC) && obj &&
- (!builtin_instanceof((java_objectheader *) obj, methodID->class))) {
- *exceptionptr = new_exception_message(string_java_lang_IllegalArgumentException,
- "Object parameter of wrong type in Java_java_lang_reflect_Method_invokeNative");
- return 0;
- }
-
-
-#ifdef arglimit
- if (argcount > 3) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- log_text("Too many arguments. invokeNativeHelper does not support that");
- return 0;
- }
-#endif
- if (((params==0) && (argcount != 0)) || (params && (params->header.size != argcount))) {
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
- return 0;
- }
-
-
- if (((methodID->flags & ACC_STATIC)==0) && (0==obj)) {
- *exceptionptr =
- new_exception_message(string_java_lang_NullPointerException,
- "Static mismatch in Java_java_lang_reflect_Method_invokeNative");
- return 0;
- }
+ JavaVMInitArgs *_vm_args;
+ _Jv_JNIEnv *env;
+ _Jv_JavaVM *jvm;
+ localref_table *lrt;
- if ((methodID->flags & ACC_STATIC) && (obj)) obj = 0;
+ /* get the arguments for the new JVM */
- if (obj) {
- if ( (methodID->flags & ACC_ABSTRACT) || (methodID->class->flags & ACC_INTERFACE) ) {
- methodID=get_virtual(obj,methodID);
- }
- }
+ _vm_args = (JavaVMInitArgs *) vm_args;
- blk = MNEW(jni_callblock, /*4 */argcount+2);
+ /* get the VM and Env tables (must be set before vm_create) */
- retT = fill_callblock_objA(obj, methodID->descriptor, blk, params);
+ env = NEW(_Jv_JNIEnv);
+ env->env = &_Jv_JNINativeInterface;
- switch (retT) {
- case 'V':
- (void) asm_calljavafunction2(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = NULL; /*native_new_and_init(loader_load(utf_new_char("java/lang/Void")));*/
- break;
+ /* XXX Set the global variable. Maybe we should do that differently. */
- case 'I': {
- s4 intVal;
- intVal = asm_calljavafunction2int(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Integer);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_int__void),
- intVal);
- }
- break;
+ _Jv_env = env;
- case 'B': {
- s4 intVal;
- intVal = asm_calljavafunction2int(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Byte);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_byte__void),
- intVal);
- }
- break;
+ /* actually create the JVM */
- case 'C': {
- s4 intVal;
- intVal = asm_calljavafunction2int(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Character);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_char__void),
- intVal);
- }
- break;
+ if (!vm_create(_vm_args))
+ return -1;
- case 'S': {
- s4 intVal;
- intVal = asm_calljavafunction2int(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Short);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_short__void),
- intVal);
- }
- break;
+ /* create and fill a JavaVM structure */
- case 'Z': {
- s4 intVal;
- intVal = asm_calljavafunction2int(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Boolean);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_boolean__void),
- intVal);
- }
- break;
+ jvm = NEW(_Jv_JavaVM);
+ jvm->functions = &_Jv_JNIInvokeInterface;
- case 'J': {
- jlong longVal;
- longVal = asm_calljavafunction2long(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Long);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_long__void),
- longVal);
- }
- break;
+ /* XXX Set the global variable. Maybe we should do that differently. */
- case 'F': {
- jdouble floatVal;
- floatVal = asm_calljavafunction2float(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Float);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_float__void),
- floatVal);
- }
- break;
+ _Jv_jvm = jvm;
- case 'D': {
- jdouble doubleVal;
- doubleVal = asm_calljavafunction2double(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- retVal = builtin_new(class_java_lang_Double);
- CallVoidMethod(env,
- retVal,
- class_resolvemethod(retVal->vftbl->class,
- utf_init,
- utf_double__void),
- doubleVal);
- }
- break;
+ /* setup the local ref table (must be created after vm_create) */
- case 'L': /* fall through */
- case '[':
- retVal = asm_calljavafunction2(methodID,
- argcount + 1,
- (argcount + 1) * sizeof(jni_callblock),
- blk);
- break;
+ lrt = GCNEW(localref_table);
- default:
- /* if this happens the acception has already been set by fill_callblock_objA*/
- MFREE(blk, jni_callblock, /*4 */ argcount+2);
- return (jobject *) 0;
- }
+ lrt->capacity = LOCALREFTABLE_CAPACITY;
+ lrt->used = 0;
+ lrt->localframes = 1;
+ lrt->prev = LOCALREFTABLE;
- MFREE(blk, jni_callblock, /* 4 */ argcount+2);
+ /* clear the references array (memset is faster then a for-loop) */
- if (*exceptionptr) {
- java_objectheader *exceptionToWrap = *exceptionptr;
- classinfo *ivtec;
- java_objectheader *ivte;
+ MSET(lrt->refs, 0, java_objectheader*, LOCALREFTABLE_CAPACITY);
- *exceptionptr = NULL;
- ivtec = class_new(utf_new_char("java/lang/reflect/InvocationTargetException"));
- ivte = builtin_new(ivtec);
- asm_calljavafunction(class_resolvemethod(ivtec,
- utf_new_char("<init>"),
- utf_new_char("(Ljava/lang/Throwable;)V")),
- ivte,
- exceptionToWrap,
- 0,
- 0);
+ LOCALREFTABLE = lrt;
- if (*exceptionptr != NULL)
- panic("jni.c: error while creating InvocationTargetException wrapper");
+ /* now return the values */
- *exceptionptr = ivte;
- }
+ *p_vm = (JavaVM *) jvm;
+ *p_env = (void *) env;
- return (jobject *) retVal;
+ return 0;
}
-
-
/*
* These are local overrides for various environment variables in Emacs.
* Please do not remove this and leave it at the end of the file, where
* c-basic-offset: 4
* tab-width: 4
* End:
+ * vim:noexpandtab:sw=4:ts=4:
*/