/* src/native/jni.c - implementation of the Java Native Interface functions
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 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
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Rainhard Grafl
- Roman Obermaisser
-
- Changes: Joseph Wenninger
- Martin Platter
- Christian Thalinger
- Edwin Steiner
-
- $Id: jni.c 5572 2006-09-28 20:38:28Z edwin $
+ $Id: jni.c 7918 2007-05-20 20:42:18Z michi $
*/
#include "vm/types.h"
-#include "mm/boehm.h"
+#include "mm/gc-common.h"
#include "mm/memory.h"
#include "native/jni.h"
#include "native/native.h"
-#include "native/include/gnu_classpath_Pointer.h"
+#if defined(ENABLE_JAVASE)
+# if defined(WITH_CLASSPATH_GNU)
+# 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"
+# if SIZEOF_VOID_P == 8
+# include "native/include/gnu_classpath_Pointer64.h"
+# else
+# include "native/include/gnu_classpath_Pointer32.h"
+# endif
+# endif
#endif
#include "native/include/java_lang_Object.h"
#include "native/include/java_lang_Long.h"
#include "native/include/java_lang_Float.h"
#include "native/include/java_lang_Double.h"
+#include "native/include/java_lang_String.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_JAVASE)
+# include "native/include/java_lang_ClassLoader.h"
+
+# include "native/include/java_lang_reflect_Constructor.h"
+# include "native/include/java_lang_reflect_Field.h"
+# include "native/include/java_lang_reflect_Method.h"
+
+# include "native/include/java_nio_Buffer.h"
+# include "native/include/java_nio_DirectByteBufferImpl.h"
+#endif
#if defined(ENABLE_JVMTI)
# include "native/jvmti/cacaodbg.h"
#endif
-#if defined(ENABLE_THREADS)
-# include "threads/native/lock.h"
-# include "threads/native/threads.h"
-#else
-# include "threads/none/lock.h"
+#include "native/vm/java_lang_Class.h"
+
+#if defined(ENABLE_JAVASE)
+# include "native/vm/java_lang_ClassLoader.h"
#endif
+#include "threads/lock-common.h"
+#include "threads/threads-common.h"
+
#include "toolbox/logging.h"
+
#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/vm.h"
+
#include "vm/jit/asmpart.h"
#include "vm/jit/jit.h"
-#include "vm/statistics.h"
-#include "vm/vm.h"
+#include "vm/jit/stacktrace.h"
+
+#include "vmcore/loader.h"
+#include "vmcore/options.h"
+#include "vm/resolve.h"
+#include "vmcore/statistics.h"
/* global variables ***********************************************************/
#define HASHTABLE_GLOBAL_REF_SIZE 64 /* initial size of globalref-hash */
-static hashtable *hashtable_global_ref; /* hashtable for globalrefs */
+hashtable *hashtable_global_ref; /* hashtable for globalrefs */
/* direct buffer stuff ********************************************************/
+#if defined(ENABLE_JAVASE)
static classinfo *class_java_nio_Buffer;
static classinfo *class_java_nio_DirectByteBufferImpl;
static classinfo *class_java_nio_DirectByteBufferImpl_ReadWrite;
-#if SIZEOF_VOID_P == 8
+
+# if defined(WITH_CLASSPATH_GNU)
+# if SIZEOF_VOID_P == 8
static classinfo *class_gnu_classpath_Pointer64;
-#else
+# else
static classinfo *class_gnu_classpath_Pointer32;
-#endif
+# endif
+# endif
static methodinfo *dbbirw_init;
+#endif
/* local reference table ******************************************************/
/* some forward declarations **************************************************/
-jobject NewLocalRef(JNIEnv *env, jobject ref);
-jint EnsureLocalCapacity(JNIEnv* env, jint capacity);
+jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref);
+jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity);
/* jni_init ********************************************************************
hashtable_create(hashtable_global_ref, HASHTABLE_GLOBAL_REF_SIZE);
+#if defined(ENABLE_JAVASE)
/* direct buffer stuff */
if (!(class_java_nio_Buffer =
utf_new_char("(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V"))))
return false;
-#if SIZEOF_VOID_P == 8
+# if defined(WITH_CLASSPATH_GNU)
+# 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
+# else
if (!(class_gnu_classpath_Pointer32 =
load_class_bootstrap(utf_new_char("gnu/classpath/Pointer32"))) ||
!link_class(class_gnu_classpath_Pointer32))
return false;
+# endif
+# endif
+#endif /* defined(ENABLE_JAVASE) */
+
+ return true;
+}
+
+
+/* jni_init_localref_table *****************************************************
+
+ Initializes the local references table of the current thread.
+
+*******************************************************************************/
+
+bool jni_init_localref_table(void)
+{
+ localref_table *lrt;
+
+#if defined(ENABLE_GC_CACAO)
+ /* XXX this one will never get freed for the main thread;
+ call jni_free_localref_table() if you want to do it! */
+ lrt = NEW(localref_table);
+#else
+ lrt = GCNEW(localref_table);
+#endif
+
+ if (lrt == NULL)
+ return false;
+
+ lrt->capacity = LOCALREFTABLE_CAPACITY;
+ lrt->used = 0;
+ lrt->localframes = 1;
+ lrt->prev = LOCALREFTABLE;
+
+ /* clear the references array (memset is faster then a for-loop) */
+
+ MSET(lrt->refs, 0, java_objectheader*, LOCALREFTABLE_CAPACITY);
+
+ LOCALREFTABLE = lrt;
+
+ return true;
+}
+
+
+/* jni_init_localref_table *****************************************************
+
+ Frees the local references table of the current thread.
+
+*******************************************************************************/
+
+bool jni_free_localref_table(void)
+{
+ localref_table *lrt;
+
+#if defined(ENABLE_GC_CACAO)
+ lrt = LOCALREFTABLE;
+
+ assert(lrt);
+ assert(lrt->prev == NULL);
+
+ FREE(lrt, localref_table);
+
+ LOCALREFTABLE = NULL;
#endif
return true;
java_objectheader *ro;
s4 argcount;
s4 paramcount;
+ java_objectheader *xptr;
- if (!m) {
+ if (m == NULL) {
exceptions_throw_nullpointerexception();
return NULL;
}
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");
+ exceptions_throw_illegalargumentexception();
return NULL;
}
if (((params == NULL) && (paramcount != 0)) ||
(params && (params->header.size != paramcount)))
{
- *exceptionptr =
- new_exception(string_java_lang_IllegalArgumentException);
+ exceptions_throw_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");
+ /* XXX not sure if that is the correct exception */
+ exceptions_throw_nullpointerexception();
return NULL;
}
if (o != NULL) {
/* for instance methods we must do a vftbl lookup */
resm = method_vftbl_lookup(o->vftbl, m);
-
- } else {
+ }
+ 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))
+ if (!_Jv_jni_vmargs_from_objectarray(o, resm->parseddesc, vmargs, params)) {
+ MFREE(vmargs, vm_arg, argcount);
return NULL;
+ }
switch (resm->parseddesc->returntype.decltype) {
case TYPE_VOID:
MFREE(vmargs, vm_arg, argcount);
- if (*exceptionptr) {
- java_objectheader *cause;
-
- cause = *exceptionptr;
+ xptr = exceptions_get_exception();
+ if (xptr != NULL) {
/* clear exception pointer, we are calling JIT code again */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
- *exceptionptr =
- new_exception_throwable(string_java_lang_reflect_InvocationTargetException,
- (java_lang_Throwable *) cause);
+ exceptions_throw_invocationtargetexception(xptr);
}
return ro;
*******************************************************************************/
-jint GetVersion(JNIEnv *env)
+jint _Jv_JNI_GetVersion(JNIEnv *env)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jclass DefineClass(JNIEnv *env, const char *name, jobject loader,
- const jbyte *buf, jsize bufLen)
+jclass _Jv_JNI_DefineClass(JNIEnv *env, const char *name, jobject loader,
+ const jbyte *buf, jsize bufLen)
{
+#if defined(ENABLE_JAVASE)
java_lang_ClassLoader *cl;
java_lang_String *s;
java_bytearray *ba;
STATISTICS(jniinvokation());
cl = (java_lang_ClassLoader *) loader;
- s = javastring_new_from_utf_string(name);
+ s = (java_lang_String *) javastring_new_from_utf_string(name);
ba = (java_bytearray *) buf;
- c = (jclass) Java_java_lang_VMClassLoader_defineClass(env, NULL, cl, s, ba,
- 0, bufLen, NULL);
+ c = (jclass) _Jv_java_lang_ClassLoader_defineClass(cl, s, ba, 0, bufLen,
+ NULL);
+
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
+#else
+ vm_abort("_Jv_JNI_DefineClass: not implemented in this configuration");
+
+ /* keep compiler happy */
- return (jclass) NewLocalRef(env, (jobject) c);
+ return 0;
+#endif
}
*******************************************************************************/
-jclass FindClass(JNIEnv *env, const char *name)
+jclass _Jv_JNI_FindClass(JNIEnv *env, const char *name)
{
+#if defined(ENABLE_JAVASE)
utf *u;
classinfo *cc;
classinfo *c;
if (!link_class(c))
return NULL;
- return (jclass) NewLocalRef(env, (jobject) c);
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
+#else
+ vm_abort("_Jv_JNI_FindClass: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-jclass GetSuperclass(JNIEnv *env, jclass sub)
+jclass _Jv_JNI_GetSuperclass(JNIEnv *env, jclass sub)
{
classinfo *c;
if (!c)
return NULL;
- return (jclass) NewLocalRef(env, (jobject) c);
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
}
*******************************************************************************/
-jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
+jboolean _Jv_JNI_IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
{
+ java_lang_Class *csup;
+ java_lang_Class *csub;
+
+ csup = (java_lang_Class *) sup;
+ csub = (java_lang_Class *) sub;
+
STATISTICS(jniinvokation());
- return Java_java_lang_VMClass_isAssignableFrom(env,
- NULL,
- (java_lang_Class *) sup,
- (java_lang_Class *) sub);
+ return _Jv_java_lang_Class_isAssignableFrom(csup, csub);
}
*******************************************************************************/
-jint Throw(JNIEnv *env, jthrowable obj)
+jint _Jv_JNI_Throw(JNIEnv *env, jthrowable obj)
{
+ java_objectheader *o;
+
STATISTICS(jniinvokation());
- *exceptionptr = (java_objectheader *) obj;
+ o = (java_objectheader *) obj;
+
+ exceptions_set_exception(o);
return JNI_OK;
}
*******************************************************************************/
-jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
+jint _Jv_JNI_ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
{
- classinfo *c;
- java_lang_Throwable *o;
- java_lang_String *s;
+ classinfo *c;
+ java_objectheader *o;
+ java_objectheader *s;
STATISTICS(jniinvokation());
c = (classinfo *) clazz;
- s = (java_lang_String *) javastring_new_from_utf_string(msg);
+ s = javastring_new_from_utf_string(msg);
/* instantiate exception object */
- o = (java_lang_Throwable *) native_new_and_init_string(c, s);
+ o = native_new_and_init_string(c, s);
if (o == NULL)
return -1;
- *exceptionptr = (java_objectheader *) o;
+ exceptions_set_exception(o);
return 0;
}
*******************************************************************************/
-jthrowable ExceptionOccurred(JNIEnv *env)
+jthrowable _Jv_JNI_ExceptionOccurred(JNIEnv *env)
{
- java_objectheader *e;
+ java_objectheader *o;
STATISTICS(jniinvokation());
- e = *exceptionptr;
+ o = exceptions_get_exception();
- return NewLocalRef(env, (jthrowable) e);
+ return _Jv_JNI_NewLocalRef(env, (jthrowable) o);
}
*******************************************************************************/
-void ExceptionDescribe(JNIEnv *env)
+void _Jv_JNI_ExceptionDescribe(JNIEnv *env)
{
- java_objectheader *e;
+ java_objectheader *o;
methodinfo *m;
STATISTICS(jniinvokation());
- e = *exceptionptr;
+ o = exceptions_get_exception();
- if (e) {
+ if (o == NULL) {
/* clear exception, because we are calling jit code again */
- *exceptionptr = NULL;
+ exceptions_clear_exception();
/* get printStackTrace method from exception class */
- m = class_resolveclassmethod(e->vftbl->class,
+ m = class_resolveclassmethod(o->vftbl->class,
utf_printStackTrace,
utf_void__void,
NULL,
true);
- if (!m)
+ if (m == NULL)
/* XXX what should we do? */
return;
/* print the stacktrace */
- (void) vm_call_method(m, e);
+ (void) vm_call_method(m, o);
}
}
*******************************************************************************/
-void ExceptionClear(JNIEnv *env)
+void _Jv_JNI_ExceptionClear(JNIEnv *env)
{
STATISTICS(jniinvokation());
- *exceptionptr = NULL;
+ exceptions_clear_exception();
}
*******************************************************************************/
-void FatalError(JNIEnv *env, const char *msg)
+void _Jv_JNI_FatalError(JNIEnv *env, const char *msg)
{
STATISTICS(jniinvokation());
- throw_cacao_exception_exit(string_java_lang_InternalError, msg);
+ /* this seems to be the best way */
+
+ vm_abort(msg);
}
*******************************************************************************/
-jint PushLocalFrame(JNIEnv* env, jint capacity)
+jint _Jv_JNI_PushLocalFrame(JNIEnv* env, jint capacity)
{
s4 additionalrefs;
localref_table *lrt;
else
additionalrefs = 0;
+#if defined(ENABLE_GC_CACAO)
+ nlrt = MNEW(u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P);
+#else
nlrt = GCMNEW(u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P);
+#endif
if (nlrt == NULL)
return -1;
*******************************************************************************/
-jobject PopLocalFrame(JNIEnv* env, jobject result)
+jobject _Jv_JNI_PopLocalFrame(JNIEnv* env, jobject result)
{
localref_table *lrt;
localref_table *plrt;
s4 localframes;
+ s4 additionalrefs;
STATISTICS(jniinvokation());
return. */
if (localframes == 1)
- return NewLocalRef(env, result);
+ return _Jv_JNI_NewLocalRef(env, result);
/* release all current local frames */
lrt->prev = NULL;
+#if defined(ENABLE_GC_CACAO)
+ /* for the exact GC local reference tables are not on the heap,
+ so we need to free them explicitly here. */
+
+ if (lrt->capacity > LOCALREFTABLE_CAPACITY)
+ additionalrefs = lrt->capacity - LOCALREFTABLE_CAPACITY;
+ else
+ additionalrefs = 0;
+
+ MFREE(lrt, u1, sizeof(localref_table) + additionalrefs * SIZEOF_VOID_P);
+#endif
+
/* set new local references table */
lrt = plrt;
/* add local reference and return the value */
- return NewLocalRef(env, result);
+ return _Jv_JNI_NewLocalRef(env, result);
}
*******************************************************************************/
-void DeleteLocalRef(JNIEnv *env, jobject localRef)
+void _Jv_JNI_DeleteLocalRef(JNIEnv *env, jobject localRef)
{
java_objectheader *o;
localref_table *lrt;
*******************************************************************************/
-jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
+jboolean _Jv_JNI_IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jobject NewLocalRef(JNIEnv *env, jobject ref)
+jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref)
{
localref_table *lrt;
s4 i;
but for compatibility reasons... */
if (lrt->used == lrt->capacity) {
- if (EnsureLocalCapacity(env, 16) != 0)
+ if (_Jv_JNI_EnsureLocalCapacity(env, 16) != 0)
return NULL;
/* get the new local reference table */
*******************************************************************************/
-jint EnsureLocalCapacity(JNIEnv* env, jint capacity)
+jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity)
{
localref_table *lrt;
- log_text("JNI-Call: EnsureLocalCapacity");
-
STATISTICS(jniinvokation());
/* get local reference table (thread specific) */
/* check if capacity elements are available in the local references table */
if ((lrt->used + capacity) > lrt->capacity)
- return PushLocalFrame(env, capacity);
+ return _Jv_JNI_PushLocalFrame(env, capacity);
return 0;
}
*******************************************************************************/
-jobject AllocObject(JNIEnv *env, jclass clazz)
+jobject _Jv_JNI_AllocObject(JNIEnv *env, jclass clazz)
{
classinfo *c;
java_objectheader *o;
c = (classinfo *) clazz;
if ((c->flags & ACC_INTERFACE) || (c->flags & ACC_ABSTRACT)) {
- *exceptionptr =
- new_exception_utfmessage(string_java_lang_InstantiationException,
- c->name);
+ exceptions_throw_instantiationexception(c);
return NULL;
}
o = builtin_new(c);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
*******************************************************************************/
-jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jobject _Jv_JNI_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
java_objectheader *o;
methodinfo *m;
_Jv_jni_CallVoidMethod(o, o->vftbl, m, ap);
va_end(ap);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
*******************************************************************************/
-jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
+jobject _Jv_JNI_NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
_Jv_jni_CallVoidMethod(o, o->vftbl, m, args);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
*******************************************************************************/
-jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
+jobject _Jv_JNI_NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID,
+ jvalue *args)
{
java_objectheader *o;
methodinfo *m;
_Jv_jni_CallVoidMethodA(o, o->vftbl, m, args);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
*******************************************************************************/
-jclass GetObjectClass(JNIEnv *env, jobject obj)
+jclass _Jv_JNI_GetObjectClass(JNIEnv *env, jobject obj)
{
java_objectheader *o;
classinfo *c;
c = o->vftbl->class;
- return (jclass) NewLocalRef(env, (jobject) c);
+ return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
}
*******************************************************************************/
-jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
+jboolean _Jv_JNI_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
{
+ java_lang_Class *c;
+ java_lang_Object *o;
+
STATISTICS(jniinvokation());
- return Java_java_lang_VMClass_isInstance(env,
- NULL,
- (java_lang_Class *) clazz,
- (java_lang_Object *) obj);
+ c = (java_lang_Class *) clazz;
+ o = (java_lang_Object *) obj;
+
+ return _Jv_java_lang_Class_isInstance(c, o);
}
*******************************************************************************/
-jmethodID FromReflectedMethod(JNIEnv *env, jobject method)
+jmethodID _Jv_JNI_FromReflectedMethod(JNIEnv *env, jobject method)
{
+#if defined(ENABLE_JAVASE)
methodinfo *mi;
classinfo *c;
s4 slot;
rm = (java_lang_reflect_Method *) method;
c = (classinfo *) (rm->declaringClass);
slot = rm->slot;
-
- } else if (builtin_instanceof(method, class_java_lang_reflect_Constructor)) {
+ }
+ 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
+ }
+ else
return NULL;
mi = &(c->methods[slot]);
return (jmethodID) mi;
+#else
+ vm_abort("_Jv_JNI_FromReflectedMethod: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-jfieldID FromReflectedField(JNIEnv* env, jobject field)
+jfieldID _Jv_JNI_FromReflectedField(JNIEnv* env, jobject field)
{
+#if defined(ENABLE_JAVASE)
java_lang_reflect_Field *rf;
classinfo *c;
fieldinfo *f;
f = &(c->fields[rf->slot]);
return (jfieldID) f;
+#else
+ vm_abort("_Jv_JNI_FromReflectedField: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
+jobject _Jv_JNI_ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID,
+ jboolean isStatic)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
- jboolean isStatic)
+jobject _Jv_JNI_ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
+ jboolean isStatic)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name,
- const char *sig)
+jmethodID _Jv_JNI_GetMethodID(JNIEnv* env, jclass clazz, const char *name,
+ const char *sig)
{
classinfo *c;
utf *uname;
/* JNI-functions for calling instance methods *********************************/
-jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jobject _Jv_JNI_CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
java_objectheader *o;
methodinfo *m;
ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, ap);
va_end(ap);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, ret);
}
-jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jobject _Jv_JNI_CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
ret = _Jv_jni_CallObjectMethod(o, o->vftbl, m, args);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, ret);
}
-jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jobject _Jv_JNI_CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
java_objectheader *o;
methodinfo *m;
ret = _Jv_jni_CallObjectMethodA(o, o->vftbl, m, args);
- return NewLocalRef(env, ret);
+ return _Jv_JNI_NewLocalRef(env, ret);
}
-jboolean CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jboolean _Jv_JNI_CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
java_objectheader *o;
methodinfo *m;
}
-jboolean CallBooleanMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jboolean _Jv_JNI_CallBooleanMethodV(JNIEnv *env, jobject obj,
+ jmethodID methodID, va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jboolean CallBooleanMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jboolean _Jv_JNI_CallBooleanMethodA(JNIEnv *env, jobject obj,
+ jmethodID methodID, jvalue *args)
{
java_objectheader *o;
methodinfo *m;
}
-jbyte CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jbyte _Jv_JNI_CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
java_objectheader *o;
methodinfo *m;
}
-jbyte CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+
+jbyte _Jv_JNI_CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jbyte _Jv_JNI_CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallByteMethodA: IMPLEMENT ME!");
}
-jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jchar _Jv_JNI_CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
java_objectheader *o;
methodinfo *m;
}
-jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jchar _Jv_JNI_CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jchar _Jv_JNI_CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallCharMethodA: IMPLEMENT ME!");
}
-jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jshort _Jv_JNI_CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
java_objectheader *o;
methodinfo *m;
}
-jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jshort _Jv_JNI_CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jshort _Jv_JNI_CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallShortMethodA: IMPLEMENT ME!");
-jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jint _Jv_JNI_CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
java_objectheader *o;
methodinfo *m;
}
-jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jint _Jv_JNI_CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jint _Jv_JNI_CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallIntMethodA: IMPLEMENT ME!");
-jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jlong _Jv_JNI_CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
java_objectheader *o;
methodinfo *m;
}
-jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jlong _Jv_JNI_CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jlong _Jv_JNI_CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallLongMethodA: IMPLEMENT ME!");
-jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jfloat _Jv_JNI_CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
java_objectheader *o;
methodinfo *m;
}
-jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jfloat _Jv_JNI_CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jfloat _Jv_JNI_CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallFloatMethodA: IMPLEMENT ME!");
-jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+jdouble _Jv_JNI_CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID,
+ ...)
{
java_objectheader *o;
methodinfo *m;
}
-jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+jdouble _Jv_JNI_CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+jdouble _Jv_JNI_CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallDoubleMethodA: IMPLEMENT ME!");
-void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
+void _Jv_JNI_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
java_objectheader *o;
methodinfo *m;
}
-void CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+void _Jv_JNI_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
methodinfo *m;
}
-void CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
+void _Jv_JNI_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
+ jvalue *args)
{
java_objectheader *o;
methodinfo *m;
-jobject CallNonvirtualObjectMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jobject _Jv_JNI_CallNonvirtualObjectMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ ...)
{
java_objectheader *o;
classinfo *c;
r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, ap);
va_end(ap);
- return NewLocalRef(env, r);
+ return _Jv_JNI_NewLocalRef(env, r);
}
-jobject CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jobject _Jv_JNI_CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
classinfo *c;
r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, args);
- return NewLocalRef(env, r);
+ return _Jv_JNI_NewLocalRef(env, r);
}
-jobject CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jobject _Jv_JNI_CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!");
- return NewLocalRef(env, NULL);
+ return _Jv_JNI_NewLocalRef(env, NULL);
}
-jboolean CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jboolean _Jv_JNI_CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ ...)
{
java_objectheader *o;
classinfo *c;
}
-jboolean CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jboolean _Jv_JNI_CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jboolean CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jboolean _Jv_JNI_CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualBooleanMethodA: IMPLEMENT ME!");
}
-jbyte CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jbyte _Jv_JNI_CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
java_objectheader *o;
classinfo *c;
}
-jbyte CallNonvirtualByteMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jbyte _Jv_JNI_CallNonvirtualByteMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jbyte CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jbyte _Jv_JNI_CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualByteMethodA: IMPLEMENT ME!");
-jchar CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jchar _Jv_JNI_CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
java_objectheader *o;
classinfo *c;
}
-jchar CallNonvirtualCharMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jchar _Jv_JNI_CallNonvirtualCharMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jchar CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jchar _Jv_JNI_CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualCharMethodA: IMPLEMENT ME!");
-jshort CallNonvirtualShortMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jshort _Jv_JNI_CallNonvirtualShortMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID, ...)
{
java_objectheader *o;
classinfo *c;
}
-jshort CallNonvirtualShortMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jshort _Jv_JNI_CallNonvirtualShortMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jshort CallNonvirtualShortMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jshort _Jv_JNI_CallNonvirtualShortMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualShortMethodA: IMPLEMENT ME!");
-jint CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jint _Jv_JNI_CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
java_objectheader *o;
classinfo *c;
}
-jint CallNonvirtualIntMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jint _Jv_JNI_CallNonvirtualIntMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jint CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jint _Jv_JNI_CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualIntMethodA: IMPLEMENT ME!");
-jlong CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jlong _Jv_JNI_CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
java_objectheader *o;
classinfo *c;
}
-jlong CallNonvirtualLongMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jlong _Jv_JNI_CallNonvirtualLongMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jlong CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jlong _Jv_JNI_CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallNonvirtualLongMethodA: IMPLEMENT ME!");
-jfloat CallNonvirtualFloatMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jfloat _Jv_JNI_CallNonvirtualFloatMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID, ...)
{
java_objectheader *o;
classinfo *c;
}
-jfloat CallNonvirtualFloatMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jfloat _Jv_JNI_CallNonvirtualFloatMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jfloat CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jfloat _Jv_JNI_CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualFloatMethodA: IMPLEMENT ME!");
-jdouble CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jdouble _Jv_JNI_CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ ...)
{
java_objectheader *o;
classinfo *c;
}
-jdouble CallNonvirtualDoubleMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+jdouble _Jv_JNI_CallNonvirtualDoubleMethodV(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ va_list args)
{
java_objectheader *o;
classinfo *c;
}
-jdouble CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jdouble _Jv_JNI_CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj,
+ jclass clazz, jmethodID methodID,
+ jvalue *args)
{
log_text("JNI-Call: CallNonvirtualDoubleMethodA: IMPLEMENT ME!");
-void CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+void _Jv_JNI_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, ...)
{
java_objectheader *o;
classinfo *c;
}
-void CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+void _Jv_JNI_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, va_list args)
{
java_objectheader *o;
classinfo *c;
}
-void CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
+void _Jv_JNI_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz,
+ jmethodID methodID, jvalue * args)
{
java_objectheader *o;
classinfo *c;
*******************************************************************************/
-jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name,
- const char *sig)
+jfieldID _Jv_JNI_GetFieldID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
+ classinfo *c;
fieldinfo *f;
utf *uname;
utf *udesc;
STATISTICS(jniinvokation());
+ c = (classinfo *) clazz;
+
uname = utf_new_char((char *) name);
udesc = utf_new_char((char *) sig);
f = class_findfield(clazz, uname, udesc);
- if (!f)
- *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
+ if (f == NULL)
+ exceptions_throw_nosuchfielderror(c, uname);
return (jfieldID) f;
}
*******************************************************************************/
-jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jobject _Jv_JNI_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
java_objectheader *o;
o = GET_FIELD(obj, java_objectheader*, fieldID);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jboolean _Jv_JNI_GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jbyte GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jbyte _Jv_JNI_GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jchar GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jchar _Jv_JNI_GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jshort GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jshort _Jv_JNI_GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s4 i;
}
-jint GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jint _Jv_JNI_GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
java_objectheader *o;
fieldinfo *f;
}
-jlong GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jlong _Jv_JNI_GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
s8 l;
}
-jfloat GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jfloat _Jv_JNI_GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
float f;
}
-jdouble GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID)
+jdouble _Jv_JNI_GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
double d;
*******************************************************************************/
-void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)
+void _Jv_JNI_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jobject value)
{
STATISTICS(jniinvokation());
}
-void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value)
+void _Jv_JNI_SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jboolean value)
{
STATISTICS(jniinvokation());
}
-void SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value)
+void _Jv_JNI_SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jbyte value)
{
STATISTICS(jniinvokation());
}
-void SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value)
+void _Jv_JNI_SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jchar value)
{
STATISTICS(jniinvokation());
}
-void SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value)
+void _Jv_JNI_SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jshort value)
{
STATISTICS(jniinvokation());
}
-void SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value)
+void _Jv_JNI_SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value)
{
STATISTICS(jniinvokation());
}
-void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value)
+void _Jv_JNI_SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jlong value)
{
STATISTICS(jniinvokation());
}
-void SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value)
+void _Jv_JNI_SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jfloat value)
{
STATISTICS(jniinvokation());
}
-void SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value)
+void _Jv_JNI_SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID,
+ jdouble value)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
- const char *sig)
+jmethodID _Jv_JNI_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
classinfo *c;
utf *uname;
}
-jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jobject _Jv_JNI_CallStaticObjectMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
java_objectheader *o;
o = _Jv_jni_CallObjectMethod(NULL, NULL, m, ap);
va_end(ap);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jobject _Jv_JNI_CallStaticObjectMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
java_objectheader *o;
o = _Jv_jni_CallObjectMethod(NULL, NULL, m, args);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jobject _Jv_JNI_CallStaticObjectMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
methodinfo *m;
java_objectheader *o;
o = _Jv_jni_CallObjectMethodA(NULL, NULL, m, args);
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jboolean _Jv_JNI_CallStaticBooleanMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jboolean _Jv_JNI_CallStaticBooleanMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jboolean b;
}
-jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jboolean _Jv_JNI_CallStaticBooleanMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticBooleanMethodA: IMPLEMENT ME!");
}
-jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jbyte _Jv_JNI_CallStaticByteMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jbyte _Jv_JNI_CallStaticByteMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jbyte b;
}
-jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jbyte _Jv_JNI_CallStaticByteMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticByteMethodA: IMPLEMENT ME!");
}
-jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jchar _Jv_JNI_CallStaticCharMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jchar _Jv_JNI_CallStaticCharMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jchar c;
}
-jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jchar _Jv_JNI_CallStaticCharMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticCharMethodA: IMPLEMENT ME!");
}
-jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jshort _Jv_JNI_CallStaticShortMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jshort _Jv_JNI_CallStaticShortMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jshort s;
}
-jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jshort _Jv_JNI_CallStaticShortMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticShortMethodA: IMPLEMENT ME!");
}
-jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jint _Jv_JNI_CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
+ ...)
{
methodinfo *m;
va_list ap;
}
-jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jint _Jv_JNI_CallStaticIntMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jint i;
}
-jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jint _Jv_JNI_CallStaticIntMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticIntMethodA: IMPLEMENT ME!");
}
-jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jlong _Jv_JNI_CallStaticLongMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
- va_list args)
+jlong _Jv_JNI_CallStaticLongMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jlong l;
}
-jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jlong _Jv_JNI_CallStaticLongMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!");
-jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jfloat _Jv_JNI_CallStaticFloatMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jfloat _Jv_JNI_CallStaticFloatMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jfloat f;
}
-jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jfloat _Jv_JNI_CallStaticFloatMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticFloatMethodA: IMPLEMENT ME!");
}
-jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+jdouble _Jv_JNI_CallStaticDoubleMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+jdouble _Jv_JNI_CallStaticDoubleMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
jdouble d;
}
-jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
+jdouble _Jv_JNI_CallStaticDoubleMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue *args)
{
log_text("JNI-Call: CallStaticDoubleMethodA: IMPLEMENT ME!");
}
-void CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
+void _Jv_JNI_CallStaticVoidMethod(JNIEnv *env, jclass clazz,
+ jmethodID methodID, ...)
{
methodinfo *m;
va_list ap;
}
-void CallStaticVoidMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
+void _Jv_JNI_CallStaticVoidMethodV(JNIEnv *env, jclass clazz,
+ jmethodID methodID, va_list args)
{
methodinfo *m;
}
-void CallStaticVoidMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args)
+void _Jv_JNI_CallStaticVoidMethodA(JNIEnv *env, jclass clazz,
+ jmethodID methodID, jvalue * args)
{
methodinfo *m;
*******************************************************************************/
-jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
+jfieldID _Jv_JNI_GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
+ classinfo *c;
fieldinfo *f;
+ utf *uname;
+ utf *usig;
STATISTICS(jniinvokation());
- f = class_findfield(clazz,
- utf_new_char((char *) name),
- utf_new_char((char *) sig));
+ c = (classinfo *) clazz;
+
+ uname = utf_new_char((char *) name);
+ usig = utf_new_char((char *) sig);
+
+ f = class_findfield(clazz, uname, usig);
if (f == NULL)
- *exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
+ exceptions_throw_nosuchfielderror(c, uname);
return (jfieldID) f;
}
*******************************************************************************/
-jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jobject _Jv_JNI_GetStaticObjectField(JNIEnv *env, jclass clazz,
+ jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
if (!initialize_class(c))
return NULL;
- return NewLocalRef(env, f->value.a);
+ return _Jv_JNI_NewLocalRef(env, f->value.a);
}
-jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jboolean _Jv_JNI_GetStaticBooleanField(JNIEnv *env, jclass clazz,
+ jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
}
-jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jbyte _Jv_JNI_GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
}
-jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jchar _Jv_JNI_GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
}
-jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jshort _Jv_JNI_GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
}
-jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jint _Jv_JNI_GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
}
-jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jlong _Jv_JNI_GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
}
-jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jfloat _Jv_JNI_GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
}
-jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID)
+jdouble _Jv_JNI_GetStaticDoubleField(JNIEnv *env, jclass clazz,
+ jfieldID fieldID)
{
classinfo *c;
fieldinfo *f;
*******************************************************************************/
-void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
+void _Jv_JNI_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jobject value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
+void _Jv_JNI_SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jboolean value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
+void _Jv_JNI_SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jbyte value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
+void _Jv_JNI_SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jchar value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
+void _Jv_JNI_SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jshort value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
+void _Jv_JNI_SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jint value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
+void _Jv_JNI_SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jlong value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
+void _Jv_JNI_SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jfloat value)
{
classinfo *c;
fieldinfo *f;
}
-void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
+void _Jv_JNI_SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID,
+ jdouble value)
{
classinfo *c;
fieldinfo *f;
*******************************************************************************/
-jstring NewString(JNIEnv *env, const jchar *buf, jsize len)
+jstring _Jv_JNI_NewString(JNIEnv *env, const jchar *buf, jsize len)
{
java_lang_String *s;
java_chararray *a;
a = builtin_newarray_char(len);
/* javastring or characterarray could not be created */
- if (!a || !s)
+ if ((a == NULL) || (s == NULL))
return NULL;
/* copy text */
for (i = 0; i < len; i++)
a->data[i] = buf[i];
- s->value = a;
+ s->value = a;
s->offset = 0;
- s->count = len;
+ s->count = len;
- return (jstring) NewLocalRef(env, (jobject) s);
+ return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
}
*******************************************************************************/
-jsize GetStringLength(JNIEnv *env, jstring str)
+jsize _Jv_JNI_GetStringLength(JNIEnv *env, jstring str)
{
return ((java_lang_String *) str)->count;
}
/* GetStringChars **************************************************************
Returns a pointer to the array of Unicode characters of the
- string. This pointer is valid until ReleaseStringchars() is called.
+ string. This pointer is valid until ReleaseStringChars() is called.
*******************************************************************************/
-const jchar *GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
+const jchar *_Jv_JNI_GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
{
jchar *jc;
*******************************************************************************/
-void ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
+void _Jv_JNI_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
{
STATISTICS(jniinvokation());
/* NewStringUTF ****************************************************************
- Constructs a new java.lang.String object from an array of UTF-8 characters.
+ Constructs a new java.lang.String object from an array of UTF-8
+ characters.
*******************************************************************************/
-jstring NewStringUTF(JNIEnv *env, const char *bytes)
+jstring _Jv_JNI_NewStringUTF(JNIEnv *env, const char *bytes)
{
java_lang_String *s;
STATISTICS(jniinvokation());
- s = javastring_new(utf_new_char(bytes));
+ s = (java_lang_String *) javastring_safe_new_from_utf8(bytes);
- return (jstring) NewLocalRef(env, (jobject) s);
+ return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
}
/****************** returns the utf8 length in bytes of a string *******************/
-jsize GetStringUTFLength (JNIEnv *env, jstring string)
+jsize _Jv_JNI_GetStringUTFLength (JNIEnv *env, jstring string)
{
java_lang_String *s = (java_lang_String*) string;
*******************************************************************************/
-const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
+const char *_Jv_JNI_GetStringUTFChars(JNIEnv *env, jstring string,
+ jboolean *isCopy)
{
utf *u;
STATISTICS(jniinvokation());
- if (!string)
+ if (string == NULL)
return "";
if (isCopy)
*isCopy = JNI_TRUE;
- u = javastring_toutf((java_lang_String *) string, false);
+ u = javastring_toutf((java_objectheader *) string, false);
- if (u)
+ if (u != NULL)
return u->text;
return "";
*******************************************************************************/
-void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
+void _Jv_JNI_ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jsize GetArrayLength(JNIEnv *env, jarray array)
+jsize _Jv_JNI_GetArrayLength(JNIEnv *env, jarray array)
{
java_arrayheader *a;
*******************************************************************************/
-jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)
+jobjectArray _Jv_JNI_NewObjectArray(JNIEnv *env, jsize length,
+ jclass elementClass, jobject initialElement)
{
java_objectarray *oa;
s4 i;
oa = builtin_anewarray(length, elementClass);
- if (!oa)
+ if (oa == NULL)
return NULL;
/* set all elements to initialElement */
for (i = 0; i < length; i++)
oa->data[i] = initialElement;
- return (jobjectArray) NewLocalRef(env, (jobject) oa);
+ return (jobjectArray) _Jv_JNI_NewLocalRef(env, (jobject) oa);
}
-jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
+jobject _Jv_JNI_GetObjectArrayElement(JNIEnv *env, jobjectArray array,
+ jsize index)
{
java_objectarray *oa;
jobject o;
o = oa->data[index];
- return NewLocalRef(env, o);
+ return _Jv_JNI_NewLocalRef(env, o);
}
-void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
+void _Jv_JNI_SetObjectArrayElement(JNIEnv *env, jobjectArray array,
+ jsize index, jobject val)
{
java_objectarray *oa;
java_objectheader *o;
/* check if the class of value is a subclass of the element class
of the array */
- if (!builtin_canstore(oa, o)) {
- *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
-
+ if (!builtin_canstore(oa, o))
return;
- }
oa->data[index] = val;
}
-jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
+jbooleanArray _Jv_JNI_NewBooleanArray(JNIEnv *env, jsize len)
{
java_booleanarray *ba;
ba = builtin_newarray_boolean(len);
- return (jbooleanArray) NewLocalRef(env, (jobject) ba);
+ return (jbooleanArray) _Jv_JNI_NewLocalRef(env, (jobject) ba);
}
-jbyteArray NewByteArray(JNIEnv *env, jsize len)
+jbyteArray _Jv_JNI_NewByteArray(JNIEnv *env, jsize len)
{
java_bytearray *ba;
ba = builtin_newarray_byte(len);
- return (jbyteArray) NewLocalRef(env, (jobject) ba);
+ return (jbyteArray) _Jv_JNI_NewLocalRef(env, (jobject) ba);
}
-jcharArray NewCharArray(JNIEnv *env, jsize len)
+jcharArray _Jv_JNI_NewCharArray(JNIEnv *env, jsize len)
{
java_chararray *ca;
ca = builtin_newarray_char(len);
- return (jcharArray) NewLocalRef(env, (jobject) ca);
+ return (jcharArray) _Jv_JNI_NewLocalRef(env, (jobject) ca);
}
-jshortArray NewShortArray(JNIEnv *env, jsize len)
+jshortArray _Jv_JNI_NewShortArray(JNIEnv *env, jsize len)
{
java_shortarray *sa;
sa = builtin_newarray_short(len);
- return (jshortArray) NewLocalRef(env, (jobject) sa);
+ return (jshortArray) _Jv_JNI_NewLocalRef(env, (jobject) sa);
}
-jintArray NewIntArray(JNIEnv *env, jsize len)
+jintArray _Jv_JNI_NewIntArray(JNIEnv *env, jsize len)
{
java_intarray *ia;
ia = builtin_newarray_int(len);
- return (jintArray) NewLocalRef(env, (jobject) ia);
+ return (jintArray) _Jv_JNI_NewLocalRef(env, (jobject) ia);
}
-jlongArray NewLongArray(JNIEnv *env, jsize len)
+jlongArray _Jv_JNI_NewLongArray(JNIEnv *env, jsize len)
{
java_longarray *la;
la = builtin_newarray_long(len);
- return (jlongArray) NewLocalRef(env, (jobject) la);
+ return (jlongArray) _Jv_JNI_NewLocalRef(env, (jobject) la);
}
-jfloatArray NewFloatArray(JNIEnv *env, jsize len)
+jfloatArray _Jv_JNI_NewFloatArray(JNIEnv *env, jsize len)
{
java_floatarray *fa;
fa = builtin_newarray_float(len);
- return (jfloatArray) NewLocalRef(env, (jobject) fa);
+ return (jfloatArray) _Jv_JNI_NewLocalRef(env, (jobject) fa);
}
-jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
+jdoubleArray _Jv_JNI_NewDoubleArray(JNIEnv *env, jsize len)
{
java_doublearray *da;
da = builtin_newarray_double(len);
- return (jdoubleArray) NewLocalRef(env, (jobject) da);
+ return (jdoubleArray) _Jv_JNI_NewLocalRef(env, (jobject) da);
}
*******************************************************************************/
-jboolean *GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
- jboolean *isCopy)
+jboolean *_Jv_JNI_GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
+ jboolean *isCopy)
{
java_booleanarray *ba;
}
-jbyte *GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy)
+jbyte *_Jv_JNI_GetByteArrayElements(JNIEnv *env, jbyteArray array,
+ jboolean *isCopy)
{
java_bytearray *ba;
}
-jchar *GetCharArrayElements(JNIEnv *env, jcharArray array, jboolean *isCopy)
+jchar *_Jv_JNI_GetCharArrayElements(JNIEnv *env, jcharArray array,
+ jboolean *isCopy)
{
java_chararray *ca;
}
-jshort *GetShortArrayElements(JNIEnv *env, jshortArray array, jboolean *isCopy)
+jshort *_Jv_JNI_GetShortArrayElements(JNIEnv *env, jshortArray array,
+ jboolean *isCopy)
{
java_shortarray *sa;
}
-jint *GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy)
+jint *_Jv_JNI_GetIntArrayElements(JNIEnv *env, jintArray array,
+ jboolean *isCopy)
{
java_intarray *ia;
}
-jlong *GetLongArrayElements(JNIEnv *env, jlongArray array, jboolean *isCopy)
+jlong *_Jv_JNI_GetLongArrayElements(JNIEnv *env, jlongArray array,
+ jboolean *isCopy)
{
java_longarray *la;
}
-jfloat *GetFloatArrayElements(JNIEnv *env, jfloatArray array, jboolean *isCopy)
+jfloat *_Jv_JNI_GetFloatArrayElements(JNIEnv *env, jfloatArray array,
+ jboolean *isCopy)
{
java_floatarray *fa;
}
-jdouble *GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
- jboolean *isCopy)
+jdouble *_Jv_JNI_GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
+ jboolean *isCopy)
{
java_doublearray *da;
*******************************************************************************/
-void ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array,
- jboolean *elems, jint mode)
+void _Jv_JNI_ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array,
+ jboolean *elems, jint mode)
{
java_booleanarray *ba;
}
-void ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, jbyte *elems,
- jint mode)
+void _Jv_JNI_ReleaseByteArrayElements(JNIEnv *env, jbyteArray array,
+ jbyte *elems, jint mode)
{
java_bytearray *ba;
}
-void ReleaseCharArrayElements(JNIEnv *env, jcharArray array, jchar *elems,
- jint mode)
+void _Jv_JNI_ReleaseCharArrayElements(JNIEnv *env, jcharArray array,
+ jchar *elems, jint mode)
{
java_chararray *ca;
}
-void ReleaseShortArrayElements(JNIEnv *env, jshortArray array, jshort *elems,
- jint mode)
+void _Jv_JNI_ReleaseShortArrayElements(JNIEnv *env, jshortArray array,
+ jshort *elems, jint mode)
{
java_shortarray *sa;
}
-void ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems,
- jint mode)
+void _Jv_JNI_ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems,
+ jint mode)
{
java_intarray *ia;
}
-void ReleaseLongArrayElements(JNIEnv *env, jlongArray array, jlong *elems,
- jint mode)
+void _Jv_JNI_ReleaseLongArrayElements(JNIEnv *env, jlongArray array,
+ jlong *elems, jint mode)
{
java_longarray *la;
}
-void ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array, jfloat *elems,
- jint mode)
+void _Jv_JNI_ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array,
+ jfloat *elems, jint mode)
{
java_floatarray *fa;
}
-void ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array,
- jdouble *elems, jint mode)
+void _Jv_JNI_ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array,
+ jdouble *elems, jint mode)
{
java_doublearray *da;
*******************************************************************************/
-void GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
- jsize len, jboolean *buf)
+void _Jv_JNI_GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array,
+ jsize start, jsize len, jboolean *buf)
{
java_booleanarray *ba;
}
-void GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
- jbyte *buf)
+void _Jv_JNI_GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start,
+ jsize len, jbyte *buf)
{
java_bytearray *ba;
}
-void GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
- jchar *buf)
+void _Jv_JNI_GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start,
+ jsize len, jchar *buf)
{
java_chararray *ca;
}
-void GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
- jsize len, jshort *buf)
+void _Jv_JNI_GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
+ jsize len, jshort *buf)
{
java_shortarray *sa;
}
-void GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
- jint *buf)
+void _Jv_JNI_GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start,
+ jsize len, jint *buf)
{
java_intarray *ia;
}
-void GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start, jsize len,
- jlong *buf)
+void _Jv_JNI_GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start,
+ jsize len, jlong *buf)
{
java_longarray *la;
}
-void GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
- jsize len, jfloat *buf)
+void _Jv_JNI_GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
+ jsize len, jfloat *buf)
{
java_floatarray *fa;
}
-void GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
- jsize len, jdouble *buf)
+void _Jv_JNI_GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
+ jsize len, jdouble *buf)
{
java_doublearray *da;
*******************************************************************************/
-void SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
- jsize len, jboolean *buf)
+void _Jv_JNI_SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array,
+ jsize start, jsize len, jboolean *buf)
{
java_booleanarray *ba;
}
-void SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
- jbyte *buf)
+void _Jv_JNI_SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start,
+ jsize len, jbyte *buf)
{
java_bytearray *ba;
}
-void SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
- jchar *buf)
+void _Jv_JNI_SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start,
+ jsize len, jchar *buf)
{
java_chararray *ca;
}
-void SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
- jsize len, jshort *buf)
+void _Jv_JNI_SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
+ jsize len, jshort *buf)
{
java_shortarray *sa;
}
-void SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
- jint *buf)
+void _Jv_JNI_SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start,
+ jsize len, jint *buf)
{
java_intarray *ia;
}
-void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len,
- jlong *buf)
+void _Jv_JNI_SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start,
+ jsize len, jlong *buf)
{
java_longarray *la;
}
-void SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
- jsize len, jfloat *buf)
+void _Jv_JNI_SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
+ jsize len, jfloat *buf)
{
java_floatarray *fa;
}
-void SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
- jsize len, jdouble *buf)
+void _Jv_JNI_SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
+ jsize len, jdouble *buf)
{
java_doublearray *da;
*******************************************************************************/
-jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
- jint nMethods)
+jint _Jv_JNI_RegisterNatives(JNIEnv *env, jclass clazz,
+ const JNINativeMethod *methods, jint nMethods)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jint UnregisterNatives(JNIEnv *env, jclass clazz)
+jint _Jv_JNI_UnregisterNatives(JNIEnv *env, jclass clazz)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jint MonitorEnter(JNIEnv *env, jobject obj)
+jint _Jv_JNI_MonitorEnter(JNIEnv *env, jobject obj)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jint MonitorExit(JNIEnv *env, jobject obj)
+jint _Jv_JNI_MonitorExit(JNIEnv *env, jobject obj)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jint GetJavaVM(JNIEnv *env, JavaVM **vm)
+jint _Jv_JNI_GetJavaVM(JNIEnv *env, JavaVM **vm)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-void GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
+void _Jv_JNI_GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len,
+ jchar *buf)
{
java_lang_String *s;
java_chararray *ca;
}
-void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
+void _Jv_JNI_GetStringUTFRegion(JNIEnv* env, jstring str, jsize start,
+ jsize len, char *buf)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)
+void *_Jv_JNI_GetPrimitiveArrayCritical(JNIEnv *env, jarray array,
+ jboolean *isCopy)
{
java_bytearray *ba;
jbyte *bp;
/* do the same as Kaffe does */
- bp = GetByteArrayElements(env, ba, isCopy);
+ bp = _Jv_JNI_GetByteArrayElements(env, ba, isCopy);
return (void *) bp;
}
*******************************************************************************/
-void ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray,
- jint mode)
+void _Jv_JNI_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array,
+ void *carray, jint mode)
{
STATISTICS(jniinvokation());
/* do the same as Kaffe does */
- ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray, mode);
+ _Jv_JNI_ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray,
+ mode);
}
*******************************************************************************/
-const jchar *GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)
+const jchar *_Jv_JNI_GetStringCritical(JNIEnv *env, jstring string,
+ jboolean *isCopy)
{
STATISTICS(jniinvokation());
- return GetStringChars(env, string, isCopy);
+ return _Jv_JNI_GetStringChars(env, string, isCopy);
}
-void ReleaseStringCritical(JNIEnv *env, jstring string, const jchar *cstring)
+void _Jv_JNI_ReleaseStringCritical(JNIEnv *env, jstring string,
+ const jchar *cstring)
{
STATISTICS(jniinvokation());
- ReleaseStringChars(env, string, cstring);
+ _Jv_JNI_ReleaseStringChars(env, string, cstring);
}
-jweak NewWeakGlobalRef(JNIEnv* env, jobject obj)
+jweak _Jv_JNI_NewWeakGlobalRef(JNIEnv* env, jobject obj)
{
STATISTICS(jniinvokation());
}
-void DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
+void _Jv_JNI_DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
{
STATISTICS(jniinvokation());
*******************************************************************************/
-jobject NewGlobalRef(JNIEnv* env, jobject obj)
+jobject _Jv_JNI_NewGlobalRef(JNIEnv* env, jobject obj)
{
hashtable_global_ref_entry *gre;
u4 key; /* hashkey */
*******************************************************************************/
-void DeleteGlobalRef(JNIEnv* env, jobject globalRef)
+void _Jv_JNI_DeleteGlobalRef(JNIEnv* env, jobject globalRef)
{
hashtable_global_ref_entry *gre;
hashtable_global_ref_entry *prevgre;
*******************************************************************************/
-jboolean ExceptionCheck(JNIEnv *env)
+jboolean _Jv_JNI_ExceptionCheck(JNIEnv *env)
{
+ java_objectheader *o;
+
STATISTICS(jniinvokation());
- return *exceptionptr ? JNI_TRUE : JNI_FALSE;
+ o = exceptions_get_exception();
+
+ return (o != NULL) ? JNI_TRUE : JNI_FALSE;
}
*******************************************************************************/
-jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
+jobject _Jv_JNI_NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
{
+#if defined(ENABLE_JAVASE)
java_objectheader *nbuf;
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
gnu_classpath_Pointer64 *paddress;
-#else
+# else
gnu_classpath_Pointer32 *paddress;
-#endif
+# endif
STATISTICS(jniinvokation());
/* alocate a gnu.classpath.Pointer{32,64} object */
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
if (!(paddress = (gnu_classpath_Pointer64 *)
builtin_new(class_gnu_classpath_Pointer64)))
-#else
+# else
if (!(paddress = (gnu_classpath_Pointer32 *)
builtin_new(class_gnu_classpath_Pointer32)))
-#endif
+# endif
return NULL;
/* fill gnu.classpath.Pointer{32,64} with address */
/* add local reference and return the value */
- return NewLocalRef(env, nbuf);
+ return _Jv_JNI_NewLocalRef(env, nbuf);
+#else
+ vm_abort("_Jv_JNI_NewDirectByteBuffer: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-void *GetDirectBufferAddress(JNIEnv *env, jobject buf)
+void *_Jv_JNI_GetDirectBufferAddress(JNIEnv *env, jobject buf)
{
+#if defined(ENABLE_JAVASE)
java_nio_DirectByteBufferImpl *nbuf;
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
gnu_classpath_Pointer64 *address;
-#else
+# else
gnu_classpath_Pointer32 *address;
-#endif
+# endif
STATISTICS(jniinvokation());
nbuf = (java_nio_DirectByteBufferImpl *) buf;
-#if SIZEOF_VOID_P == 8
+# if SIZEOF_VOID_P == 8
address = (gnu_classpath_Pointer64 *) nbuf->address;
-#else
+# else
address = (gnu_classpath_Pointer32 *) nbuf->address;
-#endif
+# endif
if (address == NULL)
return NULL;
return (void *) address->data;
+#else
+ vm_abort("_Jv_JNI_GetDirectBufferAddress: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return NULL;
+#endif
}
*******************************************************************************/
-jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
+jlong _Jv_JNI_GetDirectBufferCapacity(JNIEnv* env, jobject buf)
{
+#if defined(ENABLE_JAVASE)
java_nio_Buffer *nbuf;
STATISTICS(jniinvokation());
nbuf = (java_nio_Buffer *) buf;
return (jlong) nbuf->cap;
+#else
+ vm_abort("_Jv_JNI_GetDirectBufferCapacity: not implemented in this configuration");
+
+ /* keep compiler happy */
+
+ return 0;
+#endif
}
*******************************************************************************/
-jint DestroyJavaVM(JavaVM *vm)
+jint _Jv_JNI_DestroyJavaVM(JavaVM *vm)
{
s4 status;
*******************************************************************************/
-jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
+static s4 jni_attach_current_thread(void **p_env, void *thr_args, bool isdaemon)
{
- STATISTICS(jniinvokation());
+ JavaVMAttachArgs *vm_aargs;
- log_text("JNI-Call: AttachCurrentThread: IMPLEMENT ME!");
+#if defined(ENABLE_THREADS)
+ if (threads_get_current_threadobject() == NULL) {
+ vm_aargs = (JavaVMAttachArgs *) thr_args;
- *env = _Jv_env;
+ if (vm_aargs != NULL) {
+ if ((vm_aargs->version != JNI_VERSION_1_2) &&
+ (vm_aargs->version != JNI_VERSION_1_4))
+ return JNI_EVERSION;
+ }
- return 0;
+ if (!threads_attach_current_thread(vm_aargs, false))
+ return JNI_ERR;
+
+ if (!jni_init_localref_table())
+ return JNI_ERR;
+ }
+#endif
+
+ *p_env = _Jv_env;
+
+ return JNI_OK;
}
-jint DetachCurrentThread(JavaVM *vm)
+jint _Jv_JNI_AttachCurrentThread(JavaVM *vm, void **p_env, void *thr_args)
{
STATISTICS(jniinvokation());
- log_text("JNI-Call: DetachCurrentThread: IMPLEMENT ME!");
+ return jni_attach_current_thread(p_env, thr_args, false);
+}
- return 0;
+
+/* DetachCurrentThread *********************************************************
+
+ Detaches the current thread from a Java VM. All Java monitors held
+ by this thread are released. All Java threads waiting for this
+ thread to die are notified.
+
+ In JDK 1.1, the main thread cannot be detached from the VM. It must
+ call DestroyJavaVM to unload the entire VM.
+
+ In the JDK, the main thread can be detached from the VM.
+
+ The main thread, which is the thread that created the Java VM,
+ cannot be detached from the VM. Instead, the main thread must call
+ JNI_DestroyJavaVM() to unload the entire VM.
+
+*******************************************************************************/
+
+jint _Jv_JNI_DetachCurrentThread(JavaVM *vm)
+{
+#if defined(ENABLE_THREADS)
+ threadobject *thread;
+
+ STATISTICS(jniinvokation());
+
+ thread = threads_get_current_threadobject();
+
+ if (thread == NULL)
+ return JNI_ERR;
+
+ if (!jni_free_localref_table())
+ return JNI_ERR;
+
+ if (!threads_detach_thread(thread))
+ return JNI_ERR;
+#endif
+
+ return JNI_OK;
}
*******************************************************************************/
-jint GetEnv(JavaVM *vm, void **env, jint version)
+jint _Jv_JNI_GetEnv(JavaVM *vm, void **env, jint version)
{
STATISTICS(jniinvokation());
}
+/* AttachCurrentThreadAsDaemon *************************************************
+
+ Same semantics as AttachCurrentThread, but the newly-created
+ java.lang.Thread instance is a daemon.
-jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
+ If the thread has already been attached via either
+ AttachCurrentThread or AttachCurrentThreadAsDaemon, this routine
+ simply sets the value pointed to by penv to the JNIEnv of the
+ current thread. In this case neither AttachCurrentThread nor this
+ routine have any effect on the daemon status of the thread.
+
+*******************************************************************************/
+
+jint _Jv_JNI_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *args)
{
STATISTICS(jniinvokation());
- log_text("JNI-Call: AttachCurrentThreadAsDaemon: IMPLEMENT ME!");
-
- return 0;
+ return jni_attach_current_thread(penv, args, true);
}
NULL,
NULL,
- DestroyJavaVM,
- AttachCurrentThread,
- DetachCurrentThread,
- GetEnv,
- AttachCurrentThreadAsDaemon
+ _Jv_JNI_DestroyJavaVM,
+ _Jv_JNI_AttachCurrentThread,
+ _Jv_JNI_DetachCurrentThread,
+ _Jv_JNI_GetEnv,
+ _Jv_JNI_AttachCurrentThreadAsDaemon
};
NULL,
NULL,
NULL,
- 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,
+ _Jv_JNI_GetVersion,
+
+ _Jv_JNI_DefineClass,
+ _Jv_JNI_FindClass,
+ _Jv_JNI_FromReflectedMethod,
+ _Jv_JNI_FromReflectedField,
+ _Jv_JNI_ToReflectedMethod,
+ _Jv_JNI_GetSuperclass,
+ _Jv_JNI_IsAssignableFrom,
+ _Jv_JNI_ToReflectedField,
+
+ _Jv_JNI_Throw,
+ _Jv_JNI_ThrowNew,
+ _Jv_JNI_ExceptionOccurred,
+ _Jv_JNI_ExceptionDescribe,
+ _Jv_JNI_ExceptionClear,
+ _Jv_JNI_FatalError,
+ _Jv_JNI_PushLocalFrame,
+ _Jv_JNI_PopLocalFrame,
+
+ _Jv_JNI_NewGlobalRef,
+ _Jv_JNI_DeleteGlobalRef,
+ _Jv_JNI_DeleteLocalRef,
+ _Jv_JNI_IsSameObject,
+ _Jv_JNI_NewLocalRef,
+ _Jv_JNI_EnsureLocalCapacity,
+
+ _Jv_JNI_AllocObject,
+ _Jv_JNI_NewObject,
+ _Jv_JNI_NewObjectV,
+ _Jv_JNI_NewObjectA,
+
+ _Jv_JNI_GetObjectClass,
+ _Jv_JNI_IsInstanceOf,
+
+ _Jv_JNI_GetMethodID,
+
+ _Jv_JNI_CallObjectMethod,
+ _Jv_JNI_CallObjectMethodV,
+ _Jv_JNI_CallObjectMethodA,
+ _Jv_JNI_CallBooleanMethod,
+ _Jv_JNI_CallBooleanMethodV,
+ _Jv_JNI_CallBooleanMethodA,
+ _Jv_JNI_CallByteMethod,
+ _Jv_JNI_CallByteMethodV,
+ _Jv_JNI_CallByteMethodA,
+ _Jv_JNI_CallCharMethod,
+ _Jv_JNI_CallCharMethodV,
+ _Jv_JNI_CallCharMethodA,
+ _Jv_JNI_CallShortMethod,
+ _Jv_JNI_CallShortMethodV,
+ _Jv_JNI_CallShortMethodA,
+ _Jv_JNI_CallIntMethod,
+ _Jv_JNI_CallIntMethodV,
+ _Jv_JNI_CallIntMethodA,
+ _Jv_JNI_CallLongMethod,
+ _Jv_JNI_CallLongMethodV,
+ _Jv_JNI_CallLongMethodA,
+ _Jv_JNI_CallFloatMethod,
+ _Jv_JNI_CallFloatMethodV,
+ _Jv_JNI_CallFloatMethodA,
+ _Jv_JNI_CallDoubleMethod,
+ _Jv_JNI_CallDoubleMethodV,
+ _Jv_JNI_CallDoubleMethodA,
+ _Jv_JNI_CallVoidMethod,
+ _Jv_JNI_CallVoidMethodV,
+ _Jv_JNI_CallVoidMethodA,
+
+ _Jv_JNI_CallNonvirtualObjectMethod,
+ _Jv_JNI_CallNonvirtualObjectMethodV,
+ _Jv_JNI_CallNonvirtualObjectMethodA,
+ _Jv_JNI_CallNonvirtualBooleanMethod,
+ _Jv_JNI_CallNonvirtualBooleanMethodV,
+ _Jv_JNI_CallNonvirtualBooleanMethodA,
+ _Jv_JNI_CallNonvirtualByteMethod,
+ _Jv_JNI_CallNonvirtualByteMethodV,
+ _Jv_JNI_CallNonvirtualByteMethodA,
+ _Jv_JNI_CallNonvirtualCharMethod,
+ _Jv_JNI_CallNonvirtualCharMethodV,
+ _Jv_JNI_CallNonvirtualCharMethodA,
+ _Jv_JNI_CallNonvirtualShortMethod,
+ _Jv_JNI_CallNonvirtualShortMethodV,
+ _Jv_JNI_CallNonvirtualShortMethodA,
+ _Jv_JNI_CallNonvirtualIntMethod,
+ _Jv_JNI_CallNonvirtualIntMethodV,
+ _Jv_JNI_CallNonvirtualIntMethodA,
+ _Jv_JNI_CallNonvirtualLongMethod,
+ _Jv_JNI_CallNonvirtualLongMethodV,
+ _Jv_JNI_CallNonvirtualLongMethodA,
+ _Jv_JNI_CallNonvirtualFloatMethod,
+ _Jv_JNI_CallNonvirtualFloatMethodV,
+ _Jv_JNI_CallNonvirtualFloatMethodA,
+ _Jv_JNI_CallNonvirtualDoubleMethod,
+ _Jv_JNI_CallNonvirtualDoubleMethodV,
+ _Jv_JNI_CallNonvirtualDoubleMethodA,
+ _Jv_JNI_CallNonvirtualVoidMethod,
+ _Jv_JNI_CallNonvirtualVoidMethodV,
+ _Jv_JNI_CallNonvirtualVoidMethodA,
+
+ _Jv_JNI_GetFieldID,
+
+ _Jv_JNI_GetObjectField,
+ _Jv_JNI_GetBooleanField,
+ _Jv_JNI_GetByteField,
+ _Jv_JNI_GetCharField,
+ _Jv_JNI_GetShortField,
+ _Jv_JNI_GetIntField,
+ _Jv_JNI_GetLongField,
+ _Jv_JNI_GetFloatField,
+ _Jv_JNI_GetDoubleField,
+ _Jv_JNI_SetObjectField,
+ _Jv_JNI_SetBooleanField,
+ _Jv_JNI_SetByteField,
+ _Jv_JNI_SetCharField,
+ _Jv_JNI_SetShortField,
+ _Jv_JNI_SetIntField,
+ _Jv_JNI_SetLongField,
+ _Jv_JNI_SetFloatField,
+ _Jv_JNI_SetDoubleField,
+
+ _Jv_JNI_GetStaticMethodID,
+
+ _Jv_JNI_CallStaticObjectMethod,
+ _Jv_JNI_CallStaticObjectMethodV,
+ _Jv_JNI_CallStaticObjectMethodA,
+ _Jv_JNI_CallStaticBooleanMethod,
+ _Jv_JNI_CallStaticBooleanMethodV,
+ _Jv_JNI_CallStaticBooleanMethodA,
+ _Jv_JNI_CallStaticByteMethod,
+ _Jv_JNI_CallStaticByteMethodV,
+ _Jv_JNI_CallStaticByteMethodA,
+ _Jv_JNI_CallStaticCharMethod,
+ _Jv_JNI_CallStaticCharMethodV,
+ _Jv_JNI_CallStaticCharMethodA,
+ _Jv_JNI_CallStaticShortMethod,
+ _Jv_JNI_CallStaticShortMethodV,
+ _Jv_JNI_CallStaticShortMethodA,
+ _Jv_JNI_CallStaticIntMethod,
+ _Jv_JNI_CallStaticIntMethodV,
+ _Jv_JNI_CallStaticIntMethodA,
+ _Jv_JNI_CallStaticLongMethod,
+ _Jv_JNI_CallStaticLongMethodV,
+ _Jv_JNI_CallStaticLongMethodA,
+ _Jv_JNI_CallStaticFloatMethod,
+ _Jv_JNI_CallStaticFloatMethodV,
+ _Jv_JNI_CallStaticFloatMethodA,
+ _Jv_JNI_CallStaticDoubleMethod,
+ _Jv_JNI_CallStaticDoubleMethodV,
+ _Jv_JNI_CallStaticDoubleMethodA,
+ _Jv_JNI_CallStaticVoidMethod,
+ _Jv_JNI_CallStaticVoidMethodV,
+ _Jv_JNI_CallStaticVoidMethodA,
+
+ _Jv_JNI_GetStaticFieldID,
+
+ _Jv_JNI_GetStaticObjectField,
+ _Jv_JNI_GetStaticBooleanField,
+ _Jv_JNI_GetStaticByteField,
+ _Jv_JNI_GetStaticCharField,
+ _Jv_JNI_GetStaticShortField,
+ _Jv_JNI_GetStaticIntField,
+ _Jv_JNI_GetStaticLongField,
+ _Jv_JNI_GetStaticFloatField,
+ _Jv_JNI_GetStaticDoubleField,
+ _Jv_JNI_SetStaticObjectField,
+ _Jv_JNI_SetStaticBooleanField,
+ _Jv_JNI_SetStaticByteField,
+ _Jv_JNI_SetStaticCharField,
+ _Jv_JNI_SetStaticShortField,
+ _Jv_JNI_SetStaticIntField,
+ _Jv_JNI_SetStaticLongField,
+ _Jv_JNI_SetStaticFloatField,
+ _Jv_JNI_SetStaticDoubleField,
+
+ _Jv_JNI_NewString,
+ _Jv_JNI_GetStringLength,
+ _Jv_JNI_GetStringChars,
+ _Jv_JNI_ReleaseStringChars,
+
+ _Jv_JNI_NewStringUTF,
+ _Jv_JNI_GetStringUTFLength,
+ _Jv_JNI_GetStringUTFChars,
+ _Jv_JNI_ReleaseStringUTFChars,
+
+ _Jv_JNI_GetArrayLength,
+
+ _Jv_JNI_NewObjectArray,
+ _Jv_JNI_GetObjectArrayElement,
+ _Jv_JNI_SetObjectArrayElement,
+
+ _Jv_JNI_NewBooleanArray,
+ _Jv_JNI_NewByteArray,
+ _Jv_JNI_NewCharArray,
+ _Jv_JNI_NewShortArray,
+ _Jv_JNI_NewIntArray,
+ _Jv_JNI_NewLongArray,
+ _Jv_JNI_NewFloatArray,
+ _Jv_JNI_NewDoubleArray,
+
+ _Jv_JNI_GetBooleanArrayElements,
+ _Jv_JNI_GetByteArrayElements,
+ _Jv_JNI_GetCharArrayElements,
+ _Jv_JNI_GetShortArrayElements,
+ _Jv_JNI_GetIntArrayElements,
+ _Jv_JNI_GetLongArrayElements,
+ _Jv_JNI_GetFloatArrayElements,
+ _Jv_JNI_GetDoubleArrayElements,
+
+ _Jv_JNI_ReleaseBooleanArrayElements,
+ _Jv_JNI_ReleaseByteArrayElements,
+ _Jv_JNI_ReleaseCharArrayElements,
+ _Jv_JNI_ReleaseShortArrayElements,
+ _Jv_JNI_ReleaseIntArrayElements,
+ _Jv_JNI_ReleaseLongArrayElements,
+ _Jv_JNI_ReleaseFloatArrayElements,
+ _Jv_JNI_ReleaseDoubleArrayElements,
+
+ _Jv_JNI_GetBooleanArrayRegion,
+ _Jv_JNI_GetByteArrayRegion,
+ _Jv_JNI_GetCharArrayRegion,
+ _Jv_JNI_GetShortArrayRegion,
+ _Jv_JNI_GetIntArrayRegion,
+ _Jv_JNI_GetLongArrayRegion,
+ _Jv_JNI_GetFloatArrayRegion,
+ _Jv_JNI_GetDoubleArrayRegion,
+ _Jv_JNI_SetBooleanArrayRegion,
+ _Jv_JNI_SetByteArrayRegion,
+ _Jv_JNI_SetCharArrayRegion,
+ _Jv_JNI_SetShortArrayRegion,
+ _Jv_JNI_SetIntArrayRegion,
+ _Jv_JNI_SetLongArrayRegion,
+ _Jv_JNI_SetFloatArrayRegion,
+ _Jv_JNI_SetDoubleArrayRegion,
+
+ _Jv_JNI_RegisterNatives,
+ _Jv_JNI_UnregisterNatives,
+
+ _Jv_JNI_MonitorEnter,
+ _Jv_JNI_MonitorExit,
+
+ _Jv_JNI_GetJavaVM,
/* new JNI 1.2 functions */
- GetStringRegion,
- GetStringUTFRegion,
+ _Jv_JNI_GetStringRegion,
+ _Jv_JNI_GetStringUTFRegion,
- GetPrimitiveArrayCritical,
- ReleasePrimitiveArrayCritical,
+ _Jv_JNI_GetPrimitiveArrayCritical,
+ _Jv_JNI_ReleasePrimitiveArrayCritical,
- GetStringCritical,
- ReleaseStringCritical,
+ _Jv_JNI_GetStringCritical,
+ _Jv_JNI_ReleaseStringCritical,
- NewWeakGlobalRef,
- DeleteWeakGlobalRef,
+ _Jv_JNI_NewWeakGlobalRef,
+ _Jv_JNI_DeleteWeakGlobalRef,
- ExceptionCheck,
+ _Jv_JNI_ExceptionCheck,
/* new JNI 1.4 functions */
- NewDirectByteBuffer,
- GetDirectBufferAddress,
- GetDirectBufferCapacity
+ _Jv_JNI_NewDirectByteBuffer,
+ _Jv_JNI_GetDirectBufferAddress,
+ _Jv_JNI_GetDirectBufferCapacity
};
jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args)
{
- JavaVMInitArgs *_vm_args;
- _Jv_JNIEnv *env;
- _Jv_JavaVM *jvm;
- localref_table *lrt;
-
- /* get the arguments for the new JVM */
-
- _vm_args = (JavaVMInitArgs *) vm_args;
-
- /* get the VM and Env tables (must be set before vm_create) */
-
- env = NEW(_Jv_JNIEnv);
- env->env = &_Jv_JNINativeInterface;
-
- /* XXX Set the global variable. Maybe we should do that differently. */
-
- _Jv_env = env;
-
- /* create and fill a JavaVM structure */
-
- jvm = NEW(_Jv_JavaVM);
- jvm->functions = &_Jv_JNIInvokeInterface;
-
- /* XXX Set the global variable. Maybe we should do that differently. */
- /* XXX JVMTI Agents needs a JavaVM */
-
- _Jv_jvm = jvm;
-
/* actually create the JVM */
- if (!vm_create(_vm_args)) {
- /* release allocated memory */
-
- FREE(env, _Jv_JNIEnv);
- FREE(jvm, _Jv_JavaVM);
-
- return -1;
- }
-
- /* setup the local ref table (must be created after vm_create) */
-
- lrt = GCNEW(localref_table);
-
- lrt->capacity = LOCALREFTABLE_CAPACITY;
- lrt->used = 0;
- lrt->localframes = 1;
- lrt->prev = LOCALREFTABLE;
-
- /* clear the references array (memset is faster then a for-loop) */
-
- MSET(lrt->refs, 0, java_objectheader*, LOCALREFTABLE_CAPACITY);
-
- LOCALREFTABLE = lrt;
-
- /* now return the values */
-
- *p_vm = (JavaVM *) jvm;
- *p_env = (void *) env;
+ if (!vm_createjvm(p_vm, p_env, vm_args))
+ return JNI_ERR;
- return 0;
+ return JNI_OK;
}
projects / cacao.git / blobdiff