| // jni.cc - JNI implementation, including the jump table. |
| |
| /* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation |
| |
| This file is part of libgcj. |
| |
| This software is copyrighted work licensed under the terms of the |
| Libgcj License. Please consult the file "LIBGCJ_LICENSE" for |
| details. */ |
| |
| #include <config.h> |
| |
| #include <stddef.h> |
| #include <string.h> |
| |
| // Define this before including jni.h. |
| #define __GCJ_JNI_IMPL__ |
| |
| #include <gcj/cni.h> |
| #include <jvm.h> |
| #include <java-assert.h> |
| #include <jni.h> |
| #ifdef ENABLE_JVMPI |
| #include <jvmpi.h> |
| #endif |
| |
| #include <java/lang/Class.h> |
| #include <java/lang/ClassLoader.h> |
| #include <java/lang/Throwable.h> |
| #include <java/lang/ArrayIndexOutOfBoundsException.h> |
| #include <java/lang/StringIndexOutOfBoundsException.h> |
| #include <java/lang/AbstractMethodError.h> |
| #include <java/lang/InstantiationException.h> |
| #include <java/lang/NoSuchFieldError.h> |
| #include <java/lang/NoSuchMethodError.h> |
| #include <java/lang/reflect/Constructor.h> |
| #include <java/lang/reflect/Method.h> |
| #include <java/lang/reflect/Modifier.h> |
| #include <java/lang/OutOfMemoryError.h> |
| #include <java/util/Hashtable.h> |
| #include <java/lang/Integer.h> |
| #include <java/lang/ThreadGroup.h> |
| #include <gnu/gcj/jni/NativeThread.h> |
| |
| #include <gcj/method.h> |
| #include <gcj/field.h> |
| |
| #include <java-interp.h> |
| |
| // FIXME: remove these defines. |
| #define ClassClass java::lang::Class::class$ |
| #define ObjectClass java::lang::Object::class$ |
| #define ThrowableClass java::lang::Throwable::class$ |
| #define MethodClass java::lang::reflect::Method::class$ |
| #define ThreadGroupClass java::lang::ThreadGroup::class$ |
| #define NativeThreadClass gnu::gcj::jni::NativeThread::class$ |
| |
| // This enum is used to select different template instantiations in |
| // the invocation code. |
| enum invocation_type |
| { |
| normal, |
| nonvirtual, |
| static_type, |
| constructor |
| }; |
| |
| // Forward declarations. |
| extern struct JNINativeInterface _Jv_JNIFunctions; |
| extern struct JNIInvokeInterface _Jv_JNI_InvokeFunctions; |
| |
| // Number of slots in the default frame. The VM must allow at least |
| // 16. |
| #define FRAME_SIZE 32 |
| |
| // Mark value indicating this is an overflow frame. |
| #define MARK_NONE 0 |
| // Mark value indicating this is a user frame. |
| #define MARK_USER 1 |
| // Mark value indicating this is a system frame. |
| #define MARK_SYSTEM 2 |
| |
| // This structure is used to keep track of local references. |
| struct _Jv_JNI_LocalFrame |
| { |
| // This is true if this frame object represents a pushed frame (eg |
| // from PushLocalFrame). |
| int marker : 2; |
| |
| // Number of elements in frame. |
| int size : 30; |
| |
| // Next frame in chain. |
| _Jv_JNI_LocalFrame *next; |
| |
| // The elements. These are allocated using the C "struct hack". |
| jobject vec[0]; |
| }; |
| |
| // This holds a reference count for all local and global references. |
| static java::util::Hashtable *ref_table; |
| |
| // The only VM. |
| static JavaVM *the_vm; |
| |
| #ifdef ENABLE_JVMPI |
| // The only JVMPI interface description. |
| static JVMPI_Interface _Jv_JVMPI_Interface; |
| |
| static jint |
| jvmpiEnableEvent (jint event_type, void *) |
| { |
| switch (event_type) |
| { |
| case JVMPI_EVENT_OBJECT_ALLOC: |
| _Jv_JVMPI_Notify_OBJECT_ALLOC = _Jv_JVMPI_Interface.NotifyEvent; |
| break; |
| |
| case JVMPI_EVENT_THREAD_START: |
| _Jv_JVMPI_Notify_THREAD_START = _Jv_JVMPI_Interface.NotifyEvent; |
| break; |
| |
| case JVMPI_EVENT_THREAD_END: |
| _Jv_JVMPI_Notify_THREAD_END = _Jv_JVMPI_Interface.NotifyEvent; |
| break; |
| |
| default: |
| return JVMPI_NOT_AVAILABLE; |
| } |
| |
| return JVMPI_SUCCESS; |
| } |
| |
| static jint |
| jvmpiDisableEvent (jint event_type, void *) |
| { |
| switch (event_type) |
| { |
| case JVMPI_EVENT_OBJECT_ALLOC: |
| _Jv_JVMPI_Notify_OBJECT_ALLOC = NULL; |
| break; |
| |
| default: |
| return JVMPI_NOT_AVAILABLE; |
| } |
| |
| return JVMPI_SUCCESS; |
| } |
| #endif |
| |
| |
| |
| void |
| _Jv_JNI_Init (void) |
| { |
| ref_table = new java::util::Hashtable; |
| |
| #ifdef ENABLE_JVMPI |
| _Jv_JVMPI_Interface.version = 1; |
| _Jv_JVMPI_Interface.EnableEvent = &jvmpiEnableEvent; |
| _Jv_JVMPI_Interface.DisableEvent = &jvmpiDisableEvent; |
| _Jv_JVMPI_Interface.EnableGC = &_Jv_EnableGC; |
| _Jv_JVMPI_Interface.DisableGC = &_Jv_DisableGC; |
| _Jv_JVMPI_Interface.RunGC = &_Jv_RunGC; |
| #endif |
| } |
| |
| // Tell the GC that a certain pointer is live. |
| static void |
| mark_for_gc (jobject obj) |
| { |
| JvSynchronize sync (ref_table); |
| |
| using namespace java::lang; |
| Integer *refcount = (Integer *) ref_table->get (obj); |
| jint val = (refcount == NULL) ? 0 : refcount->intValue (); |
| // FIXME: what about out of memory error? |
| ref_table->put (obj, new Integer (val + 1)); |
| } |
| |
| // Unmark a pointer. |
| static void |
| unmark_for_gc (jobject obj) |
| { |
| JvSynchronize sync (ref_table); |
| |
| using namespace java::lang; |
| Integer *refcount = (Integer *) ref_table->get (obj); |
| JvAssert (refcount); |
| jint val = refcount->intValue () - 1; |
| if (val == 0) |
| ref_table->remove (obj); |
| else |
| // FIXME: what about out of memory error? |
| ref_table->put (obj, new Integer (val)); |
| } |
| |
| |
| |
| static jobject |
| _Jv_JNI_NewGlobalRef (JNIEnv *, jobject obj) |
| { |
| mark_for_gc (obj); |
| return obj; |
| } |
| |
| static void |
| _Jv_JNI_DeleteGlobalRef (JNIEnv *, jobject obj) |
| { |
| unmark_for_gc (obj); |
| } |
| |
| static void |
| _Jv_JNI_DeleteLocalRef (JNIEnv *env, jobject obj) |
| { |
| _Jv_JNI_LocalFrame *frame; |
| |
| for (frame = env->locals; frame != NULL; frame = frame->next) |
| { |
| for (int i = 0; i < FRAME_SIZE; ++i) |
| { |
| if (frame->vec[i] == obj) |
| { |
| frame->vec[i] = NULL; |
| unmark_for_gc (obj); |
| return; |
| } |
| } |
| |
| // Don't go past a marked frame. |
| JvAssert (frame->marker == MARK_NONE); |
| } |
| |
| JvAssert (0); |
| } |
| |
| static jint |
| _Jv_JNI_EnsureLocalCapacity (JNIEnv *env, jint size) |
| { |
| // It is easier to just always allocate a new frame of the requested |
| // size. This isn't the most efficient thing, but for now we don't |
| // care. Note that _Jv_JNI_PushLocalFrame relies on this right now. |
| |
| _Jv_JNI_LocalFrame *frame; |
| try |
| { |
| frame = (_Jv_JNI_LocalFrame *) _Jv_Malloc (sizeof (_Jv_JNI_LocalFrame) |
| + size * sizeof (jobject)); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return JNI_ERR; |
| } |
| |
| frame->marker = MARK_NONE; |
| frame->size = size; |
| memset (&frame->vec[0], 0, size * sizeof (jobject)); |
| frame->next = env->locals; |
| env->locals = frame; |
| |
| return 0; |
| } |
| |
| static jint |
| _Jv_JNI_PushLocalFrame (JNIEnv *env, jint size) |
| { |
| jint r = _Jv_JNI_EnsureLocalCapacity (env, size); |
| if (r < 0) |
| return r; |
| |
| // The new frame is on top. |
| env->locals->marker = MARK_USER; |
| |
| return 0; |
| } |
| |
| static jobject |
| _Jv_JNI_NewLocalRef (JNIEnv *env, jobject obj) |
| { |
| // Try to find an open slot somewhere in the topmost frame. |
| _Jv_JNI_LocalFrame *frame = env->locals; |
| bool done = false, set = false; |
| while (frame != NULL && ! done) |
| { |
| for (int i = 0; i < frame->size; ++i) |
| if (frame->vec[i] == NULL) |
| { |
| set = true; |
| done = true; |
| frame->vec[i] = obj; |
| break; |
| } |
| } |
| |
| if (! set) |
| { |
| // No slots, so we allocate a new frame. According to the spec |
| // we could just die here. FIXME: return value. |
| _Jv_JNI_EnsureLocalCapacity (env, 16); |
| // We know the first element of the new frame will be ok. |
| env->locals->vec[0] = obj; |
| } |
| |
| mark_for_gc (obj); |
| return obj; |
| } |
| |
| static jobject |
| _Jv_JNI_PopLocalFrame (JNIEnv *env, jobject result, int stop) |
| { |
| _Jv_JNI_LocalFrame *rf = env->locals; |
| |
| bool done = false; |
| while (rf != NULL && ! done) |
| { |
| for (int i = 0; i < rf->size; ++i) |
| if (rf->vec[i] != NULL) |
| unmark_for_gc (rf->vec[i]); |
| |
| // If the frame we just freed is the marker frame, we are done. |
| done = (rf->marker == stop); |
| |
| _Jv_JNI_LocalFrame *n = rf->next; |
| // When N==NULL, we've reached the stack-allocated frame, and we |
| // must not free it. However, we must be sure to clear all its |
| // elements, since we might conceivably reuse it. |
| if (n == NULL) |
| { |
| memset (&rf->vec[0], 0, rf->size * sizeof (jobject)); |
| break; |
| } |
| |
| _Jv_Free (rf); |
| rf = n; |
| } |
| |
| // Update the local frame information. |
| env->locals = rf; |
| |
| return result == NULL ? NULL : _Jv_JNI_NewLocalRef (env, result); |
| } |
| |
| static jobject |
| _Jv_JNI_PopLocalFrame (JNIEnv *env, jobject result) |
| { |
| return _Jv_JNI_PopLocalFrame (env, result, MARK_USER); |
| } |
| |
| // Pop a `system' frame from the stack. This is `extern "C"' as it is |
| // used by the compiler. |
| extern "C" void |
| _Jv_JNI_PopSystemFrame (JNIEnv *env) |
| { |
| _Jv_JNI_PopLocalFrame (env, NULL, MARK_SYSTEM); |
| |
| if (env->ex) |
| { |
| jthrowable t = env->ex; |
| env->ex = NULL; |
| throw t; |
| } |
| } |
| |
| // This function is used from other template functions. It wraps the |
| // return value appropriately; we specialize it so that object returns |
| // are turned into local references. |
| template<typename T> |
| static T |
| wrap_value (JNIEnv *, T value) |
| { |
| return value; |
| } |
| |
| // This specialization is used for jobject, jclass, jstring, jarray, |
| // etc. |
| template<typename T> |
| static T * |
| wrap_value (JNIEnv *env, T *value) |
| { |
| return (value == NULL |
| ? value |
| : (T *) _Jv_JNI_NewLocalRef (env, (jobject) value)); |
| } |
| |
| |
| |
| static jint |
| _Jv_JNI_GetVersion (JNIEnv *) |
| { |
| return JNI_VERSION_1_2; |
| } |
| |
| static jclass |
| _Jv_JNI_DefineClass (JNIEnv *env, jobject loader, |
| const jbyte *buf, jsize bufLen) |
| { |
| try |
| { |
| jbyteArray bytes = JvNewByteArray (bufLen); |
| |
| jbyte *elts = elements (bytes); |
| memcpy (elts, buf, bufLen * sizeof (jbyte)); |
| |
| java::lang::ClassLoader *l |
| = reinterpret_cast<java::lang::ClassLoader *> (loader); |
| |
| jclass result = l->defineClass (bytes, 0, bufLen); |
| return (jclass) wrap_value (env, result); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static jclass |
| _Jv_JNI_FindClass (JNIEnv *env, const char *name) |
| { |
| // FIXME: assume that NAME isn't too long. |
| int len = strlen (name); |
| char s[len + 1]; |
| for (int i = 0; i <= len; ++i) |
| s[i] = (name[i] == '/') ? '.' : name[i]; |
| |
| jclass r = NULL; |
| try |
| { |
| // This might throw an out of memory exception. |
| jstring n = JvNewStringUTF (s); |
| |
| java::lang::ClassLoader *loader = NULL; |
| if (env->klass != NULL) |
| loader = env->klass->getClassLoader (); |
| |
| if (loader == NULL) |
| { |
| // FIXME: should use getBaseClassLoader, but we don't have that |
| // yet. |
| loader = java::lang::ClassLoader::getSystemClassLoader (); |
| } |
| |
| r = loader->loadClass (n); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return (jclass) wrap_value (env, r); |
| } |
| |
| static jclass |
| _Jv_JNI_GetSuperclass (JNIEnv *env, jclass clazz) |
| { |
| return (jclass) wrap_value (env, clazz->getSuperclass ()); |
| } |
| |
| static jboolean |
| _Jv_JNI_IsAssignableFrom(JNIEnv *, jclass clazz1, jclass clazz2) |
| { |
| return clazz1->isAssignableFrom (clazz2); |
| } |
| |
| static jint |
| _Jv_JNI_Throw (JNIEnv *env, jthrowable obj) |
| { |
| // We check in case the user did some funky cast. |
| JvAssert (obj != NULL && (&ThrowableClass)->isInstance (obj)); |
| env->ex = obj; |
| return 0; |
| } |
| |
| static jint |
| _Jv_JNI_ThrowNew (JNIEnv *env, jclass clazz, const char *message) |
| { |
| using namespace java::lang::reflect; |
| |
| JvAssert ((&ThrowableClass)->isAssignableFrom (clazz)); |
| |
| int r = JNI_OK; |
| try |
| { |
| JArray<jclass> *argtypes |
| = (JArray<jclass> *) JvNewObjectArray (1, &ClassClass, NULL); |
| |
| jclass *elts = elements (argtypes); |
| elts[0] = &StringClass; |
| |
| Constructor *cons = clazz->getConstructor (argtypes); |
| |
| jobjectArray values = JvNewObjectArray (1, &StringClass, NULL); |
| jobject *velts = elements (values); |
| velts[0] = JvNewStringUTF (message); |
| |
| jobject obj = cons->newInstance (values); |
| |
| env->ex = reinterpret_cast<jthrowable> (obj); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| r = JNI_ERR; |
| } |
| |
| return r; |
| } |
| |
| static jthrowable |
| _Jv_JNI_ExceptionOccurred (JNIEnv *env) |
| { |
| return (jthrowable) wrap_value (env, env->ex); |
| } |
| |
| static void |
| _Jv_JNI_ExceptionDescribe (JNIEnv *env) |
| { |
| if (env->ex != NULL) |
| env->ex->printStackTrace(); |
| } |
| |
| static void |
| _Jv_JNI_ExceptionClear (JNIEnv *env) |
| { |
| env->ex = NULL; |
| } |
| |
| static jboolean |
| _Jv_JNI_ExceptionCheck (JNIEnv *env) |
| { |
| return env->ex != NULL; |
| } |
| |
| static void |
| _Jv_JNI_FatalError (JNIEnv *, const char *message) |
| { |
| JvFail (message); |
| } |
| |
| |
| |
| static jboolean |
| _Jv_JNI_IsSameObject (JNIEnv *, jobject obj1, jobject obj2) |
| { |
| return obj1 == obj2; |
| } |
| |
| static jobject |
| _Jv_JNI_AllocObject (JNIEnv *env, jclass clazz) |
| { |
| jobject obj = NULL; |
| using namespace java::lang::reflect; |
| |
| try |
| { |
| JvAssert (clazz && ! clazz->isArray ()); |
| if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers())) |
| env->ex = new java::lang::InstantiationException (); |
| else |
| { |
| // FIXME: will this work for String? |
| obj = JvAllocObject (clazz); |
| } |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return wrap_value (env, obj); |
| } |
| |
| static jclass |
| _Jv_JNI_GetObjectClass (JNIEnv *env, jobject obj) |
| { |
| JvAssert (obj); |
| return (jclass) wrap_value (env, obj->getClass()); |
| } |
| |
| static jboolean |
| _Jv_JNI_IsInstanceOf (JNIEnv *, jobject obj, jclass clazz) |
| { |
| return clazz->isInstance(obj); |
| } |
| |
| |
| |
| // |
| // This section concerns method invocation. |
| // |
| |
| template<jboolean is_static> |
| static jmethodID |
| _Jv_JNI_GetAnyMethodID (JNIEnv *env, jclass clazz, |
| const char *name, const char *sig) |
| { |
| try |
| { |
| _Jv_InitClass (clazz); |
| |
| _Jv_Utf8Const *name_u = _Jv_makeUtf8Const ((char *) name, -1); |
| |
| // FIXME: assume that SIG isn't too long. |
| int len = strlen (sig); |
| char s[len + 1]; |
| for (int i = 0; i <= len; ++i) |
| s[i] = (sig[i] == '/') ? '.' : sig[i]; |
| _Jv_Utf8Const *sig_u = _Jv_makeUtf8Const ((char *) s, -1); |
| |
| JvAssert (! clazz->isPrimitive()); |
| |
| using namespace java::lang::reflect; |
| |
| while (clazz != NULL) |
| { |
| jint count = JvNumMethods (clazz); |
| jmethodID meth = JvGetFirstMethod (clazz); |
| |
| for (jint i = 0; i < count; ++i) |
| { |
| if (((is_static && Modifier::isStatic (meth->accflags)) |
| || (! is_static && ! Modifier::isStatic (meth->accflags))) |
| && _Jv_equalUtf8Consts (meth->name, name_u) |
| && _Jv_equalUtf8Consts (meth->signature, sig_u)) |
| return meth; |
| |
| meth = meth->getNextMethod(); |
| } |
| |
| clazz = clazz->getSuperclass (); |
| } |
| |
| env->ex = new java::lang::NoSuchMethodError (); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return NULL; |
| } |
| |
| // This is a helper function which turns a va_list into an array of |
| // `jvalue's. It needs signature information in order to do its work. |
| // The array of values must already be allocated. |
| static void |
| array_from_valist (jvalue *values, JArray<jclass> *arg_types, va_list vargs) |
| { |
| jclass *arg_elts = elements (arg_types); |
| for (int i = 0; i < arg_types->length; ++i) |
| { |
| if (arg_elts[i] == JvPrimClass (byte)) |
| values[i].b = va_arg (vargs, jbyte); |
| else if (arg_elts[i] == JvPrimClass (short)) |
| values[i].s = va_arg (vargs, jshort); |
| else if (arg_elts[i] == JvPrimClass (int)) |
| values[i].i = va_arg (vargs, jint); |
| else if (arg_elts[i] == JvPrimClass (long)) |
| values[i].j = va_arg (vargs, jlong); |
| else if (arg_elts[i] == JvPrimClass (float)) |
| values[i].f = va_arg (vargs, jfloat); |
| else if (arg_elts[i] == JvPrimClass (double)) |
| values[i].d = va_arg (vargs, jdouble); |
| else if (arg_elts[i] == JvPrimClass (boolean)) |
| values[i].z = va_arg (vargs, jboolean); |
| else if (arg_elts[i] == JvPrimClass (char)) |
| values[i].c = va_arg (vargs, jchar); |
| else |
| { |
| // An object. |
| values[i].l = va_arg (vargs, jobject); |
| } |
| } |
| } |
| |
| // This can call any sort of method: virtual, "nonvirtual", static, or |
| // constructor. |
| template<typename T, invocation_type style> |
| static T |
| _Jv_JNI_CallAnyMethodV (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, va_list vargs) |
| { |
| if (style == normal) |
| id = _Jv_LookupDeclaredMethod (obj->getClass (), id->name, id->signature); |
| |
| jclass decl_class = klass ? klass : obj->getClass (); |
| JvAssert (decl_class != NULL); |
| |
| jclass return_type; |
| JArray<jclass> *arg_types; |
| |
| try |
| { |
| _Jv_GetTypesFromSignature (id, decl_class, |
| &arg_types, &return_type); |
| |
| jvalue args[arg_types->length]; |
| array_from_valist (args, arg_types, vargs); |
| |
| // For constructors we need to pass the Class we are instantiating. |
| if (style == constructor) |
| return_type = klass; |
| |
| jvalue result; |
| jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| arg_types, args, &result); |
| |
| if (ex != NULL) |
| env->ex = ex; |
| |
| // We cheat a little here. FIXME. |
| return wrap_value (env, * (T *) &result); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return wrap_value (env, (T) 0); |
| } |
| |
| template<typename T, invocation_type style> |
| static T |
| _Jv_JNI_CallAnyMethod (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID method, ...) |
| { |
| va_list args; |
| T result; |
| |
| va_start (args, method); |
| result = _Jv_JNI_CallAnyMethodV<T, style> (env, obj, klass, method, args); |
| va_end (args); |
| |
| return result; |
| } |
| |
| template<typename T, invocation_type style> |
| static T |
| _Jv_JNI_CallAnyMethodA (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, jvalue *args) |
| { |
| if (style == normal) |
| id = _Jv_LookupDeclaredMethod (obj->getClass (), id->name, id->signature); |
| |
| jclass decl_class = klass ? klass : obj->getClass (); |
| JvAssert (decl_class != NULL); |
| |
| jclass return_type; |
| JArray<jclass> *arg_types; |
| try |
| { |
| _Jv_GetTypesFromSignature (id, decl_class, |
| &arg_types, &return_type); |
| |
| // For constructors we need to pass the Class we are instantiating. |
| if (style == constructor) |
| return_type = klass; |
| |
| jvalue result; |
| jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| arg_types, args, &result); |
| |
| if (ex != NULL) |
| env->ex = ex; |
| |
| // We cheat a little here. FIXME. |
| return wrap_value (env, * (T *) &result); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return wrap_value (env, (T) 0); |
| } |
| |
| template<invocation_type style> |
| static void |
| _Jv_JNI_CallAnyVoidMethodV (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, va_list vargs) |
| { |
| if (style == normal) |
| id = _Jv_LookupDeclaredMethod (obj->getClass (), id->name, id->signature); |
| |
| jclass decl_class = klass ? klass : obj->getClass (); |
| JvAssert (decl_class != NULL); |
| |
| jclass return_type; |
| JArray<jclass> *arg_types; |
| try |
| { |
| _Jv_GetTypesFromSignature (id, decl_class, |
| &arg_types, &return_type); |
| |
| jvalue args[arg_types->length]; |
| array_from_valist (args, arg_types, vargs); |
| |
| // For constructors we need to pass the Class we are instantiating. |
| if (style == constructor) |
| return_type = klass; |
| |
| jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| arg_types, args, NULL); |
| |
| if (ex != NULL) |
| env->ex = ex; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| |
| template<invocation_type style> |
| static void |
| _Jv_JNI_CallAnyVoidMethod (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID method, ...) |
| { |
| va_list args; |
| |
| va_start (args, method); |
| _Jv_JNI_CallAnyVoidMethodV<style> (env, obj, klass, method, args); |
| va_end (args); |
| } |
| |
| template<invocation_type style> |
| static void |
| _Jv_JNI_CallAnyVoidMethodA (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, jvalue *args) |
| { |
| if (style == normal) |
| id = _Jv_LookupDeclaredMethod (obj->getClass (), id->name, id->signature); |
| |
| jclass decl_class = klass ? klass : obj->getClass (); |
| JvAssert (decl_class != NULL); |
| |
| jclass return_type; |
| JArray<jclass> *arg_types; |
| try |
| { |
| _Jv_GetTypesFromSignature (id, decl_class, |
| &arg_types, &return_type); |
| |
| jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| arg_types, args, NULL); |
| |
| if (ex != NULL) |
| env->ex = ex; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| |
| // Functions with this signature are used to implement functions in |
| // the CallMethod family. |
| template<typename T> |
| static T |
| _Jv_JNI_CallMethodV (JNIEnv *env, jobject obj, jmethodID id, va_list args) |
| { |
| return _Jv_JNI_CallAnyMethodV<T, normal> (env, obj, NULL, id, args); |
| } |
| |
| // Functions with this signature are used to implement functions in |
| // the CallMethod family. |
| template<typename T> |
| static T |
| _Jv_JNI_CallMethod (JNIEnv *env, jobject obj, jmethodID id, ...) |
| { |
| va_list args; |
| T result; |
| |
| va_start (args, id); |
| result = _Jv_JNI_CallAnyMethodV<T, normal> (env, obj, NULL, id, args); |
| va_end (args); |
| |
| return result; |
| } |
| |
| // Functions with this signature are used to implement functions in |
| // the CallMethod family. |
| template<typename T> |
| static T |
| _Jv_JNI_CallMethodA (JNIEnv *env, jobject obj, jmethodID id, jvalue *args) |
| { |
| return _Jv_JNI_CallAnyMethodA<T, normal> (env, obj, NULL, id, args); |
| } |
| |
| static void |
| _Jv_JNI_CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID id, va_list args) |
| { |
| _Jv_JNI_CallAnyVoidMethodV<normal> (env, obj, NULL, id, args); |
| } |
| |
| static void |
| _Jv_JNI_CallVoidMethod (JNIEnv *env, jobject obj, jmethodID id, ...) |
| { |
| va_list args; |
| |
| va_start (args, id); |
| _Jv_JNI_CallAnyVoidMethodV<normal> (env, obj, NULL, id, args); |
| va_end (args); |
| } |
| |
| static void |
| _Jv_JNI_CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID id, jvalue *args) |
| { |
| _Jv_JNI_CallAnyVoidMethodA<normal> (env, obj, NULL, id, args); |
| } |
| |
| // Functions with this signature are used to implement functions in |
| // the CallStaticMethod family. |
| template<typename T> |
| static T |
| _Jv_JNI_CallStaticMethodV (JNIEnv *env, jclass klass, |
| jmethodID id, va_list args) |
| { |
| JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC)); |
| JvAssert ((&ClassClass)->isInstance (klass)); |
| |
| return _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass, id, args); |
| } |
| |
| // Functions with this signature are used to implement functions in |
| // the CallStaticMethod family. |
| template<typename T> |
| static T |
| _Jv_JNI_CallStaticMethod (JNIEnv *env, jclass klass, jmethodID id, ...) |
| { |
| va_list args; |
| T result; |
| |
| JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC)); |
| JvAssert ((&ClassClass)->isInstance (klass)); |
| |
| va_start (args, id); |
| result = _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass, |
| id, args); |
| va_end (args); |
| |
| return result; |
| } |
| |
| // Functions with this signature are used to implement functions in |
| // the CallStaticMethod family. |
| template<typename T> |
| static T |
| _Jv_JNI_CallStaticMethodA (JNIEnv *env, jclass klass, jmethodID id, |
| jvalue *args) |
| { |
| JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC)); |
| JvAssert ((&ClassClass)->isInstance (klass)); |
| |
| return _Jv_JNI_CallAnyMethodA<T, static_type> (env, NULL, klass, id, args); |
| } |
| |
| static void |
| _Jv_JNI_CallStaticVoidMethodV (JNIEnv *env, jclass klass, jmethodID id, |
| va_list args) |
| { |
| _Jv_JNI_CallAnyVoidMethodV<static_type> (env, NULL, klass, id, args); |
| } |
| |
| static void |
| _Jv_JNI_CallStaticVoidMethod (JNIEnv *env, jclass klass, jmethodID id, ...) |
| { |
| va_list args; |
| |
| va_start (args, id); |
| _Jv_JNI_CallAnyVoidMethodV<static_type> (env, NULL, klass, id, args); |
| va_end (args); |
| } |
| |
| static void |
| _Jv_JNI_CallStaticVoidMethodA (JNIEnv *env, jclass klass, jmethodID id, |
| jvalue *args) |
| { |
| _Jv_JNI_CallAnyVoidMethodA<static_type> (env, NULL, klass, id, args); |
| } |
| |
| static jobject |
| _Jv_JNI_NewObjectV (JNIEnv *env, jclass klass, |
| jmethodID id, va_list args) |
| { |
| JvAssert (klass && ! klass->isArray ()); |
| JvAssert (! strcmp (id->name->data, "<init>") |
| && id->signature->length > 2 |
| && id->signature->data[0] == '(' |
| && ! strcmp (&id->signature->data[id->signature->length - 2], |
| ")V")); |
| |
| return _Jv_JNI_CallAnyMethodV<jobject, constructor> (env, NULL, klass, |
| id, args); |
| } |
| |
| static jobject |
| _Jv_JNI_NewObject (JNIEnv *env, jclass klass, jmethodID id, ...) |
| { |
| JvAssert (klass && ! klass->isArray ()); |
| JvAssert (! strcmp (id->name->data, "<init>") |
| && id->signature->length > 2 |
| && id->signature->data[0] == '(' |
| && ! strcmp (&id->signature->data[id->signature->length - 2], |
| ")V")); |
| |
| va_list args; |
| jobject result; |
| |
| va_start (args, id); |
| result = _Jv_JNI_CallAnyMethodV<jobject, constructor> (env, NULL, klass, |
| id, args); |
| va_end (args); |
| |
| return result; |
| } |
| |
| static jobject |
| _Jv_JNI_NewObjectA (JNIEnv *env, jclass klass, jmethodID id, |
| jvalue *args) |
| { |
| JvAssert (klass && ! klass->isArray ()); |
| JvAssert (! strcmp (id->name->data, "<init>") |
| && id->signature->length > 2 |
| && id->signature->data[0] == '(' |
| && ! strcmp (&id->signature->data[id->signature->length - 2], |
| ")V")); |
| |
| return _Jv_JNI_CallAnyMethodA<jobject, constructor> (env, NULL, klass, |
| id, args); |
| } |
| |
| |
| |
| template<typename T> |
| static T |
| _Jv_JNI_GetField (JNIEnv *env, jobject obj, jfieldID field) |
| { |
| JvAssert (obj); |
| T *ptr = (T *) ((char *) obj + field->getOffset ()); |
| return wrap_value (env, *ptr); |
| } |
| |
| template<typename T> |
| static void |
| _Jv_JNI_SetField (JNIEnv *, jobject obj, jfieldID field, T value) |
| { |
| JvAssert (obj); |
| T *ptr = (T *) ((char *) obj + field->getOffset ()); |
| *ptr = value; |
| } |
| |
| template<jboolean is_static> |
| static jfieldID |
| _Jv_JNI_GetAnyFieldID (JNIEnv *env, jclass clazz, |
| const char *name, const char *sig) |
| { |
| try |
| { |
| _Jv_InitClass (clazz); |
| |
| _Jv_Utf8Const *a_name = _Jv_makeUtf8Const ((char *) name, -1); |
| |
| // FIXME: assume that SIG isn't too long. |
| int len = strlen (sig); |
| char s[len + 1]; |
| for (int i = 0; i <= len; ++i) |
| s[i] = (sig[i] == '/') ? '.' : sig[i]; |
| jclass field_class = _Jv_FindClassFromSignature ((char *) s, NULL); |
| |
| // FIXME: what if field_class == NULL? |
| |
| java::lang::ClassLoader *loader = clazz->getClassLoader (); |
| while (clazz != NULL) |
| { |
| // We acquire the class lock so that fields aren't resolved |
| // while we are running. |
| JvSynchronize sync (clazz); |
| |
| jint count = (is_static |
| ? JvNumStaticFields (clazz) |
| : JvNumInstanceFields (clazz)); |
| jfieldID field = (is_static |
| ? JvGetFirstStaticField (clazz) |
| : JvGetFirstInstanceField (clazz)); |
| for (jint i = 0; i < count; ++i) |
| { |
| _Jv_Utf8Const *f_name = field->getNameUtf8Const(clazz); |
| |
| // The field might be resolved or it might not be. It |
| // is much simpler to always resolve it. |
| _Jv_ResolveField (field, loader); |
| if (_Jv_equalUtf8Consts (f_name, a_name) |
| && field->getClass() == field_class) |
| return field; |
| |
| field = field->getNextField (); |
| } |
| |
| clazz = clazz->getSuperclass (); |
| } |
| |
| env->ex = new java::lang::NoSuchFieldError (); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| return NULL; |
| } |
| |
| template<typename T> |
| static T |
| _Jv_JNI_GetStaticField (JNIEnv *env, jclass, jfieldID field) |
| { |
| T *ptr = (T *) field->u.addr; |
| return wrap_value (env, *ptr); |
| } |
| |
| template<typename T> |
| static void |
| _Jv_JNI_SetStaticField (JNIEnv *, jclass, jfieldID field, T value) |
| { |
| T *ptr = (T *) field->u.addr; |
| *ptr = value; |
| } |
| |
| static jstring |
| _Jv_JNI_NewString (JNIEnv *env, const jchar *unichars, jsize len) |
| { |
| try |
| { |
| jstring r = _Jv_NewString (unichars, len); |
| return (jstring) wrap_value (env, r); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static jsize |
| _Jv_JNI_GetStringLength (JNIEnv *, jstring string) |
| { |
| return string->length(); |
| } |
| |
| static const jchar * |
| _Jv_JNI_GetStringChars (JNIEnv *, jstring string, jboolean *isCopy) |
| { |
| jchar *result = _Jv_GetStringChars (string); |
| mark_for_gc (string); |
| if (isCopy) |
| *isCopy = false; |
| return (const jchar *) result; |
| } |
| |
| static void |
| _Jv_JNI_ReleaseStringChars (JNIEnv *, jstring string, const jchar *) |
| { |
| unmark_for_gc (string); |
| } |
| |
| static jstring |
| _Jv_JNI_NewStringUTF (JNIEnv *env, const char *bytes) |
| { |
| try |
| { |
| jstring result = JvNewStringUTF (bytes); |
| return (jstring) wrap_value (env, result); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static jsize |
| _Jv_JNI_GetStringUTFLength (JNIEnv *, jstring string) |
| { |
| return JvGetStringUTFLength (string); |
| } |
| |
| static const char * |
| _Jv_JNI_GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy) |
| { |
| jsize len = JvGetStringUTFLength (string); |
| try |
| { |
| char *r = (char *) _Jv_Malloc (len + 1); |
| JvGetStringUTFRegion (string, 0, len, r); |
| r[len] = '\0'; |
| |
| if (isCopy) |
| *isCopy = true; |
| |
| return (const char *) r; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static void |
| _Jv_JNI_ReleaseStringUTFChars (JNIEnv *, jstring, const char *utf) |
| { |
| _Jv_Free ((void *) utf); |
| } |
| |
| static void |
| _Jv_JNI_GetStringRegion (JNIEnv *env, jstring string, jsize start, jsize len, |
| jchar *buf) |
| { |
| jchar *result = _Jv_GetStringChars (string); |
| if (start < 0 || start > string->length () |
| || len < 0 || start + len > string->length ()) |
| { |
| try |
| { |
| env->ex = new java::lang::StringIndexOutOfBoundsException (); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| else |
| memcpy (buf, &result[start], len * sizeof (jchar)); |
| } |
| |
| static void |
| _Jv_JNI_GetStringUTFRegion (JNIEnv *env, jstring str, jsize start, |
| jsize len, char *buf) |
| { |
| if (start < 0 || start > str->length () |
| || len < 0 || start + len > str->length ()) |
| { |
| try |
| { |
| env->ex = new java::lang::StringIndexOutOfBoundsException (); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| else |
| _Jv_GetStringUTFRegion (str, start, len, buf); |
| } |
| |
| static const jchar * |
| _Jv_JNI_GetStringCritical (JNIEnv *, jstring str, jboolean *isCopy) |
| { |
| jchar *result = _Jv_GetStringChars (str); |
| if (isCopy) |
| *isCopy = false; |
| return result; |
| } |
| |
| static void |
| _Jv_JNI_ReleaseStringCritical (JNIEnv *, jstring, const jchar *) |
| { |
| // Nothing. |
| } |
| |
| static jsize |
| _Jv_JNI_GetArrayLength (JNIEnv *, jarray array) |
| { |
| return array->length; |
| } |
| |
| static jarray |
| _Jv_JNI_NewObjectArray (JNIEnv *env, jsize length, jclass elementClass, |
| jobject init) |
| { |
| try |
| { |
| jarray result = JvNewObjectArray (length, elementClass, init); |
| return (jarray) wrap_value (env, result); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static jobject |
| _Jv_JNI_GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index) |
| { |
| jobject *elts = elements (array); |
| return wrap_value (env, elts[index]); |
| } |
| |
| static void |
| _Jv_JNI_SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index, |
| jobject value) |
| { |
| try |
| { |
| _Jv_CheckArrayStore (array, value); |
| jobject *elts = elements (array); |
| elts[index] = value; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| |
| template<typename T, jclass K> |
| static JArray<T> * |
| _Jv_JNI_NewPrimitiveArray (JNIEnv *env, jsize length) |
| { |
| try |
| { |
| return (JArray<T> *) wrap_value (env, _Jv_NewPrimArray (K, length)); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| template<typename T> |
| static T * |
| _Jv_JNI_GetPrimitiveArrayElements (JNIEnv *, JArray<T> *array, |
| jboolean *isCopy) |
| { |
| T *elts = elements (array); |
| if (isCopy) |
| { |
| // We elect never to copy. |
| *isCopy = false; |
| } |
| mark_for_gc (array); |
| return elts; |
| } |
| |
| template<typename T> |
| static void |
| _Jv_JNI_ReleasePrimitiveArrayElements (JNIEnv *, JArray<T> *array, |
| T *, jint /* mode */) |
| { |
| // Note that we ignore MODE. We can do this because we never copy |
| // the array elements. My reading of the JNI documentation is that |
| // this is an option for the implementor. |
| unmark_for_gc (array); |
| } |
| |
| template<typename T> |
| static void |
| _Jv_JNI_GetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array, |
| jsize start, jsize len, |
| T *buf) |
| { |
| if (start < 0 || len >= array->length || start + len >= array->length) |
| { |
| try |
| { |
| // FIXME: index. |
| env->ex = new java::lang::ArrayIndexOutOfBoundsException (); |
| } |
| catch (jthrowable t) |
| { |
| // Could have thown out of memory error. |
| env->ex = t; |
| } |
| } |
| else |
| { |
| T *elts = elements (array) + start; |
| memcpy (buf, elts, len * sizeof (T)); |
| } |
| } |
| |
| template<typename T> |
| static void |
| _Jv_JNI_SetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array, |
| jsize start, jsize len, T *buf) |
| { |
| if (start < 0 || len >= array->length || start + len >= array->length) |
| { |
| try |
| { |
| // FIXME: index. |
| env->ex = new java::lang::ArrayIndexOutOfBoundsException (); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| else |
| { |
| T *elts = elements (array) + start; |
| memcpy (elts, buf, len * sizeof (T)); |
| } |
| } |
| |
| static void * |
| _Jv_JNI_GetPrimitiveArrayCritical (JNIEnv *, jarray array, |
| jboolean *isCopy) |
| { |
| // FIXME: does this work? |
| jclass klass = array->getClass()->getComponentType(); |
| JvAssert (klass->isPrimitive ()); |
| char *r = _Jv_GetArrayElementFromElementType (array, klass); |
| if (isCopy) |
| *isCopy = false; |
| return r; |
| } |
| |
| static void |
| _Jv_JNI_ReleasePrimitiveArrayCritical (JNIEnv *, jarray, void *, jint) |
| { |
| // Nothing. |
| } |
| |
| static jint |
| _Jv_JNI_MonitorEnter (JNIEnv *env, jobject obj) |
| { |
| try |
| { |
| return _Jv_MonitorEnter (obj); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| return JNI_ERR; |
| } |
| |
| static jint |
| _Jv_JNI_MonitorExit (JNIEnv *env, jobject obj) |
| { |
| try |
| { |
| return _Jv_MonitorExit (obj); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| return JNI_ERR; |
| } |
| |
| // JDK 1.2 |
| jobject |
| _Jv_JNI_ToReflectedField (JNIEnv *env, jclass cls, jfieldID fieldID, |
| jboolean) |
| { |
| try |
| { |
| java::lang::reflect::Field *field = new java::lang::reflect::Field(); |
| field->declaringClass = cls; |
| field->offset = (char*) fieldID - (char *) cls->fields; |
| field->name = _Jv_NewStringUtf8Const (fieldID->getNameUtf8Const (cls)); |
| return wrap_value (env, field); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| return NULL; |
| } |
| |
| // JDK 1.2 |
| static jfieldID |
| _Jv_JNI_FromReflectedField (JNIEnv *, jobject f) |
| { |
| using namespace java::lang::reflect; |
| |
| Field *field = reinterpret_cast<Field *> (f); |
| return _Jv_FromReflectedField (field); |
| } |
| |
| jobject |
| _Jv_JNI_ToReflectedMethod (JNIEnv *env, jclass klass, jmethodID id, |
| jboolean) |
| { |
| using namespace java::lang::reflect; |
| |
| // FIXME. |
| static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("<init>", 6); |
| |
| jobject result = NULL; |
| |
| try |
| { |
| if (_Jv_equalUtf8Consts (id->name, init_name)) |
| { |
| // A constructor. |
| Constructor *cons = new Constructor (); |
| cons->offset = (char *) id - (char *) &klass->methods; |
| cons->declaringClass = klass; |
| result = cons; |
| } |
| else |
| { |
| Method *meth = new Method (); |
| meth->offset = (char *) id - (char *) &klass->methods; |
| meth->declaringClass = klass; |
| result = meth; |
| } |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return wrap_value (env, result); |
| } |
| |
| static jmethodID |
| _Jv_JNI_FromReflectedMethod (JNIEnv *, jobject method) |
| { |
| using namespace java::lang::reflect; |
| if ((&MethodClass)->isInstance (method)) |
| return _Jv_FromReflectedMethod (reinterpret_cast<Method *> (method)); |
| return |
| _Jv_FromReflectedConstructor (reinterpret_cast<Constructor *> (method)); |
| } |
| |
| static jint |
| _Jv_JNI_RegisterNatives (JNIEnv *env, jclass k, |
| const JNINativeMethod *methods, |
| jint nMethods) |
| { |
| #ifdef INTERPRETER |
| // For now, this only matters for interpreted methods. FIXME. |
| if (! _Jv_IsInterpretedClass (k)) |
| { |
| // FIXME: throw exception. |
| return JNI_ERR; |
| } |
| _Jv_InterpClass *klass = reinterpret_cast<_Jv_InterpClass *> (k); |
| |
| // Look at each descriptor given us, and find the corresponding |
| // method in the class. |
| for (int j = 0; j < nMethods; ++j) |
| { |
| bool found = false; |
| |
| _Jv_MethodBase **imeths = _Jv_GetFirstMethod (klass); |
| for (int i = 0; i < JvNumMethods (klass); ++i) |
| { |
| _Jv_MethodBase *meth = imeths[i]; |
| _Jv_Method *self = meth->get_method (); |
| |
| if (! strcmp (self->name->data, methods[j].name) |
| && ! strcmp (self->signature->data, methods[j].signature)) |
| { |
| if (! (self->accflags |
| & java::lang::reflect::Modifier::NATIVE)) |
| break; |
| |
| // Found a match that is native. |
| _Jv_JNIMethod *jmeth = reinterpret_cast<_Jv_JNIMethod *> (meth); |
| jmeth->set_function (methods[i].fnPtr); |
| found = true; |
| break; |
| } |
| } |
| |
| if (! found) |
| { |
| jstring m = JvNewStringUTF (methods[j].name); |
| try |
| { |
| env->ex =new java::lang::NoSuchMethodError (m); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| return JNI_ERR; |
| } |
| } |
| |
| return JNI_OK; |
| #else /* INTERPRETER */ |
| return JNI_ERR; |
| #endif /* INTERPRETER */ |
| } |
| |
| static jint |
| _Jv_JNI_UnregisterNatives (JNIEnv *, jclass) |
| { |
| return JNI_ERR; |
| } |
| |
| |
| |
| // Add a character to the buffer, encoding properly. |
| static void |
| add_char (char *buf, jchar c, int *here) |
| { |
| if (c == '_') |
| { |
| buf[(*here)++] = '_'; |
| buf[(*here)++] = '1'; |
| } |
| else if (c == ';') |
| { |
| buf[(*here)++] = '_'; |
| buf[(*here)++] = '2'; |
| } |
| else if (c == '[') |
| { |
| buf[(*here)++] = '_'; |
| buf[(*here)++] = '3'; |
| } |
| |
| // Also check for `.' here because we might be passed an internal |
| // qualified class name like `foo.bar'. |
| else if (c == '/' || c == '.') |
| buf[(*here)++] = '_'; |
| else if ((c >= '0' && c <= '9') |
| || (c >= 'a' && c <= 'z') |
| || (c >= 'A' && c <= 'Z')) |
| buf[(*here)++] = (char) c; |
| else |
| { |
| // "Unicode" character. |
| buf[(*here)++] = '_'; |
| buf[(*here)++] = '0'; |
| for (int i = 0; i < 4; ++i) |
| { |
| int val = c & 0x0f; |
| buf[(*here) + 3 - i] = (val > 10) ? ('a' + val - 10) : ('0' + val); |
| c >>= 4; |
| } |
| *here += 4; |
| } |
| } |
| |
| // Compute a mangled name for a native function. This computes the |
| // long name, and also returns an index which indicates where a NUL |
| // can be placed to create the short name. This function assumes that |
| // the buffer is large enough for its results. |
| static void |
| mangled_name (jclass klass, _Jv_Utf8Const *func_name, |
| _Jv_Utf8Const *signature, char *buf, int *long_start) |
| { |
| strcpy (buf, "Java_"); |
| int here = 5; |
| |
| // Add fully qualified class name. |
| jchar *chars = _Jv_GetStringChars (klass->getName ()); |
| jint len = klass->getName ()->length (); |
| for (int i = 0; i < len; ++i) |
| add_char (buf, chars[i], &here); |
| |
| // Don't use add_char because we need a literal `_'. |
| buf[here++] = '_'; |
| |
| const unsigned char *fn = (const unsigned char *) func_name->data; |
| const unsigned char *limit = fn + func_name->length; |
| for (int i = 0; ; ++i) |
| { |
| int ch = UTF8_GET (fn, limit); |
| if (ch < 0) |
| break; |
| add_char (buf, ch, &here); |
| } |
| |
| // This is where the long signature begins. |
| *long_start = here; |
| buf[here++] = '_'; |
| buf[here++] = '_'; |
| |
| const unsigned char *sig = (const unsigned char *) signature->data; |
| limit = sig + signature->length; |
| JvAssert (sig[0] == '('); |
| ++sig; |
| while (1) |
| { |
| int ch = UTF8_GET (sig, limit); |
| if (ch == ')' || ch < 0) |
| break; |
| add_char (buf, ch, &here); |
| } |
| |
| buf[here] = '\0'; |
| } |
| |
| // Return the current thread's JNIEnv; if one does not exist, create |
| // it. Also create a new system frame for use. This is `extern "C"' |
| // because the compiler calls it. |
| extern "C" JNIEnv * |
| _Jv_GetJNIEnvNewFrame (jclass klass) |
| { |
| JNIEnv *env = _Jv_GetCurrentJNIEnv (); |
| if (env == NULL) |
| { |
| env = (JNIEnv *) _Jv_MallocUnchecked (sizeof (JNIEnv)); |
| env->p = &_Jv_JNIFunctions; |
| env->ex = NULL; |
| env->klass = klass; |
| env->locals = NULL; |
| |
| _Jv_SetCurrentJNIEnv (env); |
| } |
| |
| _Jv_JNI_LocalFrame *frame |
| = (_Jv_JNI_LocalFrame *) _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame) |
| + (FRAME_SIZE |
| * sizeof (jobject))); |
| |
| frame->marker = MARK_SYSTEM; |
| frame->size = FRAME_SIZE; |
| frame->next = env->locals; |
| env->locals = frame; |
| |
| for (int i = 0; i < frame->size; ++i) |
| frame->vec[i] = NULL; |
| |
| return env; |
| } |
| |
| // Return the function which implements a particular JNI method. If |
| // we can't find the function, we throw the appropriate exception. |
| // This is `extern "C"' because the compiler uses it. |
| extern "C" void * |
| _Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name, |
| _Jv_Utf8Const *signature) |
| { |
| char buf[10 + 6 * (name->length + signature->length)]; |
| int long_start; |
| void *function; |
| |
| mangled_name (klass, name, signature, buf, &long_start); |
| char c = buf[long_start]; |
| buf[long_start] = '\0'; |
| function = _Jv_FindSymbolInExecutable (buf); |
| if (function == NULL) |
| { |
| buf[long_start] = c; |
| function = _Jv_FindSymbolInExecutable (buf); |
| if (function == NULL) |
| { |
| jstring str = JvNewStringUTF (name->data); |
| throw new java::lang::AbstractMethodError (str); |
| } |
| } |
| |
| return function; |
| } |
| |
| #ifdef INTERPRETER |
| |
| // This function is the stub which is used to turn an ordinary (CNI) |
| // method call into a JNI call. |
| void |
| _Jv_JNIMethod::call (ffi_cif *, void *ret, ffi_raw *args, void *__this) |
| { |
| _Jv_JNIMethod* _this = (_Jv_JNIMethod *) __this; |
| |
| JNIEnv *env = _Jv_GetJNIEnvNewFrame (_this->defining_class); |
| |
| // FIXME: we should mark every reference parameter as a local. For |
| // now we assume a conservative GC, and we assume that the |
| // references are on the stack somewhere. |
| |
| // We cache the value that we find, of course, but if we don't find |
| // a value we don't cache that fact -- we might subsequently load a |
| // library which finds the function in question. |
| if (_this->function == NULL) |
| _this->function = _Jv_LookupJNIMethod (_this->defining_class, |
| _this->self->name, |
| _this->self->signature); |
| |
| JvAssert (_this->args_raw_size % sizeof (ffi_raw) == 0); |
| ffi_raw real_args[2 + _this->args_raw_size / sizeof (ffi_raw)]; |
| int offset = 0; |
| |
| // First argument is always the environment pointer. |
| real_args[offset++].ptr = env; |
| |
| // For a static method, we pass in the Class. For non-static |
| // methods, the `this' argument is already handled. |
| if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC)) |
| real_args[offset++].ptr = _this->defining_class; |
| |
| // Copy over passed-in arguments. |
| memcpy (&real_args[offset], args, _this->args_raw_size); |
| |
| // The actual call to the JNI function. |
| ffi_raw_call (&_this->jni_cif, (void (*)()) _this->function, |
| ret, real_args); |
| |
| _Jv_JNI_PopSystemFrame (env); |
| } |
| |
| #endif /* INTERPRETER */ |
| |
| |
| |
| // |
| // Invocation API. |
| // |
| |
| // An internal helper function. |
| static jint |
| _Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv, void *args) |
| { |
| JavaVMAttachArgs *attach = reinterpret_cast<JavaVMAttachArgs *> (args); |
| java::lang::ThreadGroup *group = NULL; |
| |
| if (attach) |
| { |
| // FIXME: do we really want to support 1.1? |
| if (attach->version != JNI_VERSION_1_2 |
| && attach->version != JNI_VERSION_1_1) |
| return JNI_EVERSION; |
| |
| JvAssert ((&ThreadGroupClass)->isInstance (attach->group)); |
| group = reinterpret_cast<java::lang::ThreadGroup *> (attach->group); |
| } |
| |
| // Attaching an already-attached thread is a no-op. |
| if (_Jv_GetCurrentJNIEnv () != NULL) |
| return 0; |
| |
| JNIEnv *env = (JNIEnv *) _Jv_MallocUnchecked (sizeof (JNIEnv)); |
| if (env == NULL) |
| return JNI_ERR; |
| env->p = &_Jv_JNIFunctions; |
| env->ex = NULL; |
| env->klass = NULL; |
| env->locals |
| = (_Jv_JNI_LocalFrame *) _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame) |
| + (FRAME_SIZE |
| * sizeof (jobject))); |
| if (env->locals == NULL) |
| { |
| _Jv_Free (env); |
| return JNI_ERR; |
| } |
| *penv = reinterpret_cast<void *> (env); |
| |
| // This thread might already be a Java thread -- this function might |
| // have been called simply to set the new JNIEnv. |
| if (_Jv_ThreadCurrent () == NULL) |
| { |
| try |
| { |
| (void) new gnu::gcj::jni::NativeThread (group, name); |
| } |
| catch (jthrowable t) |
| { |
| return JNI_ERR; |
| } |
| } |
| _Jv_SetCurrentJNIEnv (env); |
| |
| return 0; |
| } |
| |
| // This is the one actually used by JNI. |
| static jint |
| _Jv_JNI_AttachCurrentThread (JavaVM *vm, void **penv, void *args) |
| { |
| return _Jv_JNI_AttachCurrentThread (vm, NULL, penv, args); |
| } |
| |
| static jint |
| _Jv_JNI_DestroyJavaVM (JavaVM *vm) |
| { |
| JvAssert (the_vm && vm == the_vm); |
| |
| JNIEnv *env; |
| if (_Jv_ThreadCurrent () != NULL) |
| { |
| jstring main_name; |
| // This sucks. |
| try |
| { |
| main_name = JvNewStringLatin1 ("main"); |
| } |
| catch (jthrowable t) |
| { |
| return JNI_ERR; |
| } |
| |
| jint r = _Jv_JNI_AttachCurrentThread (vm, |
| main_name, |
| reinterpret_cast<void **> (&env), |
| NULL); |
| if (r < 0) |
| return r; |
| } |
| else |
| env = _Jv_GetCurrentJNIEnv (); |
| |
| _Jv_ThreadWait (); |
| |
| // Docs say that this always returns an error code. |
| return JNI_ERR; |
| } |
| |
| static jint |
| _Jv_JNI_DetachCurrentThread (JavaVM *) |
| { |
| java::lang::Thread *t = _Jv_ThreadCurrent (); |
| if (t == NULL) |
| return JNI_EDETACHED; |
| |
| // FIXME: we only allow threads attached via AttachCurrentThread to |
| // be detached. I have no idea how we could implement detaching |
| // other threads, given the requirement that we must release all the |
| // monitors. That just seems evil. |
| JvAssert ((&NativeThreadClass)->isInstance (t)); |
| |
| // FIXME: release the monitors. We'll take this to mean all |
| // monitors acquired via the JNI interface. This means we have to |
| // keep track of them. |
| |
| gnu::gcj::jni::NativeThread *nt |
| = reinterpret_cast<gnu::gcj::jni::NativeThread *> (t); |
| nt->finish (); |
| |
| return 0; |
| } |
| |
| static jint |
| _Jv_JNI_GetEnv (JavaVM *, void **penv, jint version) |
| { |
| if (_Jv_ThreadCurrent () == NULL) |
| { |
| *penv = NULL; |
| return JNI_EDETACHED; |
| } |
| |
| #ifdef ENABLE_JVMPI |
| // Handle JVMPI requests. |
| if (version == JVMPI_VERSION_1) |
| { |
| *penv = (void *) &_Jv_JVMPI_Interface; |
| return 0; |
| } |
| #endif |
| |
| // FIXME: do we really want to support 1.1? |
| if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_1) |
| { |
| *penv = NULL; |
| return JNI_EVERSION; |
| } |
| |
| *penv = (void *) _Jv_GetCurrentJNIEnv (); |
| return 0; |
| } |
| |
| jint |
| JNI_GetDefaultJavaVMInitArgs (void *args) |
| { |
| jint version = * (jint *) args; |
| // Here we only support 1.2. |
| if (version != JNI_VERSION_1_2) |
| return JNI_EVERSION; |
| |
| JavaVMInitArgs *ia = reinterpret_cast<JavaVMInitArgs *> (args); |
| ia->version = JNI_VERSION_1_2; |
| ia->nOptions = 0; |
| ia->options = NULL; |
| ia->ignoreUnrecognized = true; |
| |
| return 0; |
| } |
| |
| jint |
| JNI_CreateJavaVM (JavaVM **vm, void **penv, void *args) |
| { |
| JvAssert (! the_vm); |
| // FIXME: synchronize |
| JavaVM *nvm = (JavaVM *) _Jv_MallocUnchecked (sizeof (JavaVM)); |
| if (nvm == NULL) |
| return JNI_ERR; |
| nvm->functions = &_Jv_JNI_InvokeFunctions; |
| |
| // Parse the arguments. |
| if (args != NULL) |
| { |
| jint version = * (jint *) args; |
| // We only support 1.2. |
| if (version != JNI_VERSION_1_2) |
| return JNI_EVERSION; |
| JavaVMInitArgs *ia = reinterpret_cast<JavaVMInitArgs *> (args); |
| for (int i = 0; i < ia->nOptions; ++i) |
| { |
| if (! strcmp (ia->options[i].optionString, "vfprintf") |
| || ! strcmp (ia->options[i].optionString, "exit") |
| || ! strcmp (ia->options[i].optionString, "abort")) |
| { |
| // We are required to recognize these, but for now we |
| // don't handle them in any way. FIXME. |
| continue; |
| } |
| else if (! strncmp (ia->options[i].optionString, |
| "-verbose", sizeof ("-verbose") - 1)) |
| { |
| // We don't do anything with this option either. We |
| // might want to make sure the argument is valid, but we |
| // don't really care all that much for now. |
| continue; |
| } |
| else if (! strncmp (ia->options[i].optionString, "-D", 2)) |
| { |
| // FIXME. |
| continue; |
| } |
| else if (ia->ignoreUnrecognized) |
| { |
| if (ia->options[i].optionString[0] == '_' |
| || ! strncmp (ia->options[i].optionString, "-X", 2)) |
| continue; |
| } |
| |
| return JNI_ERR; |
| } |
| } |
| |
| jint r =_Jv_JNI_AttachCurrentThread (nvm, penv, NULL); |
| if (r < 0) |
| return r; |
| |
| the_vm = nvm; |
| *vm = the_vm; |
| return 0; |
| } |
| |
| jint |
| JNI_GetCreatedJavaVMs (JavaVM **vm_buffer, jsize buf_len, jsize *n_vms) |
| { |
| if (buf_len <= 0) |
| return JNI_ERR; |
| |
| // We only support a single VM. |
| if (the_vm != NULL) |
| { |
| vm_buffer[0] = the_vm; |
| *n_vms = 1; |
| } |
| else |
| *n_vms = 0; |
| return 0; |
| } |
| |
| JavaVM * |
| _Jv_GetJavaVM () |
| { |
| // FIXME: synchronize |
| if (! the_vm) |
| { |
| JavaVM *nvm = (JavaVM *) _Jv_MallocUnchecked (sizeof (JavaVM)); |
| if (nvm != NULL) |
| nvm->functions = &_Jv_JNI_InvokeFunctions; |
| the_vm = nvm; |
| } |
| |
| // If this is a Java thread, we want to make sure it has an |
| // associated JNIEnv. |
| if (_Jv_ThreadCurrent () != NULL) |
| { |
| void *ignore; |
| _Jv_JNI_AttachCurrentThread (the_vm, &ignore, NULL); |
| } |
| |
| return the_vm; |
| } |
| |
| static jint |
| _Jv_JNI_GetJavaVM (JNIEnv *, JavaVM **vm) |
| { |
| *vm = _Jv_GetJavaVM (); |
| return *vm == NULL ? JNI_ERR : JNI_OK; |
| } |
| |
| |
| |
| #define NOT_IMPL NULL |
| #define RESERVED NULL |
| |
| struct JNINativeInterface _Jv_JNIFunctions = |
| { |
| RESERVED, |
| RESERVED, |
| RESERVED, |
| RESERVED, |
| _Jv_JNI_GetVersion, // GetVersion |
| _Jv_JNI_DefineClass, // DefineClass |
| _Jv_JNI_FindClass, // FindClass |
| _Jv_JNI_FromReflectedMethod, // FromReflectedMethod |
| _Jv_JNI_FromReflectedField, // FromReflectedField |
| _Jv_JNI_ToReflectedMethod, // ToReflectedMethod |
| _Jv_JNI_GetSuperclass, // GetSuperclass |
| _Jv_JNI_IsAssignableFrom, // IsAssignableFrom |
| _Jv_JNI_ToReflectedField, // ToReflectedField |
| _Jv_JNI_Throw, // Throw |
| _Jv_JNI_ThrowNew, // ThrowNew |
| _Jv_JNI_ExceptionOccurred, // ExceptionOccurred |
| _Jv_JNI_ExceptionDescribe, // ExceptionDescribe |
| _Jv_JNI_ExceptionClear, // ExceptionClear |
| _Jv_JNI_FatalError, // FatalError |
| |
| _Jv_JNI_PushLocalFrame, // PushLocalFrame |
| _Jv_JNI_PopLocalFrame, // PopLocalFrame |
| _Jv_JNI_NewGlobalRef, // NewGlobalRef |
| _Jv_JNI_DeleteGlobalRef, // DeleteGlobalRef |
| _Jv_JNI_DeleteLocalRef, // DeleteLocalRef |
| |
| _Jv_JNI_IsSameObject, // IsSameObject |
| |
| _Jv_JNI_NewLocalRef, // NewLocalRef |
| _Jv_JNI_EnsureLocalCapacity, // EnsureLocalCapacity |
| |
| _Jv_JNI_AllocObject, // AllocObject |
| _Jv_JNI_NewObject, // NewObject |
| _Jv_JNI_NewObjectV, // NewObjectV |
| _Jv_JNI_NewObjectA, // NewObjectA |
| _Jv_JNI_GetObjectClass, // GetObjectClass |
| _Jv_JNI_IsInstanceOf, // IsInstanceOf |
| _Jv_JNI_GetAnyMethodID<false>, // GetMethodID |
| |
| _Jv_JNI_CallMethod<jobject>, // CallObjectMethod |
| _Jv_JNI_CallMethodV<jobject>, // CallObjectMethodV |
| _Jv_JNI_CallMethodA<jobject>, // CallObjectMethodA |
| _Jv_JNI_CallMethod<jboolean>, // CallBooleanMethod |
| _Jv_JNI_CallMethodV<jboolean>, // CallBooleanMethodV |
| _Jv_JNI_CallMethodA<jboolean>, // CallBooleanMethodA |
| _Jv_JNI_CallMethod<jbyte>, // CallByteMethod |
| _Jv_JNI_CallMethodV<jbyte>, // CallByteMethodV |
| _Jv_JNI_CallMethodA<jbyte>, // CallByteMethodA |
| _Jv_JNI_CallMethod<jchar>, // CallCharMethod |
| _Jv_JNI_CallMethodV<jchar>, // CallCharMethodV |
| _Jv_JNI_CallMethodA<jchar>, // CallCharMethodA |
| _Jv_JNI_CallMethod<jshort>, // CallShortMethod |
| _Jv_JNI_CallMethodV<jshort>, // CallShortMethodV |
| _Jv_JNI_CallMethodA<jshort>, // CallShortMethodA |
| _Jv_JNI_CallMethod<jint>, // CallIntMethod |
| _Jv_JNI_CallMethodV<jint>, // CallIntMethodV |
| _Jv_JNI_CallMethodA<jint>, // CallIntMethodA |
| _Jv_JNI_CallMethod<jlong>, // CallLongMethod |
| _Jv_JNI_CallMethodV<jlong>, // CallLongMethodV |
| _Jv_JNI_CallMethodA<jlong>, // CallLongMethodA |
| _Jv_JNI_CallMethod<jfloat>, // CallFloatMethod |
| _Jv_JNI_CallMethodV<jfloat>, // CallFloatMethodV |
| _Jv_JNI_CallMethodA<jfloat>, // CallFloatMethodA |
| _Jv_JNI_CallMethod<jdouble>, // CallDoubleMethod |
| _Jv_JNI_CallMethodV<jdouble>, // CallDoubleMethodV |
| _Jv_JNI_CallMethodA<jdouble>, // CallDoubleMethodA |
| _Jv_JNI_CallVoidMethod, // CallVoidMethod |
| _Jv_JNI_CallVoidMethodV, // CallVoidMethodV |
| _Jv_JNI_CallVoidMethodA, // CallVoidMethodA |
| |
| // Nonvirtual method invocation functions follow. |
| _Jv_JNI_CallAnyMethod<jobject, nonvirtual>, // CallNonvirtualObjectMethod |
| _Jv_JNI_CallAnyMethodV<jobject, nonvirtual>, // CallNonvirtualObjectMethodV |
| _Jv_JNI_CallAnyMethodA<jobject, nonvirtual>, // CallNonvirtualObjectMethodA |
| _Jv_JNI_CallAnyMethod<jboolean, nonvirtual>, // CallNonvirtualBooleanMethod |
| _Jv_JNI_CallAnyMethodV<jboolean, nonvirtual>, // CallNonvirtualBooleanMethodV |
| _Jv_JNI_CallAnyMethodA<jboolean, nonvirtual>, // CallNonvirtualBooleanMethodA |
| _Jv_JNI_CallAnyMethod<jbyte, nonvirtual>, // CallNonvirtualByteMethod |
| _Jv_JNI_CallAnyMethodV<jbyte, nonvirtual>, // CallNonvirtualByteMethodV |
| _Jv_JNI_CallAnyMethodA<jbyte, nonvirtual>, // CallNonvirtualByteMethodA |
| _Jv_JNI_CallAnyMethod<jchar, nonvirtual>, // CallNonvirtualCharMethod |
| _Jv_JNI_CallAnyMethodV<jchar, nonvirtual>, // CallNonvirtualCharMethodV |
| _Jv_JNI_CallAnyMethodA<jchar, nonvirtual>, // CallNonvirtualCharMethodA |
| _Jv_JNI_CallAnyMethod<jshort, nonvirtual>, // CallNonvirtualShortMethod |
| _Jv_JNI_CallAnyMethodV<jshort, nonvirtual>, // CallNonvirtualShortMethodV |
| _Jv_JNI_CallAnyMethodA<jshort, nonvirtual>, // CallNonvirtualShortMethodA |
| _Jv_JNI_CallAnyMethod<jint, nonvirtual>, // CallNonvirtualIntMethod |
| _Jv_JNI_CallAnyMethodV<jint, nonvirtual>, // CallNonvirtualIntMethodV |
| _Jv_JNI_CallAnyMethodA<jint, nonvirtual>, // CallNonvirtualIntMethodA |
| _Jv_JNI_CallAnyMethod<jlong, nonvirtual>, // CallNonvirtualLongMethod |
| _Jv_JNI_CallAnyMethodV<jlong, nonvirtual>, // CallNonvirtualLongMethodV |
| _Jv_JNI_CallAnyMethodA<jlong, nonvirtual>, // CallNonvirtualLongMethodA |
| _Jv_JNI_CallAnyMethod<jfloat, nonvirtual>, // CallNonvirtualFloatMethod |
| _Jv_JNI_CallAnyMethodV<jfloat, nonvirtual>, // CallNonvirtualFloatMethodV |
| _Jv_JNI_CallAnyMethodA<jfloat, nonvirtual>, // CallNonvirtualFloatMethodA |
| _Jv_JNI_CallAnyMethod<jdouble, nonvirtual>, // CallNonvirtualDoubleMethod |
| _Jv_JNI_CallAnyMethodV<jdouble, nonvirtual>, // CallNonvirtualDoubleMethodV |
| _Jv_JNI_CallAnyMethodA<jdouble, nonvirtual>, // CallNonvirtualDoubleMethodA |
| _Jv_JNI_CallAnyVoidMethod<nonvirtual>, // CallNonvirtualVoidMethod |
| _Jv_JNI_CallAnyVoidMethodV<nonvirtual>, // CallNonvirtualVoidMethodV |
| _Jv_JNI_CallAnyVoidMethodA<nonvirtual>, // CallNonvirtualVoidMethodA |
| |
| _Jv_JNI_GetAnyFieldID<false>, // GetFieldID |
| _Jv_JNI_GetField<jobject>, // GetObjectField |
| _Jv_JNI_GetField<jboolean>, // GetBooleanField |
| _Jv_JNI_GetField<jbyte>, // GetByteField |
| _Jv_JNI_GetField<jchar>, // GetCharField |
| _Jv_JNI_GetField<jshort>, // GetShortField |
| _Jv_JNI_GetField<jint>, // GetIntField |
| _Jv_JNI_GetField<jlong>, // GetLongField |
| _Jv_JNI_GetField<jfloat>, // GetFloatField |
| _Jv_JNI_GetField<jdouble>, // GetDoubleField |
| _Jv_JNI_SetField, // SetObjectField |
| _Jv_JNI_SetField, // SetBooleanField |
| _Jv_JNI_SetField, // SetByteField |
| _Jv_JNI_SetField, // SetCharField |
| _Jv_JNI_SetField, // SetShortField |
| _Jv_JNI_SetField, // SetIntField |
| _Jv_JNI_SetField, // SetLongField |
| _Jv_JNI_SetField, // SetFloatField |
| _Jv_JNI_SetField, // SetDoubleField |
| _Jv_JNI_GetAnyMethodID<true>, // GetStaticMethodID |
| |
| _Jv_JNI_CallStaticMethod<jobject>, // CallStaticObjectMethod |
| _Jv_JNI_CallStaticMethodV<jobject>, // CallStaticObjectMethodV |
| _Jv_JNI_CallStaticMethodA<jobject>, // CallStaticObjectMethodA |
| _Jv_JNI_CallStaticMethod<jboolean>, // CallStaticBooleanMethod |
| _Jv_JNI_CallStaticMethodV<jboolean>, // CallStaticBooleanMethodV |
| _Jv_JNI_CallStaticMethodA<jboolean>, // CallStaticBooleanMethodA |
| _Jv_JNI_CallStaticMethod<jbyte>, // CallStaticByteMethod |
| _Jv_JNI_CallStaticMethodV<jbyte>, // CallStaticByteMethodV |
| _Jv_JNI_CallStaticMethodA<jbyte>, // CallStaticByteMethodA |
| _Jv_JNI_CallStaticMethod<jchar>, // CallStaticCharMethod |
| _Jv_JNI_CallStaticMethodV<jchar>, // CallStaticCharMethodV |
| _Jv_JNI_CallStaticMethodA<jchar>, // CallStaticCharMethodA |
| _Jv_JNI_CallStaticMethod<jshort>, // CallStaticShortMethod |
| _Jv_JNI_CallStaticMethodV<jshort>, // CallStaticShortMethodV |
| _Jv_JNI_CallStaticMethodA<jshort>, // CallStaticShortMethodA |
| _Jv_JNI_CallStaticMethod<jint>, // CallStaticIntMethod |
| _Jv_JNI_CallStaticMethodV<jint>, // CallStaticIntMethodV |
| _Jv_JNI_CallStaticMethodA<jint>, // CallStaticIntMethodA |
| _Jv_JNI_CallStaticMethod<jlong>, // CallStaticLongMethod |
| _Jv_JNI_CallStaticMethodV<jlong>, // CallStaticLongMethodV |
| _Jv_JNI_CallStaticMethodA<jlong>, // CallStaticLongMethodA |
| _Jv_JNI_CallStaticMethod<jfloat>, // CallStaticFloatMethod |
| _Jv_JNI_CallStaticMethodV<jfloat>, // CallStaticFloatMethodV |
| _Jv_JNI_CallStaticMethodA<jfloat>, // CallStaticFloatMethodA |
| _Jv_JNI_CallStaticMethod<jdouble>, // CallStaticDoubleMethod |
| _Jv_JNI_CallStaticMethodV<jdouble>, // CallStaticDoubleMethodV |
| _Jv_JNI_CallStaticMethodA<jdouble>, // CallStaticDoubleMethodA |
| _Jv_JNI_CallStaticVoidMethod, // CallStaticVoidMethod |
| _Jv_JNI_CallStaticVoidMethodV, // CallStaticVoidMethodV |
| _Jv_JNI_CallStaticVoidMethodA, // CallStaticVoidMethodA |
| |
| _Jv_JNI_GetAnyFieldID<true>, // GetStaticFieldID |
| _Jv_JNI_GetStaticField<jobject>, // GetStaticObjectField |
| _Jv_JNI_GetStaticField<jboolean>, // GetStaticBooleanField |
| _Jv_JNI_GetStaticField<jbyte>, // GetStaticByteField |
| _Jv_JNI_GetStaticField<jchar>, // GetStaticCharField |
| _Jv_JNI_GetStaticField<jshort>, // GetStaticShortField |
| _Jv_JNI_GetStaticField<jint>, // GetStaticIntField |
| _Jv_JNI_GetStaticField<jlong>, // GetStaticLongField |
| _Jv_JNI_GetStaticField<jfloat>, // GetStaticFloatField |
| _Jv_JNI_GetStaticField<jdouble>, // GetStaticDoubleField |
| _Jv_JNI_SetStaticField, // SetStaticObjectField |
| _Jv_JNI_SetStaticField, // SetStaticBooleanField |
| _Jv_JNI_SetStaticField, // SetStaticByteField |
| _Jv_JNI_SetStaticField, // SetStaticCharField |
| _Jv_JNI_SetStaticField, // SetStaticShortField |
| _Jv_JNI_SetStaticField, // SetStaticIntField |
| _Jv_JNI_SetStaticField, // SetStaticLongField |
| _Jv_JNI_SetStaticField, // SetStaticFloatField |
| _Jv_JNI_SetStaticField, // SetStaticDoubleField |
| _Jv_JNI_NewString, // NewString |
| _Jv_JNI_GetStringLength, // GetStringLength |
| _Jv_JNI_GetStringChars, // GetStringChars |
| _Jv_JNI_ReleaseStringChars, // ReleaseStringChars |
| _Jv_JNI_NewStringUTF, // NewStringUTF |
| _Jv_JNI_GetStringUTFLength, // GetStringUTFLength |
| _Jv_JNI_GetStringUTFChars, // GetStringUTFLength |
| _Jv_JNI_ReleaseStringUTFChars, // ReleaseStringUTFChars |
| _Jv_JNI_GetArrayLength, // GetArrayLength |
| _Jv_JNI_NewObjectArray, // NewObjectArray |
| _Jv_JNI_GetObjectArrayElement, // GetObjectArrayElement |
| _Jv_JNI_SetObjectArrayElement, // SetObjectArrayElement |
| _Jv_JNI_NewPrimitiveArray<jboolean, JvPrimClass (boolean)>, |
| // NewBooleanArray |
| _Jv_JNI_NewPrimitiveArray<jbyte, JvPrimClass (byte)>, // NewByteArray |
| _Jv_JNI_NewPrimitiveArray<jchar, JvPrimClass (char)>, // NewCharArray |
| _Jv_JNI_NewPrimitiveArray<jshort, JvPrimClass (short)>, // NewShortArray |
| _Jv_JNI_NewPrimitiveArray<jint, JvPrimClass (int)>, // NewIntArray |
| _Jv_JNI_NewPrimitiveArray<jlong, JvPrimClass (long)>, // NewLongArray |
| _Jv_JNI_NewPrimitiveArray<jfloat, JvPrimClass (float)>, // NewFloatArray |
| _Jv_JNI_NewPrimitiveArray<jdouble, JvPrimClass (double)>, // NewDoubleArray |
| _Jv_JNI_GetPrimitiveArrayElements, // GetBooleanArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements, // GetByteArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements, // GetCharArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements, // GetShortArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements, // GetIntArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements, // GetLongArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements, // GetFloatArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements, // GetDoubleArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseBooleanArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseByteArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseCharArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseShortArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseIntArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseLongArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseFloatArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements, // ReleaseDoubleArrayElements |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetBooleanArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetByteArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetCharArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetShortArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetIntArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetLongArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetFloatArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion, // GetDoubleArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetBooleanArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetByteArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetCharArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetShortArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetIntArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetLongArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetFloatArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion, // SetDoubleArrayRegion |
| _Jv_JNI_RegisterNatives, // RegisterNatives |
| _Jv_JNI_UnregisterNatives, // UnregisterNatives |
| _Jv_JNI_MonitorEnter, // MonitorEnter |
| _Jv_JNI_MonitorExit, // MonitorExit |
| _Jv_JNI_GetJavaVM, // GetJavaVM |
| |
| _Jv_JNI_GetStringRegion, // GetStringRegion |
| _Jv_JNI_GetStringUTFRegion, // GetStringUTFRegion |
| _Jv_JNI_GetPrimitiveArrayCritical, // GetPrimitiveArrayCritical |
| _Jv_JNI_ReleasePrimitiveArrayCritical, // ReleasePrimitiveArrayCritical |
| _Jv_JNI_GetStringCritical, // GetStringCritical |
| _Jv_JNI_ReleaseStringCritical, // ReleaseStringCritical |
| |
| NOT_IMPL /* newweakglobalref */, |
| NOT_IMPL /* deleteweakglobalref */, |
| |
| _Jv_JNI_ExceptionCheck |
| }; |
| |
| struct JNIInvokeInterface _Jv_JNI_InvokeFunctions = |
| { |
| RESERVED, |
| RESERVED, |
| RESERVED, |
| |
| _Jv_JNI_DestroyJavaVM, |
| _Jv_JNI_AttachCurrentThread, |
| _Jv_JNI_DetachCurrentThread, |
| _Jv_JNI_GetEnv |
| }; |