| // jni.cc - JNI implementation, including the jump table. |
| |
| /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 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 <stdio.h> |
| #include <stddef.h> |
| #include <string.h> |
| |
| #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/UnsatisfiedLinkError.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/lang/Integer.h> |
| #include <java/lang/ThreadGroup.h> |
| #include <java/lang/Thread.h> |
| #include <java/lang/IllegalAccessError.h> |
| #include <java/nio/DirectByteBufferImpl.h> |
| #include <java/util/IdentityHashMap.h> |
| #include <gnu/gcj/RawData.h> |
| |
| #include <gcj/method.h> |
| #include <gcj/field.h> |
| |
| #include <java-interp.h> |
| #include <java-threads.h> |
| |
| using namespace gcj; |
| |
| // 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 references. |
| static java::util::IdentityHashMap *local_ref_table; |
| // This holds a reference count for all global references. |
| static java::util::IdentityHashMap *global_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) |
| { |
| local_ref_table = new java::util::IdentityHashMap; |
| global_ref_table = new java::util::IdentityHashMap; |
| |
| #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, java::util::IdentityHashMap *ref_table) |
| { |
| 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, java::util::IdentityHashMap *ref_table) |
| { |
| JvSynchronize sync (ref_table); |
| |
| using namespace java::lang; |
| Integer *refcount = (Integer *) ref_table->get (obj); |
| JvAssert (refcount); |
| jint val = refcount->intValue () - 1; |
| JvAssert (val >= 0); |
| if (val == 0) |
| ref_table->remove (obj); |
| else |
| // FIXME: what about out of memory error? |
| ref_table->put (obj, new Integer (val)); |
| } |
| |
| // "Unwrap" some random non-reference type. This exists to simplify |
| // other template functions. |
| template<typename T> |
| static T |
| unwrap (T val) |
| { |
| return val; |
| } |
| |
| // Unwrap a weak reference, if required. |
| template<typename T> |
| static T * |
| unwrap (T *obj) |
| { |
| using namespace gnu::gcj::runtime; |
| // We can compare the class directly because JNIWeakRef is `final'. |
| // Doing it this way is much faster. |
| if (obj == NULL || obj->getClass () != &JNIWeakRef::class$) |
| return obj; |
| JNIWeakRef *wr = reinterpret_cast<JNIWeakRef *> (obj); |
| return reinterpret_cast<T *> (wr->get ()); |
| } |
| |
| |
| |
| static jobject |
| (JNICALL _Jv_JNI_NewGlobalRef) (JNIEnv *, jobject obj) |
| { |
| // This seems weird but I think it is correct. |
| obj = unwrap (obj); |
| mark_for_gc (obj, global_ref_table); |
| return obj; |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_DeleteGlobalRef) (JNIEnv *, jobject obj) |
| { |
| // This seems weird but I think it is correct. |
| obj = unwrap (obj); |
| unmark_for_gc (obj, global_ref_table); |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_DeleteLocalRef) (JNIEnv *env, jobject obj) |
| { |
| _Jv_JNI_LocalFrame *frame; |
| |
| // This seems weird but I think it is correct. |
| obj = unwrap (obj); |
| |
| 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, local_ref_table); |
| return; |
| } |
| } |
| |
| // Don't go past a marked frame. |
| JvAssert (frame->marker == MARK_NONE); |
| } |
| |
| JvAssert (0); |
| } |
| |
| static jint |
| (JNICALL _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 |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_NewLocalRef) (JNIEnv *env, jobject obj) |
| { |
| // This seems weird but I think it is correct. |
| obj = unwrap (obj); |
| |
| // Try to find an open slot somewhere in the topmost frame. |
| _Jv_JNI_LocalFrame *frame = env->locals; |
| bool done = false, set = false; |
| for (; frame != NULL && ! done; frame = frame->next) |
| { |
| for (int i = 0; i < frame->size; ++i) |
| { |
| if (frame->vec[i] == NULL) |
| { |
| set = true; |
| done = true; |
| frame->vec[i] = obj; |
| break; |
| } |
| } |
| |
| // If we found a slot, or if the frame we just searched is the |
| // mark frame, then we are done. |
| if (done || frame == NULL || frame->marker != MARK_NONE) |
| 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, local_ref_table); |
| return obj; |
| } |
| |
| static jobject |
| (JNICALL _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], local_ref_table); |
| |
| // 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 |
| (JNICALL _Jv_JNI_PopLocalFrame) (JNIEnv *env, jobject result) |
| { |
| return _Jv_JNI_PopLocalFrame (env, result, MARK_USER); |
| } |
| |
| // Make sure an array's type is compatible with the type of the |
| // destination. |
| template<typename T> |
| static bool |
| _Jv_JNI_check_types (JNIEnv *env, JArray<T> *array, jclass K) |
| { |
| jclass klass = array->getClass()->getComponentType(); |
| if (__builtin_expect (klass != K, false)) |
| { |
| env->ex = new java::lang::IllegalAccessError (); |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| // 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; |
| } |
| } |
| |
| template<typename T> T extract_from_jvalue(jvalue const & t); |
| template<> jboolean extract_from_jvalue(jvalue const & jv) { return jv.z; } |
| template<> jbyte extract_from_jvalue(jvalue const & jv) { return jv.b; } |
| template<> jchar extract_from_jvalue(jvalue const & jv) { return jv.c; } |
| template<> jshort extract_from_jvalue(jvalue const & jv) { return jv.s; } |
| template<> jint extract_from_jvalue(jvalue const & jv) { return jv.i; } |
| template<> jlong extract_from_jvalue(jvalue const & jv) { return jv.j; } |
| template<> jfloat extract_from_jvalue(jvalue const & jv) { return jv.f; } |
| template<> jdouble extract_from_jvalue(jvalue const & jv) { return jv.d; } |
| template<> jobject extract_from_jvalue(jvalue const & jv) { return jv.l; } |
| |
| |
| // 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 R, typename T> |
| static T * |
| wrap_value (JNIEnv *env, T *value) |
| { |
| return (value == NULL |
| ? value |
| : (T *) _Jv_JNI_NewLocalRef (env, (jobject) value)); |
| } |
| |
| |
| |
| static jint |
| (JNICALL _Jv_JNI_GetVersion) (JNIEnv *) |
| { |
| return JNI_VERSION_1_4; |
| } |
| |
| static jclass |
| (JNICALL _Jv_JNI_DefineClass) (JNIEnv *env, const char *name, jobject loader, |
| const jbyte *buf, jsize bufLen) |
| { |
| try |
| { |
| loader = unwrap (loader); |
| |
| jstring sname = JvNewStringUTF (name); |
| 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 (sname, bytes, 0, bufLen); |
| return (jclass) wrap_value (env, result); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static jclass |
| (JNICALL _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->getClassLoaderInternal (); |
| |
| 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 |
| (JNICALL _Jv_JNI_GetSuperclass) (JNIEnv *env, jclass clazz) |
| { |
| return (jclass) wrap_value (env, unwrap (clazz)->getSuperclass ()); |
| } |
| |
| static jboolean |
| (JNICALL _Jv_JNI_IsAssignableFrom) (JNIEnv *, jclass clazz1, jclass clazz2) |
| { |
| return unwrap (clazz1)->isAssignableFrom (unwrap (clazz2)); |
| } |
| |
| static jint |
| (JNICALL _Jv_JNI_Throw) (JNIEnv *env, jthrowable obj) |
| { |
| // We check in case the user did some funky cast. |
| obj = unwrap (obj); |
| JvAssert (obj != NULL && java::lang::Throwable::class$.isInstance (obj)); |
| env->ex = obj; |
| return 0; |
| } |
| |
| static jint |
| (JNICALL _Jv_JNI_ThrowNew) (JNIEnv *env, jclass clazz, const char *message) |
| { |
| using namespace java::lang::reflect; |
| |
| clazz = unwrap (clazz); |
| JvAssert (java::lang::Throwable::class$.isAssignableFrom (clazz)); |
| |
| int r = JNI_OK; |
| try |
| { |
| JArray<jclass> *argtypes |
| = (JArray<jclass> *) JvNewObjectArray (1, &java::lang::Class::class$, |
| 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 |
| (JNICALL _Jv_JNI_ExceptionOccurred) (JNIEnv *env) |
| { |
| return (jthrowable) wrap_value (env, env->ex); |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_ExceptionDescribe) (JNIEnv *env) |
| { |
| if (env->ex != NULL) |
| env->ex->printStackTrace(); |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_ExceptionClear) (JNIEnv *env) |
| { |
| env->ex = NULL; |
| } |
| |
| static jboolean |
| (JNICALL _Jv_JNI_ExceptionCheck) (JNIEnv *env) |
| { |
| return env->ex != NULL; |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_FatalError) (JNIEnv *, const char *message) |
| { |
| JvFail (message); |
| } |
| |
| |
| |
| static jboolean |
| (JNICALL _Jv_JNI_IsSameObject) (JNIEnv *, jobject obj1, jobject obj2) |
| { |
| return unwrap (obj1) == unwrap (obj2); |
| } |
| |
| static jobject |
| (JNICALL _Jv_JNI_AllocObject) (JNIEnv *env, jclass clazz) |
| { |
| jobject obj = NULL; |
| using namespace java::lang::reflect; |
| |
| try |
| { |
| clazz = unwrap (clazz); |
| JvAssert (clazz && ! clazz->isArray ()); |
| if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers())) |
| env->ex = new java::lang::InstantiationException (); |
| else |
| obj = JvAllocObject (clazz); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return wrap_value (env, obj); |
| } |
| |
| static jclass |
| (JNICALL _Jv_JNI_GetObjectClass) (JNIEnv *env, jobject obj) |
| { |
| obj = unwrap (obj); |
| JvAssert (obj); |
| return (jclass) wrap_value (env, obj->getClass()); |
| } |
| |
| static jboolean |
| (JNICALL _Jv_JNI_IsInstanceOf) (JNIEnv *, jobject obj, jclass clazz) |
| { |
| return unwrap (clazz)->isInstance(unwrap (obj)); |
| } |
| |
| |
| |
| // |
| // This section concerns method invocation. |
| // |
| |
| template<jboolean is_static> |
| static jmethodID |
| (JNICALL _Jv_JNI_GetAnyMethodID) (JNIEnv *env, jclass clazz, |
| const char *name, const char *sig) |
| { |
| try |
| { |
| clazz = unwrap (clazz); |
| _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) |
| { |
| // Here we assume that sizeof(int) >= sizeof(jint), because we |
| // use `int' when decoding the varargs. Likewise for |
| // float, and double. Also we assume that sizeof(jlong) >= |
| // sizeof(int), i.e. that jlong values are not further |
| // promoted. |
| JvAssert (sizeof (int) >= sizeof (jint)); |
| JvAssert (sizeof (jlong) >= sizeof (int)); |
| JvAssert (sizeof (double) >= sizeof (jfloat)); |
| JvAssert (sizeof (double) >= sizeof (jdouble)); |
| if (arg_elts[i] == JvPrimClass (byte)) |
| values[i].b = (jbyte) va_arg (vargs, int); |
| else if (arg_elts[i] == JvPrimClass (short)) |
| values[i].s = (jshort) va_arg (vargs, int); |
| else if (arg_elts[i] == JvPrimClass (int)) |
| values[i].i = (jint) va_arg (vargs, int); |
| else if (arg_elts[i] == JvPrimClass (long)) |
| values[i].j = (jlong) va_arg (vargs, jlong); |
| else if (arg_elts[i] == JvPrimClass (float)) |
| values[i].f = (jfloat) va_arg (vargs, double); |
| else if (arg_elts[i] == JvPrimClass (double)) |
| values[i].d = (jdouble) va_arg (vargs, double); |
| else if (arg_elts[i] == JvPrimClass (boolean)) |
| values[i].z = (jboolean) va_arg (vargs, int); |
| else if (arg_elts[i] == JvPrimClass (char)) |
| values[i].c = (jchar) va_arg (vargs, int); |
| else |
| { |
| // An object. |
| values[i].l = unwrap (va_arg (vargs, jobject)); |
| } |
| } |
| } |
| |
| // This can call any sort of method: virtual, "nonvirtual", static, or |
| // constructor. |
| template<typename T, invocation_type style> |
| static T |
| (JNICALL _Jv_JNI_CallAnyMethodV) (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, va_list vargs) |
| { |
| obj = unwrap (obj); |
| klass = unwrap (klass); |
| |
| 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; |
| _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| style == normal, |
| arg_types, args, &result); |
| |
| return wrap_value (env, extract_from_jvalue<T>(result)); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return wrap_value (env, (T) 0); |
| } |
| |
| template<typename T, invocation_type style> |
| static T |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_CallAnyMethodA) (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, jvalue *args) |
| { |
| obj = unwrap (obj); |
| klass = unwrap (klass); |
| |
| 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; |
| |
| // Unwrap arguments as required. Eww. |
| jclass *type_elts = elements (arg_types); |
| jvalue arg_copy[arg_types->length]; |
| for (int i = 0; i < arg_types->length; ++i) |
| { |
| if (type_elts[i]->isPrimitive ()) |
| arg_copy[i] = args[i]; |
| else |
| arg_copy[i].l = unwrap (args[i].l); |
| } |
| |
| jvalue result; |
| _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| style == normal, |
| arg_types, arg_copy, &result); |
| |
| return wrap_value (env, extract_from_jvalue<T>(result)); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return wrap_value (env, (T) 0); |
| } |
| |
| template<invocation_type style> |
| static void |
| (JNICALL _Jv_JNI_CallAnyVoidMethodV) (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, va_list vargs) |
| { |
| obj = unwrap (obj); |
| klass = unwrap (klass); |
| |
| 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; |
| |
| _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| style == normal, |
| arg_types, args, NULL); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| |
| template<invocation_type style> |
| static void |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_CallAnyVoidMethodA) (JNIEnv *env, jobject obj, jclass klass, |
| jmethodID id, jvalue *args) |
| { |
| 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); |
| |
| // Unwrap arguments as required. Eww. |
| jclass *type_elts = elements (arg_types); |
| jvalue arg_copy[arg_types->length]; |
| for (int i = 0; i < arg_types->length; ++i) |
| { |
| if (type_elts[i]->isPrimitive ()) |
| arg_copy[i] = args[i]; |
| else |
| arg_copy[i].l = unwrap (args[i].l); |
| } |
| |
| _Jv_CallAnyMethodA (obj, return_type, id, |
| style == constructor, |
| style == normal, |
| arg_types, args, NULL); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| |
| // Functions with this signature are used to implement functions in |
| // the CallMethod family. |
| template<typename T> |
| static T |
| (JNICALL _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 |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_CallMethodA) (JNIEnv *env, jobject obj, |
| jmethodID id, jvalue *args) |
| { |
| return _Jv_JNI_CallAnyMethodA<T, normal> (env, obj, NULL, id, args); |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_CallVoidMethodV) (JNIEnv *env, jobject obj, |
| jmethodID id, va_list args) |
| { |
| _Jv_JNI_CallAnyVoidMethodV<normal> (env, obj, NULL, id, args); |
| } |
| |
| static void |
| (JNICALL _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 |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_CallStaticMethodV) (JNIEnv *env, jclass klass, |
| jmethodID id, va_list args) |
| { |
| JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC)); |
| JvAssert (java::lang::Class::class$.isInstance (unwrap (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 |
| (JNICALL _Jv_JNI_CallStaticMethod) (JNIEnv *env, jclass klass, |
| jmethodID id, ...) |
| { |
| va_list args; |
| T result; |
| |
| JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC)); |
| JvAssert (java::lang::Class::class$.isInstance (unwrap (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 |
| (JNICALL _Jv_JNI_CallStaticMethodA) (JNIEnv *env, jclass klass, jmethodID id, |
| jvalue *args) |
| { |
| JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC)); |
| JvAssert (java::lang::Class::class$.isInstance (unwrap (klass))); |
| |
| return _Jv_JNI_CallAnyMethodA<T, static_type> (env, NULL, klass, id, args); |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_CallStaticVoidMethodV) (JNIEnv *env, jclass klass, |
| jmethodID id, va_list args) |
| { |
| _Jv_JNI_CallAnyVoidMethodV<static_type> (env, NULL, klass, id, args); |
| } |
| |
| static void |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_CallStaticVoidMethodA) (JNIEnv *env, jclass klass, |
| jmethodID id, jvalue *args) |
| { |
| _Jv_JNI_CallAnyVoidMethodA<static_type> (env, NULL, klass, id, args); |
| } |
| |
| static jobject |
| (JNICALL _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 |
| (JNICALL _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 |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_GetField) (JNIEnv *env, jobject obj, jfieldID field) |
| { |
| obj = unwrap (obj); |
| JvAssert (obj); |
| T *ptr = (T *) ((char *) obj + field->getOffset ()); |
| return wrap_value (env, *ptr); |
| } |
| |
| template<typename T> |
| static void |
| (JNICALL _Jv_JNI_SetField) (JNIEnv *, jobject obj, jfieldID field, T value) |
| { |
| obj = unwrap (obj); |
| value = unwrap (value); |
| |
| JvAssert (obj); |
| T *ptr = (T *) ((char *) obj + field->getOffset ()); |
| *ptr = value; |
| } |
| |
| template<jboolean is_static> |
| static jfieldID |
| (JNICALL _Jv_JNI_GetAnyFieldID) (JNIEnv *env, jclass clazz, |
| const char *name, const char *sig) |
| { |
| try |
| { |
| clazz = unwrap (clazz); |
| |
| _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->getClassLoaderInternal (); |
| 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 |
| (JNICALL _Jv_JNI_GetStaticField) (JNIEnv *env, jclass, jfieldID field) |
| { |
| T *ptr = (T *) field->u.addr; |
| return wrap_value (env, *ptr); |
| } |
| |
| template<typename T> |
| static void |
| (JNICALL _Jv_JNI_SetStaticField) (JNIEnv *, jclass, jfieldID field, T value) |
| { |
| value = unwrap (value); |
| T *ptr = (T *) field->u.addr; |
| *ptr = value; |
| } |
| |
| static jstring |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_GetStringLength) (JNIEnv *, jstring string) |
| { |
| return unwrap (string)->length(); |
| } |
| |
| static const jchar * |
| (JNICALL _Jv_JNI_GetStringChars) (JNIEnv *, jstring string, jboolean *isCopy) |
| { |
| string = unwrap (string); |
| jchar *result = _Jv_GetStringChars (string); |
| mark_for_gc (string, global_ref_table); |
| if (isCopy) |
| *isCopy = false; |
| return (const jchar *) result; |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_ReleaseStringChars) (JNIEnv *, jstring string, const jchar *) |
| { |
| unmark_for_gc (unwrap (string), global_ref_table); |
| } |
| |
| static jstring |
| (JNICALL _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 |
| (JNICALL _Jv_JNI_GetStringUTFLength) (JNIEnv *, jstring string) |
| { |
| return JvGetStringUTFLength (unwrap (string)); |
| } |
| |
| static const char * |
| (JNICALL _Jv_JNI_GetStringUTFChars) (JNIEnv *env, jstring string, |
| jboolean *isCopy) |
| { |
| try |
| { |
| string = unwrap (string); |
| if (string == NULL) |
| return NULL; |
| jsize len = JvGetStringUTFLength (string); |
| char *r = (char *) _Jv_Malloc (len + 1); |
| JvGetStringUTFRegion (string, 0, string->length(), r); |
| r[len] = '\0'; |
| |
| if (isCopy) |
| *isCopy = true; |
| |
| return (const char *) r; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_ReleaseStringUTFChars) (JNIEnv *, jstring, const char *utf) |
| { |
| _Jv_Free ((void *) utf); |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_GetStringRegion) (JNIEnv *env, jstring string, jsize start, |
| jsize len, jchar *buf) |
| { |
| string = unwrap (string); |
| 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 |
| (JNICALL _Jv_JNI_GetStringUTFRegion) (JNIEnv *env, jstring str, jsize start, |
| jsize len, char *buf) |
| { |
| str = unwrap (str); |
| |
| 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 * |
| (JNICALL _Jv_JNI_GetStringCritical) (JNIEnv *, jstring str, jboolean *isCopy) |
| { |
| jchar *result = _Jv_GetStringChars (unwrap (str)); |
| if (isCopy) |
| *isCopy = false; |
| return result; |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_ReleaseStringCritical) (JNIEnv *, jstring, const jchar *) |
| { |
| // Nothing. |
| } |
| |
| static jsize |
| (JNICALL _Jv_JNI_GetArrayLength) (JNIEnv *, jarray array) |
| { |
| return unwrap (array)->length; |
| } |
| |
| static jarray |
| (JNICALL _Jv_JNI_NewObjectArray) (JNIEnv *env, jsize length, |
| jclass elementClass, jobject init) |
| { |
| try |
| { |
| elementClass = unwrap (elementClass); |
| init = unwrap (init); |
| |
| _Jv_CheckCast (elementClass, init); |
| jarray result = JvNewObjectArray (length, elementClass, init); |
| return (jarray) wrap_value (env, result); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| return NULL; |
| } |
| } |
| |
| static jobject |
| (JNICALL _Jv_JNI_GetObjectArrayElement) (JNIEnv *env, jobjectArray array, |
| jsize index) |
| { |
| if ((unsigned) index >= (unsigned) array->length) |
| _Jv_ThrowBadArrayIndex (index); |
| jobject *elts = elements (unwrap (array)); |
| return wrap_value (env, elts[index]); |
| } |
| |
| static void |
| (JNICALL _Jv_JNI_SetObjectArrayElement) (JNIEnv *env, jobjectArray array, |
| jsize index, jobject value) |
| { |
| try |
| { |
| array = unwrap (array); |
| value = unwrap (value); |
| |
| _Jv_CheckArrayStore (array, value); |
| if ((unsigned) index >= (unsigned) array->length) |
| _Jv_ThrowBadArrayIndex (index); |
| jobject *elts = elements (array); |
| elts[index] = value; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| } |
| |
| template<typename T, jclass K> |
| static JArray<T> * |
| (JNICALL _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, jclass K> |
| static T * |
| (JNICALL _Jv_JNI_GetPrimitiveArrayElements) (JNIEnv *env, JArray<T> *array, |
| jboolean *isCopy) |
| { |
| array = unwrap (array); |
| if (! _Jv_JNI_check_types (env, array, K)) |
| return NULL; |
| T *elts = elements (array); |
| if (isCopy) |
| { |
| // We elect never to copy. |
| *isCopy = false; |
| } |
| mark_for_gc (array, global_ref_table); |
| return elts; |
| } |
| |
| template<typename T, jclass K> |
| static void |
| (JNICALL _Jv_JNI_ReleasePrimitiveArrayElements) (JNIEnv *env, JArray<T> *array, |
| T *, jint /* mode */) |
| { |
| array = unwrap (array); |
| _Jv_JNI_check_types (env, array, K); |
| // 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, global_ref_table); |
| } |
| |
| template<typename T, jclass K> |
| static void |
| (JNICALL _Jv_JNI_GetPrimitiveArrayRegion) (JNIEnv *env, JArray<T> *array, |
| jsize start, jsize len, |
| T *buf) |
| { |
| array = unwrap (array); |
| if (! _Jv_JNI_check_types (env, array, K)) |
| return; |
| |
| // The cast to unsigned lets us save a comparison. |
| if (start < 0 || len < 0 |
| || (unsigned long) (start + len) > (unsigned long) 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, jclass K> |
| static void |
| (JNICALL _Jv_JNI_SetPrimitiveArrayRegion) (JNIEnv *env, JArray<T> *array, |
| jsize start, jsize len, T *buf) |
| { |
| array = unwrap (array); |
| if (! _Jv_JNI_check_types (env, array, K)) |
| return; |
| |
| // The cast to unsigned lets us save a comparison. |
| if (start < 0 || len < 0 |
| || (unsigned long) (start + len) > (unsigned long) 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 * |
| (JNICALL _Jv_JNI_GetPrimitiveArrayCritical) (JNIEnv *, jarray array, |
| jboolean *isCopy) |
| { |
| array = unwrap (array); |
| // 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 |
| (JNICALL _Jv_JNI_ReleasePrimitiveArrayCritical) (JNIEnv *, jarray, void *, jint) |
| { |
| // Nothing. |
| } |
| |
| static jint |
| (JNICALL _Jv_JNI_MonitorEnter) (JNIEnv *env, jobject obj) |
| { |
| try |
| { |
| _Jv_MonitorEnter (unwrap (obj)); |
| return 0; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| return JNI_ERR; |
| } |
| |
| static jint |
| (JNICALL _Jv_JNI_MonitorExit) (JNIEnv *env, jobject obj) |
| { |
| try |
| { |
| _Jv_MonitorExit (unwrap (obj)); |
| return 0; |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| return JNI_ERR; |
| } |
| |
| // JDK 1.2 |
| jobject |
| (JNICALL _Jv_JNI_ToReflectedField) (JNIEnv *env, jclass cls, jfieldID fieldID, |
| jboolean) |
| { |
| try |
| { |
| cls = unwrap (cls); |
| 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 |
| (JNICALL _Jv_JNI_FromReflectedField) (JNIEnv *, jobject f) |
| { |
| using namespace java::lang::reflect; |
| |
| f = unwrap (f); |
| Field *field = reinterpret_cast<Field *> (f); |
| return _Jv_FromReflectedField (field); |
| } |
| |
| jobject |
| (JNICALL _Jv_JNI_ToReflectedMethod) (JNIEnv *env, jclass klass, jmethodID id, |
| jboolean) |
| { |
| using namespace java::lang::reflect; |
| |
| jobject result = NULL; |
| klass = unwrap (klass); |
| |
| 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 |
| (JNICALL _Jv_JNI_FromReflectedMethod) (JNIEnv *, jobject method) |
| { |
| using namespace java::lang::reflect; |
| method = unwrap (method); |
| if (Method::class$.isInstance (method)) |
| return _Jv_FromReflectedMethod (reinterpret_cast<Method *> (method)); |
| return |
| _Jv_FromReflectedConstructor (reinterpret_cast<Constructor *> (method)); |
| } |
| |
| // JDK 1.2. |
| jweak |
| (JNICALL _Jv_JNI_NewWeakGlobalRef) (JNIEnv *env, jobject obj) |
| { |
| using namespace gnu::gcj::runtime; |
| JNIWeakRef *ref = NULL; |
| |
| try |
| { |
| // This seems weird but I think it is correct. |
| obj = unwrap (obj); |
| ref = new JNIWeakRef (obj); |
| mark_for_gc (ref, global_ref_table); |
| } |
| catch (jthrowable t) |
| { |
| env->ex = t; |
| } |
| |
| return reinterpret_cast<jweak> (ref); |
| } |
| |
| void |
| (JNICALL _Jv_JNI_DeleteWeakGlobalRef) (JNIEnv *, jweak obj) |
| { |
| using namespace gnu::gcj::runtime; |
| JNIWeakRef *ref = reinterpret_cast<JNIWeakRef *> (obj); |
| unmark_for_gc (ref, global_ref_table); |
| ref->clear (); |
| } |
| |
| |
| |
| // Direct byte buffers. |
| |
| static jobject |
| (JNICALL _Jv_JNI_NewDirectByteBuffer) (JNIEnv *, void *address, jlong length) |
| { |
| using namespace gnu::gcj; |
| using namespace java::nio; |
| return new DirectByteBufferImpl (reinterpret_cast<RawData *> (address), |
| length); |
| } |
| |
| static void * |
| (JNICALL _Jv_JNI_GetDirectBufferAddress) (JNIEnv *, jobject buffer) |
| { |
| using namespace java::nio; |
| DirectByteBufferImpl* bb = static_cast<DirectByteBufferImpl *> (buffer); |
| return reinterpret_cast<void *> (bb->address); |
| } |
| |
| static jlong |
| (JNICALL _Jv_JNI_GetDirectBufferCapacity) (JNIEnv *, jobject buffer) |
| { |
| using namespace java::nio; |
| DirectByteBufferImpl* bb = static_cast<DirectByteBufferImpl *> (buffer); |
| return bb->capacity(); |
| } |
| |
| |
| |
| // Hash table of native methods. |
| static JNINativeMethod *nathash; |
| // Number of slots used. |
| static int nathash_count = 0; |
| // Number of slots available. Must be power of 2. |
| static int nathash_size = 0; |
| |
| #define DELETED_ENTRY ((char *) (~0)) |
| |
| // Compute a hash value for a native method descriptor. |
| static int |
| hash (const JNINativeMethod *method) |
| { |
| char *ptr; |
| int hash = 0; |
| |
| ptr = method->name; |
| while (*ptr) |
| hash = (31 * hash) + *ptr++; |
| |
| ptr = method->signature; |
| while (*ptr) |
| hash = (31 * hash) + *ptr++; |
| |
| return hash; |
| } |
| |
| // Find the slot where a native method goes. |
| static JNINativeMethod * |
| nathash_find_slot (const JNINativeMethod *method) |
| { |
| jint h = hash (method); |
| int step = (h ^ (h >> 16)) | 1; |
| int w = h & (nathash_size - 1); |
| int del = -1; |
| |
| for (;;) |
| { |
| JNINativeMethod *slotp = &nathash[w]; |
| if (slotp->name == NULL) |
| { |
| if (del >= 0) |
| return &nathash[del]; |
| else |
| return slotp; |
| } |
| else if (slotp->name == DELETED_ENTRY) |
| del = w; |
| else if (! strcmp (slotp->name, method->name) |
| && ! strcmp (slotp->signature, method->signature)) |
| return slotp; |
| w = (w + step) & (nathash_size - 1); |
| } |
| } |
| |
| // Find a method. Return NULL if it isn't in the hash table. |
| static void * |
| nathash_find (JNINativeMethod *method) |
| { |
| if (nathash == NULL) |
| return NULL; |
| JNINativeMethod *slot = nathash_find_slot (method); |
| if (slot->name == NULL || slot->name == DELETED_ENTRY) |
| return NULL; |
| return slot->fnPtr; |
| } |
| |
| static void |
| natrehash () |
| { |
| if (nathash == NULL) |
| { |
| nathash_size = 1024; |
| nathash = |
| (JNINativeMethod *) _Jv_AllocBytes (nathash_size |
| * sizeof (JNINativeMethod)); |
| memset (nathash, 0, nathash_size * sizeof (JNINativeMethod)); |
| } |
| else |
| { |
| int savesize = nathash_size; |
| JNINativeMethod *savehash = nathash; |
| nathash_size *= 2; |
| nathash = |
| (JNINativeMethod *) _Jv_AllocBytes (nathash_size |
| * sizeof (JNINativeMethod)); |
| memset (nathash, 0, nathash_size * sizeof (JNINativeMethod)); |
| |
| for (int i = 0; i < savesize; ++i) |
| { |
| if (savehash[i].name != NULL && savehash[i].name != DELETED_ENTRY) |
| { |
| JNINativeMethod *slot = nathash_find_slot (&savehash[i]); |
| *slot = savehash[i]; |
| } |
| } |
| } |
| } |
| |
| static void |
| nathash_add (const JNINativeMethod *method) |
| { |
| if (3 * nathash_count >= 2 * nathash_size) |
| natrehash (); |
| JNINativeMethod *slot = nathash_find_slot (method); |
| // If the slot has a real entry in it, then there is no work to do. |
| if (slot->name != NULL && slot->name != DELETED_ENTRY) |
| return; |
| // FIXME |
| slot->name = strdup (method->name); |
| slot->signature = strdup (method->signature); |
| slot->fnPtr = method->fnPtr; |
| } |
| |
| static jint |
| (JNICALL _Jv_JNI_RegisterNatives) (JNIEnv *env, jclass klass, |
| const JNINativeMethod *methods, |
| jint nMethods) |
| { |
| // Synchronize while we do the work. This must match |
| // synchronization in some other functions that manipulate or use |
| // the nathash table. |
| JvSynchronize sync (global_ref_table); |
| |
| // 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_Method *imeths = JvGetFirstMethod (klass); |
| for (int i = 0; i < JvNumMethods (klass); ++i) |
| { |
| _Jv_Method *self = &imeths[i]; |
| |
| 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. |
| found = true; |
| nathash_add (&methods[j]); |
| |
| 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; |
| } |
| |
| static jint |
| (JNICALL _Jv_JNI_UnregisterNatives) (JNIEnv *, jclass) |
| { |
| // FIXME -- we could implement this. |
| 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->klass = klass; |
| env->locals = NULL; |
| // We set env->ex below. |
| |
| _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; |
| |
| for (int i = 0; i < frame->size; ++i) |
| frame->vec[i] = NULL; |
| |
| env->locals = frame; |
| env->ex = 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, int args_size) |
| { |
| char buf[10 + 6 * (name->length + signature->length) + 12]; |
| int long_start; |
| void *function; |
| |
| // Synchronize on something convenient. Right now we use the hash. |
| JvSynchronize sync (global_ref_table); |
| |
| // First see if we have an override in the hash table. |
| strncpy (buf, name->data, name->length); |
| buf[name->length] = '\0'; |
| strncpy (buf + name->length + 1, signature->data, signature->length); |
| buf[name->length + signature->length + 1] = '\0'; |
| JNINativeMethod meth; |
| meth.name = buf; |
| meth.signature = buf + name->length + 1; |
| function = nathash_find (&meth); |
| if (function != NULL) |
| return function; |
| |
| // If there was no override, then look in the symbol table. |
| buf[0] = '_'; |
| mangled_name (klass, name, signature, buf + 1, &long_start); |
| char c = buf[long_start + 1]; |
| buf[long_start + 1] = '\0'; |
| |
| function = _Jv_FindSymbolInExecutable (buf + 1); |
| #ifdef WIN32 |
| // On Win32, we use the "stdcall" calling convention (see JNICALL |
| // in jni.h). |
| // |
| // For a function named 'fooBar' that takes 'nn' bytes as arguments, |
| // by default, MinGW GCC exports it as 'fooBar@nn', MSVC exports it |
| // as '_fooBar@nn' and Borland C exports it as 'fooBar'. We try to |
| // take care of all these variations here. |
| |
| char asz_buf[12]; /* '@' + '2147483647' (32-bit INT_MAX) + '\0' */ |
| char long_nm_sv[11]; /* Ditto, except for the '\0'. */ |
| |
| if (function == NULL) |
| { |
| // We have tried searching for the 'fooBar' form (BCC) - now |
| // try the others. |
| |
| // First, save the part of the long name that will be damaged |
| // by appending '@nn'. |
| memcpy (long_nm_sv, (buf + long_start + 1 + 1), sizeof (long_nm_sv)); |
| |
| sprintf (asz_buf, "@%d", args_size); |
| strcat (buf, asz_buf); |
| |
| // Search for the '_fooBar@nn' form (MSVC). |
| function = _Jv_FindSymbolInExecutable (buf); |
| |
| if (function == NULL) |
| { |
| // Search for the 'fooBar@nn' form (MinGW GCC). |
| function = _Jv_FindSymbolInExecutable (buf + 1); |
| } |
| } |
| #endif /* WIN32 */ |
| |
| if (function == NULL) |
| { |
| buf[long_start + 1] = c; |
| #ifdef WIN32 |
| // Restore the part of the long name that was damaged by |
| // appending the '@nn'. |
| memcpy ((buf + long_start + 1 + 1), long_nm_sv, sizeof (long_nm_sv)); |
| #endif /* WIN32 */ |
| function = _Jv_FindSymbolInExecutable (buf + 1); |
| if (function == NULL) |
| { |
| #ifdef WIN32 |
| strcat (buf, asz_buf); |
| function = _Jv_FindSymbolInExecutable (buf); |
| if (function == NULL) |
| function = _Jv_FindSymbolInExecutable (buf + 1); |
| |
| if (function == NULL) |
| #endif /* WIN32 */ |
| { |
| jstring str = JvNewStringUTF (name->data); |
| throw new java::lang::UnsatisfiedLinkError (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. |
| { |
| // Synchronize on a convenient object to ensure sanity in case two |
| // threads reach this point for the same function at the same |
| // time. |
| JvSynchronize sync (global_ref_table); |
| if (_this->function == NULL) |
| { |
| int args_size = sizeof (JNIEnv *) + _this->args_raw_size; |
| |
| if (_this->self->accflags & java::lang::reflect::Modifier::STATIC) |
| args_size += sizeof (_this->defining_class); |
| |
| _this->function = _Jv_LookupJNIMethod (_this->defining_class, |
| _this->self->name, |
| _this->self->signature, |
| args_size); |
| } |
| } |
| |
| 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; |
| |
| // In libgcj, the callee synchronizes. |
| jobject sync = NULL; |
| if ((_this->self->accflags & java::lang::reflect::Modifier::SYNCHRONIZED)) |
| { |
| if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC)) |
| sync = _this->defining_class; |
| else |
| sync = (jobject) args[0].ptr; |
| _Jv_MonitorEnter (sync); |
| } |
| |
| // 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); |
| |
| if (sync != NULL) |
| _Jv_MonitorExit (sync); |
| |
| _Jv_JNI_PopSystemFrame (env); |
| } |
| |
| #endif /* INTERPRETER */ |
| |
| |
| |
| // |
| // Invocation API. |
| // |
| |
| // An internal helper function. |
| static jint |
| _Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv, |
| void *args, jboolean is_daemon) |
| { |
| 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_4 |
| && attach->version != JNI_VERSION_1_2 |
| && attach->version != JNI_VERSION_1_1) |
| return JNI_EVERSION; |
| |
| JvAssert (java::lang::ThreadGroup::class$.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; |
| } |
| |
| env->locals->marker = MARK_SYSTEM; |
| env->locals->size = FRAME_SIZE; |
| env->locals->next = NULL; |
| |
| for (int i = 0; i < env->locals->size; ++i) |
| env->locals->vec[i] = NULL; |
| |
| *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 |
| { |
| if (is_daemon) |
| _Jv_AttachCurrentThreadAsDaemon (name, group); |
| else |
| _Jv_AttachCurrentThread (name, group); |
| } |
| catch (jthrowable t) |
| { |
| return JNI_ERR; |
| } |
| } |
| _Jv_SetCurrentJNIEnv (env); |
| |
| return 0; |
| } |
| |
| // This is the one actually used by JNI. |
| static jint |
| (JNICALL _Jv_JNI_AttachCurrentThread) (JavaVM *vm, void **penv, void *args) |
| { |
| return _Jv_JNI_AttachCurrentThread (vm, NULL, penv, args, false); |
| } |
| |
| static jint |
| (JNICALL _Jv_JNI_AttachCurrentThreadAsDaemon) (JavaVM *vm, void **penv, |
| void *args) |
| { |
| return _Jv_JNI_AttachCurrentThread (vm, NULL, penv, args, true); |
| } |
| |
| static jint |
| (JNICALL _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, false); |
| if (r < 0) |
| return r; |
| } |
| else |
| env = _Jv_GetCurrentJNIEnv (); |
| |
| _Jv_ThreadWait (); |
| |
| // Docs say that this always returns an error code. |
| return JNI_ERR; |
| } |
| |
| jint |
| (JNICALL _Jv_JNI_DetachCurrentThread) (JavaVM *) |
| { |
| jint code = _Jv_DetachCurrentThread (); |
| return code ? JNI_EDETACHED : 0; |
| } |
| |
| static jint |
| (JNICALL _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_4 && version != JNI_VERSION_1_2 |
| && version != JNI_VERSION_1_1) |
| { |
| *penv = NULL; |
| return JNI_EVERSION; |
| } |
| |
| *penv = (void *) _Jv_GetCurrentJNIEnv (); |
| return 0; |
| } |
| |
| jint JNICALL |
| JNI_GetDefaultJavaVMInitArgs (void *args) |
| { |
| jint version = * (jint *) args; |
| // Here we only support 1.2 and 1.4. |
| if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4) |
| return JNI_EVERSION; |
| |
| JavaVMInitArgs *ia = reinterpret_cast<JavaVMInitArgs *> (args); |
| ia->version = JNI_VERSION_1_4; |
| ia->nOptions = 0; |
| ia->options = NULL; |
| ia->ignoreUnrecognized = true; |
| |
| return 0; |
| } |
| |
| jint JNICALL |
| JNI_CreateJavaVM (JavaVM **vm, void **penv, void *args) |
| { |
| JvAssert (! the_vm); |
| |
| _Jv_CreateJavaVM (NULL); |
| |
| // 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 and 1.4. |
| if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4) |
| 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 JNICALL |
| 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 |
| (JNICALL _Jv_JNI_GetJavaVM) (JNIEnv *, JavaVM **vm) |
| { |
| *vm = _Jv_GetJavaVM (); |
| return *vm == NULL ? JNI_ERR : JNI_OK; |
| } |
| |
| |
| |
| #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, // GetStringUTFChars |
| _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<jboolean, JvPrimClass (boolean)>, |
| // GetBooleanArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements<jbyte, JvPrimClass (byte)>, |
| // GetByteArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements<jchar, JvPrimClass (char)>, |
| // GetCharArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements<jshort, JvPrimClass (short)>, |
| // GetShortArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements<jint, JvPrimClass (int)>, |
| // GetIntArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements<jlong, JvPrimClass (long)>, |
| // GetLongArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements<jfloat, JvPrimClass (float)>, |
| // GetFloatArrayElements |
| _Jv_JNI_GetPrimitiveArrayElements<jdouble, JvPrimClass (double)>, |
| // GetDoubleArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jboolean, JvPrimClass (boolean)>, |
| // ReleaseBooleanArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jbyte, JvPrimClass (byte)>, |
| // ReleaseByteArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jchar, JvPrimClass (char)>, |
| // ReleaseCharArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jshort, JvPrimClass (short)>, |
| // ReleaseShortArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jint, JvPrimClass (int)>, |
| // ReleaseIntArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jlong, JvPrimClass (long)>, |
| // ReleaseLongArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jfloat, JvPrimClass (float)>, |
| // ReleaseFloatArrayElements |
| _Jv_JNI_ReleasePrimitiveArrayElements<jdouble, JvPrimClass (double)>, |
| // ReleaseDoubleArrayElements |
| _Jv_JNI_GetPrimitiveArrayRegion<jboolean, JvPrimClass (boolean)>, |
| // GetBooleanArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion<jbyte, JvPrimClass (byte)>, |
| // GetByteArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion<jchar, JvPrimClass (char)>, |
| // GetCharArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion<jshort, JvPrimClass (short)>, |
| // GetShortArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion<jint, JvPrimClass (int)>, |
| // GetIntArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion<jlong, JvPrimClass (long)>, |
| // GetLongArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion<jfloat, JvPrimClass (float)>, |
| // GetFloatArrayRegion |
| _Jv_JNI_GetPrimitiveArrayRegion<jdouble, JvPrimClass (double)>, |
| // GetDoubleArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jboolean, JvPrimClass (boolean)>, |
| // SetBooleanArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jbyte, JvPrimClass (byte)>, |
| // SetByteArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jchar, JvPrimClass (char)>, |
| // SetCharArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jshort, JvPrimClass (short)>, |
| // SetShortArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jint, JvPrimClass (int)>, |
| // SetIntArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jlong, JvPrimClass (long)>, |
| // SetLongArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jfloat, JvPrimClass (float)>, |
| // SetFloatArrayRegion |
| _Jv_JNI_SetPrimitiveArrayRegion<jdouble, JvPrimClass (double)>, |
| // 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 |
| |
| _Jv_JNI_NewWeakGlobalRef, // NewWeakGlobalRef |
| _Jv_JNI_DeleteWeakGlobalRef, // DeleteWeakGlobalRef |
| |
| _Jv_JNI_ExceptionCheck, // ExceptionCheck |
| |
| _Jv_JNI_NewDirectByteBuffer, // NewDirectByteBuffer |
| _Jv_JNI_GetDirectBufferAddress, // GetDirectBufferAddress |
| _Jv_JNI_GetDirectBufferCapacity // GetDirectBufferCapacity |
| }; |
| |
| struct JNIInvokeInterface _Jv_JNI_InvokeFunctions = |
| { |
| RESERVED, |
| RESERVED, |
| RESERVED, |
| |
| _Jv_JNI_DestroyJavaVM, |
| _Jv_JNI_AttachCurrentThread, |
| _Jv_JNI_DetachCurrentThread, |
| _Jv_JNI_GetEnv, |
| _Jv_JNI_AttachCurrentThreadAsDaemon |
| }; |