--- /dev/null
+/*
+ Copyright (C) 2004 Jeroen Frijters
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jeroen Frijters
+ jeroen@frijters.net
+
+*/
+#include <stdarg.h>
+#include <malloc.h>
+#include "jni.h"
+
+#ifdef _WIN32
+#define ALLOCA _alloca
+#else
+#include <alloca.h>
+#define ALLOCA alloca
+#endif
+
+static jobject JNICALL NewObject(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...)
+{
+ jobject o;
+ va_list args;
+ va_start(args, methodID);
+ o = (*pEnv)->NewObjectV(pEnv, clazz, methodID, args);
+ va_end(args);
+ return o;
+}
+
+#define MAKE_ARG_ARRAY(pEnv, args, argarray) \
+do { \
+ jbyte sig[257];\
+ int argc = (*pEnv)->GetMethodArgs(pEnv, methodID, sig);\
+ int i;\
+ argarray = (jvalue*)ALLOCA(argc * sizeof(jvalue));\
+ for(i = 0; i < argc; i++)\
+ {\
+ switch(sig[i])\
+ {\
+ case 'Z':\
+ case 'B':\
+ case 'S':\
+ case 'C':\
+ case 'I':\
+ argarray[i].i = va_arg(args, jint);\
+ break;\
+ case 'J':\
+ argarray[i].j = va_arg(args, jlong);\
+ break;\
+ case 'L':\
+ argarray[i].l = va_arg(args, jobject);\
+ break;\
+ case 'D':\
+ argarray[i].d = va_arg(args, double);\
+ break;\
+ case 'F':\
+ argarray[i].f = (float)va_arg(args, double);\
+ break;\
+ }\
+ }\
+} while(0);
+
+static jobject JNICALL NewObjectV(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args)
+{
+ jvalue* argarray;
+ MAKE_ARG_ARRAY(pEnv, args, argarray);
+ return (*pEnv)->NewObjectA(pEnv, clazz, methodID, argarray);
+}
+
+#define MAKE_METHOD(Type, type) \
+static type JNICALL Call##Type##Method(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...)\
+{\
+ type ret;\
+ va_list args;\
+ va_start(args, methodID);\
+ ret = (*pEnv)->Call##Type##MethodV(pEnv, obj, methodID, args);\
+ va_end(args);\
+ return ret;\
+}\
+static type JNICALL Call##Type##MethodV(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args)\
+{\
+ jvalue* argarray;\
+ MAKE_ARG_ARRAY(pEnv, args, argarray);\
+ return (*pEnv)->Call##Type##MethodA(pEnv, obj, methodID, argarray);\
+}\
+static type JNICALL CallNonvirtual##Type##Method(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...)\
+{\
+ type ret;\
+ va_list args;\
+ va_start(args, methodID);\
+ ret = (*pEnv)->CallNonvirtual##Type##MethodV(pEnv, obj, clazz, methodID, args);\
+ va_end(args);\
+ return ret;\
+}\
+static type JNICALL CallNonvirtual##Type##MethodV(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args)\
+{\
+ jvalue* argarray;\
+ MAKE_ARG_ARRAY(pEnv, args, argarray);\
+ return (*pEnv)->CallNonvirtual##Type##MethodA(pEnv, obj, clazz, methodID, argarray);\
+}\
+static type JNICALL CallStatic##Type##Method(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...)\
+{\
+ type ret;\
+ va_list args;\
+ va_start(args, methodID);\
+ ret = (*pEnv)->CallStatic##Type##MethodV(pEnv, clazz, methodID, args);\
+ va_end(args);\
+ return ret;\
+}\
+static type JNICALL CallStatic##Type##MethodV(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args)\
+{\
+ jvalue* argarray;\
+ MAKE_ARG_ARRAY(pEnv, args, argarray);\
+ return (*pEnv)->CallStatic##Type##MethodA(pEnv, clazz, methodID, argarray);\
+}
+
+MAKE_METHOD(Object, jobject)
+MAKE_METHOD(Boolean, jboolean)
+MAKE_METHOD(Byte, jbyte)
+MAKE_METHOD(Char, jchar)
+MAKE_METHOD(Short, jshort)
+MAKE_METHOD(Int, jint)
+MAKE_METHOD(Long, jlong)
+MAKE_METHOD(Float, jfloat)
+MAKE_METHOD(Double, jdouble)
+
+static void JNICALL CallVoidMethod(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...)
+{
+ va_list args;
+ va_start(args, methodID);
+ (*pEnv)->CallVoidMethodV(pEnv, obj, methodID, args);
+ va_end(args);
+}
+static void JNICALL CallVoidMethodV(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args)
+{
+ jvalue* argarray;
+ MAKE_ARG_ARRAY(pEnv, args, argarray);
+ (*pEnv)->CallVoidMethodA(pEnv, obj, methodID, argarray);
+}
+static void JNICALL CallNonvirtualVoidMethod(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...)
+{
+ va_list args;
+ va_start(args, methodID);
+ (*pEnv)->CallNonvirtualVoidMethodV(pEnv, obj, clazz, methodID, args);
+ va_end(args);
+}
+static void JNICALL CallNonvirtualVoidMethodV(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args)
+{
+ jvalue* argarray;
+ MAKE_ARG_ARRAY(pEnv, args, argarray);
+ (*pEnv)->CallNonvirtualVoidMethodA(pEnv, obj, clazz, methodID, argarray);
+}
+static void JNICALL CallStaticVoidMethod(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...)
+{
+ va_list args;
+ va_start(args, methodID);
+ (*pEnv)->CallStaticVoidMethodV(pEnv, clazz, methodID, args);
+ va_end(args);
+}
+static void JNICALL CallStaticVoidMethodV(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args)
+{
+ jvalue* argarray;
+ MAKE_ARG_ARRAY(pEnv, args, argarray);
+ (*pEnv)->CallStaticVoidMethodA(pEnv, clazz, methodID, argarray);
+}
+
+static void* JNIEnv_vtable[] =
+{
+ 0, // void JNICALL reserved0();
+ 0, // void JNICALL reserved1();
+ 0, // void JNICALL reserved2();
+ 0, // void JNICALL reserved3();
+
+ 0, // jint JNICALL GetVersion();
+
+ 0, // jclass JNICALL DefineClass(const char *name, jobject loader, const jbyte *buf, jsize len);
+ 0, // jclass JNICALL FindClass(const char *name);
+
+ 0, // jmethodID JNICALL FromReflectedMethod(jobject method);
+ 0, // jfieldID JNICALL FromReflectedField(jobject field);
+ 0, // jobject JNICALL ToReflectedMethod(jclass clazz, jmethodID methodID);
+
+ 0, // jclass JNICALL GetSuperclass(jclass sub);
+ 0, // jboolean JNICALL IsAssignableFrom(jclass sub, jclass sup);
+
+ 0, // jobject JNICALL ToReflectedField(jclass clazz, jfieldID fieldID);
+
+ 0, // jint JNICALL Throw(jthrowable obj);
+ 0, // jint JNICALL ThrowNew(jclass clazz, const char *msg);
+ 0, // jthrowable JNICALL ExceptionOccurred();
+ 0, // void JNICALL ExceptionDescribe();
+ 0, // void JNICALL ExceptionClear();
+ 0, // void JNICALL FatalError(const char *msg);
+
+ 0, // jint JNICALL PushLocalFrame(jint capacity);
+ 0, // jobject JNICALL PopLocalFrame(jobject result);
+
+ 0, // jobject JNICALL NewGlobalRef(jobject lobj);
+ 0, // void JNICALL DeleteGlobalRef(jobject gref);
+ 0, // void JNICALL DeleteLocalRef(jobject obj);
+ 0, // jboolean JNICALL IsSameObject(jobject obj1, jobject obj2);
+
+ 0, // jobject JNICALL NewLocalRef(jobject ref);
+ 0, // jint JNICALL EnsureLocalCapacity(jint capacity);
+
+ 0, // jobject JNICALL AllocObject(jclass clazz);
+ NewObject, // jobject JNICALL NewObject(jclass clazz, jmethodID methodID, ...);
+ NewObjectV, // jobject JNICALL NewObjectV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jobject JNICALL NewObjectA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ 0, // jclass JNICALL GetObjectClass(jobject obj);
+ 0, // jboolean JNICALL IsInstanceOf(jobject obj, jclass clazz);
+
+ 0, // jmethodID JNICALL GetMethodID(jclass clazz, const char *name, const char *sig);
+
+ CallObjectMethod, // jobject JNICALL CallObjectMethod(jobject obj, jmethodID methodID, ...);
+ CallObjectMethodV, // jobject JNICALL CallObjectMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jobject JNICALL CallObjectMethodA(jobject obj, jmethodID methodID, jvalue * args);
+
+ CallBooleanMethod, // jboolean JNICALL CallBooleanMethod(jobject obj, jmethodID methodID, ...);
+ CallBooleanMethodV, // jboolean JNICALL CallBooleanMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jboolean JNICALL CallBooleanMethodA(jobject obj, jmethodID methodID, jvalue * args);
+
+ CallByteMethod, // jbyte JNICALL CallByteMethod(jobject obj, jmethodID methodID, ...);
+ CallByteMethodV, // jbyte JNICALL CallByteMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jbyte JNICALL CallByteMethodA(jobject obj, jmethodID methodID, jvalue *args);
+
+ CallCharMethod, // jchar JNICALL CallCharMethod(jobject obj, jmethodID methodID, ...);
+ CallCharMethodV, // jchar JNICALL CallCharMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jchar JNICALL CallCharMethodA(jobject obj, jmethodID methodID, jvalue *args);
+
+ CallShortMethod, // jshort JNICALL CallShortMethod(jobject obj, jmethodID methodID, ...);
+ CallShortMethodV, // jshort JNICALL CallShortMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jshort JNICALL CallShortMethodA(jobject obj, jmethodID methodID, jvalue *args);
+
+ CallIntMethod, // jint JNICALL CallIntMethod(jobject obj, jmethodID methodID, ...);
+ CallIntMethodV, // jint JNICALL CallIntMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jint JNICALL CallIntMethodA(jobject obj, jmethodID methodID, jvalue *args);
+
+ CallLongMethod, // jlong JNICALL CallLongMethod(jobject obj, jmethodID methodID, ...);
+ CallLongMethodV, // jlong JNICALL CallLongMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jlong JNICALL CallLongMethodA(jobject obj, jmethodID methodID, jvalue *args);
+
+ CallFloatMethod, // jfloat JNICALL CallFloatMethod(jobject obj, jmethodID methodID, ...);
+ CallFloatMethodV, // jfloat JNICALL CallFloatMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jfloat JNICALL CallFloatMethodA(jobject obj, jmethodID methodID, jvalue *args);
+
+ CallDoubleMethod, // jdouble JNICALL CallDoubleMethod(jobject obj, jmethodID methodID, ...);
+ CallDoubleMethodV, // jdouble JNICALL CallDoubleMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // jdouble JNICALL CallDoubleMethodA(jobject obj, jmethodID methodID, jvalue *args);
+
+ CallVoidMethod, // void JNICALL CallVoidMethod(jobject obj, jmethodID methodID, ...);
+ CallVoidMethodV, // void JNICALL CallVoidMethodV(jobject obj, jmethodID methodID, va_list args);
+ 0, // void JNICALL CallVoidMethodA(jobject obj, jmethodID methodID, jvalue * args);
+
+ CallNonvirtualObjectMethod, // jobject JNICALL CallNonvirtualObjectMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualObjectMethodV, // jobject JNICALL CallNonvirtualObjectMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jobject JNICALL CallNonvirtualObjectMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+
+ CallNonvirtualBooleanMethod, // jboolean JNICALL CallNonvirtualBooleanMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualBooleanMethodV, // jboolean JNICALL CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jboolean JNICALL CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+
+ CallNonvirtualByteMethod, // jbyte JNICALL CallNonvirtualByteMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualByteMethodV, // jbyte JNICALL CallNonvirtualByteMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jbyte JNICALL CallNonvirtualByteMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallNonvirtualCharMethod, // jchar JNICALL CallNonvirtualCharMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualCharMethodV, // jchar JNICALL CallNonvirtualCharMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jchar JNICALL CallNonvirtualCharMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallNonvirtualShortMethod, // jshort JNICALL CallNonvirtualShortMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualShortMethodV, // jshort JNICALL CallNonvirtualShortMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jshort JNICALL CallNonvirtualShortMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallNonvirtualIntMethod, // jint JNICALL CallNonvirtualIntMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualIntMethodV, // jint JNICALL CallNonvirtualIntMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jint JNICALL CallNonvirtualIntMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallNonvirtualLongMethod, // jlong JNICALL CallNonvirtualLongMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualLongMethodV, // jlong JNICALL CallNonvirtualLongMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jlong JNICALL CallNonvirtualLongMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallNonvirtualFloatMethod, // jfloat JNICALL CallNonvirtualFloatMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualFloatMethodV, // jfloat JNICALL CallNonvirtualFloatMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jfloat JNICALL CallNonvirtualFloatMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallNonvirtualDoubleMethod, // jdouble JNICALL CallNonvirtualDoubleMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualDoubleMethodV, // jdouble JNICALL CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // jdouble JNICALL CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallNonvirtualVoidMethod, // void JNICALL CallNonvirtualVoidMethod(jobject obj, jclass clazz, jmethodID methodID, ...);
+ CallNonvirtualVoidMethodV, // void JNICALL CallNonvirtualVoidMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ 0, // void JNICALL CallNonvirtualVoidMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+
+ 0, // jfieldID JNICALL GetFieldID(jclass clazz, const char *name, const char *sig);
+
+ 0, // jobject JNICALL GetObjectField(jobject obj, jfieldID fieldID);
+ 0, // jboolean JNICALL GetBooleanField(jobject obj, jfieldID fieldID);
+ 0, // jbyte JNICALL GetByteField(jobject obj, jfieldID fieldID);
+ 0, // jchar JNICALL GetCharField(jobject obj, jfieldID fieldID);
+ 0, // jshort JNICALL GetShortField(jobject obj, jfieldID fieldID);
+ 0, // jint JNICALL GetIntField(jobject obj, jfieldID fieldID);
+ 0, // jlong JNICALL GetLongField(jobject obj, jfieldID fieldID);
+ 0, // jfloat JNICALL GetFloatField(jobject obj, jfieldID fieldID);
+ 0, // jdouble JNICALL GetDoubleField(jobject obj, jfieldID fieldID);
+
+ 0, // void JNICALL SetObjectField(jobject obj, jfieldID fieldID, jobject val);
+ 0, // void JNICALL SetBooleanField(jobject obj, jfieldID fieldID, jboolean val);
+ 0, // void JNICALL SetByteField(jobject obj, jfieldID fieldID, jbyte val);
+ 0, // void JNICALL SetCharField(jobject obj, jfieldID fieldID, jchar val);
+ 0, // void JNICALL SetShortField(jobject obj, jfieldID fieldID, jshort val);
+ 0, // void JNICALL SetIntField(jobject obj, jfieldID fieldID, jint val);
+ 0, // void JNICALL SetLongField(jobject obj, jfieldID fieldID, jlong val);
+ 0, // void JNICALL SetFloatField(jobject obj, jfieldID fieldID, jfloat val);
+ 0, // void JNICALL SetDoubleField(jobject obj, jfieldID fieldID, jdouble val);
+
+ 0, // jmethodID JNICALL GetStaticMethodID(jclass clazz, const char *name, const char *sig);
+
+ CallStaticObjectMethod, // jobject JNICALL CallStaticObjectMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticObjectMethodV, // jobject JNICALL CallStaticObjectMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jobject JNICALL CallStaticObjectMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticBooleanMethod, // jboolean JNICALL CallStaticBooleanMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticBooleanMethodV, // jboolean JNICALL CallStaticBooleanMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jboolean JNICALL CallStaticBooleanMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticByteMethod, // jbyte JNICALL CallStaticByteMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticByteMethodV, // jbyte JNICALL CallStaticByteMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jbyte JNICALL CallStaticByteMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticCharMethod, // jchar JNICALL CallStaticCharMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticCharMethodV, // jchar JNICALL CallStaticCharMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jchar JNICALL CallStaticCharMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticShortMethod, // jshort JNICALL CallStaticShortMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticShortMethodV, // jshort JNICALL CallStaticShortMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jshort JNICALL CallStaticShortMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticIntMethod, // jint JNICALL CallStaticIntMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticIntMethodV, // jint JNICALL CallStaticIntMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jint JNICALL CallStaticIntMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticLongMethod, // jlong JNICALL CallStaticLongMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticLongMethodV, // jlong JNICALL CallStaticLongMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jlong JNICALL CallStaticLongMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticFloatMethod, // jfloat JNICALL CallStaticFloatMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticFloatMethodV, // jfloat JNICALL CallStaticFloatMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jfloat JNICALL CallStaticFloatMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticDoubleMethod, // jdouble JNICALL CallStaticDoubleMethod(jclass clazz, jmethodID methodID, ...);
+ CallStaticDoubleMethodV, // jdouble JNICALL CallStaticDoubleMethodV(jclass clazz, jmethodID methodID, va_list args);
+ 0, // jdouble JNICALL CallStaticDoubleMethodA(jclass clazz, jmethodID methodID, jvalue *args);
+
+ CallStaticVoidMethod, // void JNICALL CallStaticVoidMethod(jclass cls, jmethodID methodID, ...);
+ CallStaticVoidMethodV, // void JNICALL CallStaticVoidMethodV(jclass cls, jmethodID methodID, va_list args);
+ 0, // void JNICALL CallStaticVoidMethodA(jclass cls, jmethodID methodID, jvalue * args);
+
+ 0, // jfieldID JNICALL GetStaticFieldID(jclass clazz, const char *name, const char *sig);
+
+ 0, // jobject JNICALL GetObjectField(jobject obj, jfieldID fieldID);
+ 0, // jboolean JNICALL GetBooleanField(jobject obj, jfieldID fieldID);
+ 0, // jbyte JNICALL GetByteField(jobject obj, jfieldID fieldID);
+ 0, // jchar JNICALL GetCharField(jobject obj, jfieldID fieldID);
+ 0, // jshort JNICALL GetShortField(jobject obj, jfieldID fieldID);
+ 0, // jint JNICALL GetIntField(jobject obj, jfieldID fieldID);
+ 0, // jlong JNICALL GetLongField(jobject obj, jfieldID fieldID);
+ 0, // jfloat JNICALL GetFloatField(jobject obj, jfieldID fieldID);
+ 0, // jdouble JNICALL GetDoubleField(jobject obj, jfieldID fieldID);
+
+ 0, // void JNICALL SetObjectField(jobject obj, jfieldID fieldID, jobject val);
+ 0, // void JNICALL SetBooleanField(jobject obj, jfieldID fieldID, jboolean val);
+ 0, // void JNICALL SetByteField(jobject obj, jfieldID fieldID, jbyte val);
+ 0, // void JNICALL SetCharField(jobject obj, jfieldID fieldID, jchar val);
+ 0, // void JNICALL SetShortField(jobject obj, jfieldID fieldID, jshort val);
+ 0, // void JNICALL SetIntField(jobject obj, jfieldID fieldID, jint val);
+ 0, // void JNICALL SetLongField(jobject obj, jfieldID fieldID, jlong val);
+ 0, // void JNICALL SetFloatField(jobject obj, jfieldID fieldID, jfloat val);
+ 0, // void JNICALL SetDoubleField(jobject obj, jfieldID fieldID, jdouble val);
+
+ 0, // jstring JNICALL NewString(const jchar *unicode, jsize len);
+ 0, // jsize JNICALL GetStringLength(jstring str);
+ 0, // const jchar *JNICALL GetStringChars(jstring str, jboolean *isCopy);
+ 0, // void JNICALL ReleaseStringChars(jstring str, const jchar *chars);
+
+ 0, // jstring JNICALL NewStringUTF(const char *utf);
+ 0, // jsize JNICALL GetStringUTFLength(jstring str);
+ 0, // const char* JNICALL GetStringUTFChars(jstring str, jboolean *isCopy);
+ 0, // void JNICALL ReleaseStringUTFChars(jstring str, const char* chars);
+
+ 0, // jsize JNICALL GetArrayLength(jarray array);
+
+ 0, // jobjectArray JNICALL NewObjectArray(jsize len, jclass clazz, jobject init);
+ 0, // jobject JNICALL GetObjectArrayElement(jobjectArray array, jsize index);
+ 0, // void JNICALL SetObjectArrayElement(jobjectArray array, jsize index, jobject val);
+
+ 0, // jbooleanArray JNICALL NewBooleanArray(jsize len);
+ 0, // jbyteArray JNICALL NewByteArray(jsize len);
+ 0, // jcharArray JNICALL NewCharArray(jsize len);
+ 0, // jshortArray JNICALL NewShortArray(jsize len);
+ 0, // jintArray JNICALL NewIntArray(jsize len);
+ 0, // jlongArray JNICALL NewLongArray(jsize len);
+ 0, // jfloatArray JNICALL NewFloatArray(jsize len);
+ 0, // jdoubleArray JNICALL NewDoubleArray(jsize len);
+
+ 0, // jboolean * JNICALL GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy);
+ 0, // jbyte * JNICALL GetByteArrayElements(jbyteArray array, jboolean *isCopy);
+ 0, // jchar * JNICALL GetCharArrayElements(jcharArray array, jboolean *isCopy);
+ 0, // jshort * JNICALL GetShortArrayElements(jshortArray array, jboolean *isCopy);
+ 0, // jint * JNICALL GetIntArrayElements(jintArray array, jboolean *isCopy);
+ 0, // jlong * JNICALL GetLongArrayElements(jlongArray array, jboolean *isCopy);
+ 0, // jfloat * JNICALL GetFloatArrayElements(jfloatArray array, jboolean *isCopy);
+ 0, // jdouble * JNICALL GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy);
+
+ 0, // void JNICALL ReleaseBooleanArrayElements(jbooleanArray array, jboolean *elems, jint mode);
+ 0, // void JNICALL ReleaseByteArrayElements(jbyteArray array, jbyte *elems, jint mode);
+ 0, // void JNICALL ReleaseCharArrayElements(jcharArray array, jchar *elems, jint mode);
+ 0, // void JNICALL ReleaseShortArrayElements(jshortArray array, jshort *elems, jint mode);
+ 0, // void JNICALL ReleaseIntArrayElements(jintArray array, jint *elems, jint mode);
+ 0, // void JNICALL ReleaseLongArrayElements(jlongArray array, jlong *elems, jint mode);
+ 0, // void JNICALL ReleaseFloatArrayElements(jfloatArray array, jfloat *elems, jint mode);
+ 0, // void JNICALL ReleaseDoubleArrayElements(jdoubleArray array, jdouble *elems, jint mode);
+
+ 0, // void JNICALL GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize l, jboolean *buf);
+ 0, // void JNICALL GetByteArrayRegion(jbyteArray array, jsize start, jsize len, jbyte *buf);
+ 0, // void JNICALL GetCharArrayRegion(jcharArray array, jsize start, jsize len, jchar *buf);
+ 0, // void JNICALL GetShortArrayRegion(jshortArray array, jsize start, jsize len, jshort *buf);
+ 0, // void JNICALL GetIntArrayRegion(jintArray array, jsize start, jsize len, jint *buf);
+ 0, // void JNICALL GetLongArrayRegion(jlongArray array, jsize start, jsize len, jlong *buf);
+ 0, // void JNICALL GetFloatArrayRegion(jfloatArray array, jsize start, jsize len, jfloat *buf);
+ 0, // void JNICALL GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, jdouble *buf);
+
+ 0, // void JNICALL SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize l, jboolean *buf);
+ 0, // void JNICALL SetByteArrayRegion(jbyteArray array, jsize start, jsize len, jbyte *buf);
+ 0, // void JNICALL SetCharArrayRegion(jcharArray array, jsize start, jsize len, jchar *buf);
+ 0, // void JNICALL SetShortArrayRegion(jshortArray array, jsize start, jsize len, jshort *buf);
+ 0, // void JNICALL SetIntArrayRegion(jintArray array, jsize start, jsize len, jint *buf);
+ 0, // void JNICALL SetLongArrayRegion(jlongArray array, jsize start, jsize len, jlong *buf);
+ 0, // void JNICALL SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, jfloat *buf);
+ 0, // void JNICALL SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, jdouble *buf);
+
+ 0, // jint JNICALL RegisterNatives(jclass clazz, const JNINativeMethod *methods, jint nMethods);
+ 0, // jint JNICALL UnregisterNatives(jclass clazz);
+
+ 0, // jint JNICALL MonitorEnter(jobject obj);
+ 0, // jint JNICALL MonitorExit(jobject obj);
+
+ 0, // jint JNICALL GetJavaVM(JavaVM **vm);
+
+ 0, // void JNICALL GetStringRegion(jstring str, jsize start, jsize len, jchar *buf);
+ 0, // void JNICALL GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf);
+
+ 0, // void* JNICALL GetPrimitiveArrayCritical(jarray array, jboolean *isCopy);
+ 0, // void JNICALL ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode);
+
+ 0, // const jchar* JNICALL GetStringCritical(jstring string, jboolean *isCopy);
+ 0, // void JNICALL ReleaseStringCritical(jstring string, const jchar *cstring);
+
+ 0, // jweak JNICALL NewWeakGlobalRef(jobject obj);
+ 0, // void JNICALL DeleteWeakGlobalRef(jweak ref);
+
+ 0, // jboolean JNICALL ExceptionCheck();
+
+ 0, // jobject JNICALL NewDirectByteBuffer(void* address, jlong capacity);
+ 0, // void* JNICALL GetDirectBufferAddress(jobject buf);
+ 0 // jlong JNICALL GetDirectBufferCapacity(jobject buf);
+};
+
+JNIEXPORT void** JNICALL ikvm_GetJNIEnvVTable()
+{
+ return JNIEnv_vtable;
+}
+
+JNIEXPORT void* JNICALL ikvm_MarshalDelegate(void* p)
+{
+ return p;
+}
+
+typedef jint (JNICALL *PJNI_ONLOAD)(JavaVM* vm, void* reserved);
+
+JNIEXPORT jint JNICALL ikvm_CallOnLoad(PJNI_ONLOAD method, JavaVM* vm, void* reserved)
+{
+ return method(vm, reserved);
+}
--- /dev/null
+/*
+ Copyright (C) 2004 Jeroen Frijters
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jeroen Frijters
+ jeroen@frijters.net
+
+*/
+#ifndef __JNI_H__
+#define __JNI_H__
+
+#ifdef _WIN32
+ #define JNICALL __stdcall
+ #ifdef __cplusplus
+ #define JNIEXPORT extern "C" __declspec(dllexport)
+ #else
+ #define JNIEXPORT __declspec(dllexport)
+ #endif
+#else
+ #define JNICALL
+ #ifdef __cplusplus
+ #define JNIEXPORT extern "C"
+ #else
+ #define JNIEXPORT
+ #endif
+ #include <stdarg.h>
+#endif
+
+typedef void* jobject;
+typedef void* jstring;
+typedef void* jweak;
+typedef void* jthrowable;
+typedef void* jclass;
+typedef void* jmethodID;
+typedef void* jfieldID;
+typedef void* jarray;
+typedef void* jobjectArray;
+typedef void* jbooleanArray;
+typedef void* jbyteArray;
+typedef void* jcharArray;
+typedef void* jshortArray;
+typedef void* jintArray;
+typedef void* jlongArray;
+typedef void* jfloatArray;
+typedef void* jdoubleArray;
+
+typedef unsigned char jboolean;
+typedef signed char jbyte;
+typedef unsigned short jchar;
+typedef short jshort;
+typedef int jint;
+#ifdef __GNUC__
+ typedef long long int jlong;
+#else
+ typedef __int64 jlong;
+#endif
+typedef float jfloat;
+typedef double jdouble;
+typedef jint jsize;
+
+typedef struct
+{
+ char *name;
+ char *signature;
+ void *fnPtr;
+} JNINativeMethod;
+
+typedef union jvalue
+{
+ jboolean z;
+ jbyte b;
+ jchar c;
+ jshort s;
+ jint i;
+ jlong j;
+ jfloat f;
+ jdouble d;
+ jobject l;
+} jvalue;
+
+typedef void* JavaVM;
+typedef struct JNIEnv_methods *JNIEnv;
+
+struct JNIEnv_methods
+{
+ jint (JNICALL *GetMethodArgs)(JNIEnv* pEnv, jmethodID method, jbyte* sig);
+ void (JNICALL *reserved1)(JNIEnv* pEnv);
+ void (JNICALL *reserved2)(JNIEnv* pEnv);
+ void (JNICALL *reserved3)(JNIEnv* pEnv);
+
+ jint (JNICALL *GetVersion)(JNIEnv* pEnv);
+
+ jclass (JNICALL *DefineClass)(JNIEnv* pEnv, const char *name, jobject loader, const jbyte *buf, jsize len);
+ jclass (JNICALL *FindClass)(JNIEnv* pEnv, const char *name);
+
+ jmethodID (JNICALL *FromReflectedMethod)(JNIEnv* pEnv, jobject method);
+ jfieldID (JNICALL *FromReflectedField)(JNIEnv* pEnv, jobject field);
+ jobject (JNICALL *ToReflectedMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID);
+
+ jclass (JNICALL *GetSuperclass)(JNIEnv* pEnv, jclass sub);
+ jboolean (JNICALL *IsAssignableFrom)(JNIEnv* pEnv, jclass sub, jclass sup);
+
+ jobject (JNICALL *ToReflectedField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+
+ jint (JNICALL *Throw)(JNIEnv* pEnv, jthrowable obj);
+ jint (JNICALL *ThrowNew)(JNIEnv* pEnv, jclass clazz, const char *msg);
+ jthrowable (JNICALL *ExceptionOccurred)(JNIEnv* pEnv);
+ void (JNICALL *ExceptionDescribe)(JNIEnv* pEnv);
+ void (JNICALL *ExceptionClear)(JNIEnv* pEnv);
+ void (JNICALL *FatalError)(JNIEnv* pEnv, const char *msg);
+
+ jint (JNICALL *PushLocalFrame)(JNIEnv* pEnv, jint capacity);
+ jobject (JNICALL *PopLocalFrame)(JNIEnv* pEnv, jobject result);
+
+ jobject (JNICALL *NewGlobalRef)(JNIEnv* pEnv, jobject lobj);
+ void (JNICALL *DeleteGlobalRef)(JNIEnv* pEnv, jobject gref);
+ void (JNICALL *DeleteLocalRef)(JNIEnv* pEnv, jobject obj);
+ jboolean (JNICALL *IsSameObject)(JNIEnv* pEnv, jobject obj1, jobject obj2);
+
+ jobject (JNICALL *NewLocalRef)(JNIEnv* pEnv, jobject ref);
+ jint (JNICALL *EnsureLocalCapacity)(JNIEnv* pEnv, jint capacity);
+
+ jobject (JNICALL *AllocObject)(JNIEnv* pEnv, jclass clazz);
+ jobject (JNICALL *NewObject)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *NewObjectV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jobject (JNICALL *NewObjectA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jclass (JNICALL *GetObjectClass)(JNIEnv* pEnv, jobject obj);
+ jboolean (JNICALL *IsInstanceOf)(JNIEnv* pEnv, jobject obj, jclass clazz);
+
+ jmethodID (JNICALL *GetMethodID)(JNIEnv* pEnv, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *CallObjectMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jobject (JNICALL *CallObjectMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jobject (JNICALL *CallObjectMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue * args);
+
+ jboolean (JNICALL *CallBooleanMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jboolean (JNICALL *CallBooleanMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jboolean (JNICALL *CallBooleanMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue * args);
+
+ jbyte (JNICALL *CallByteMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jbyte (JNICALL *CallByteMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jbyte (JNICALL *CallByteMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue *args);
+
+ jchar (JNICALL *CallCharMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jchar (JNICALL *CallCharMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jchar (JNICALL *CallCharMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue *args);
+
+ jshort (JNICALL *CallShortMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jshort (JNICALL *CallShortMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jshort (JNICALL *CallShortMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue *args);
+
+ jint (JNICALL *CallIntMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jint (JNICALL *CallIntMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jint (JNICALL *CallIntMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue *args);
+
+ jlong (JNICALL *CallLongMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jlong (JNICALL *CallLongMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jlong (JNICALL *CallLongMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue *args);
+
+ jfloat (JNICALL *CallFloatMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jfloat (JNICALL *CallFloatMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jfloat (JNICALL *CallFloatMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue *args);
+
+ jdouble (JNICALL *CallDoubleMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ jdouble (JNICALL *CallDoubleMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ jdouble (JNICALL *CallDoubleMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue *args);
+
+ void (JNICALL *CallVoidMethod)(JNIEnv* pEnv, jobject obj, jmethodID methodID, ...);
+ void (JNICALL *CallVoidMethodV)(JNIEnv* pEnv, jobject obj, jmethodID methodID, va_list args);
+ void (JNICALL *CallVoidMethodA)(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue * args);
+
+ jobject (JNICALL *CallNonvirtualObjectMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *CallNonvirtualObjectMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jobject (JNICALL *CallNonvirtualObjectMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+
+ jboolean (JNICALL *CallNonvirtualBooleanMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jboolean (JNICALL *CallNonvirtualBooleanMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jboolean (JNICALL *CallNonvirtualBooleanMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+
+ jbyte (JNICALL *CallNonvirtualByteMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jbyte (JNICALL *CallNonvirtualByteMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jbyte (JNICALL *CallNonvirtualByteMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jchar (JNICALL *CallNonvirtualCharMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jchar (JNICALL *CallNonvirtualCharMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jchar (JNICALL *CallNonvirtualCharMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jshort (JNICALL *CallNonvirtualShortMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jshort (JNICALL *CallNonvirtualShortMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jshort (JNICALL *CallNonvirtualShortMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jint (JNICALL *CallNonvirtualIntMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jint (JNICALL *CallNonvirtualIntMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jint (JNICALL *CallNonvirtualIntMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jlong (JNICALL *CallNonvirtualLongMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jlong (JNICALL *CallNonvirtualLongMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jlong (JNICALL *CallNonvirtualLongMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jfloat (JNICALL *CallNonvirtualFloatMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jfloat (JNICALL *CallNonvirtualFloatMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jfloat (JNICALL *CallNonvirtualFloatMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jdouble (JNICALL *CallNonvirtualDoubleMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jdouble (JNICALL *CallNonvirtualDoubleMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ jdouble (JNICALL *CallNonvirtualDoubleMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+
+ void (JNICALL *CallNonvirtualVoidMethod)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, ...);
+ void (JNICALL *CallNonvirtualVoidMethodV)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+ void (JNICALL *CallNonvirtualVoidMethodA)(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+
+ jfieldID (JNICALL *GetFieldID)(JNIEnv* pEnv, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *GetObjectField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jboolean (JNICALL *GetBooleanField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jbyte (JNICALL *GetByteField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jchar (JNICALL *GetCharField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jshort (JNICALL *GetShortField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jint (JNICALL *GetIntField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jlong (JNICALL *GetLongField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jfloat (JNICALL *GetFloatField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+ jdouble (JNICALL *GetDoubleField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID);
+
+ void (JNICALL *SetObjectField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jobject val);
+ void (JNICALL *SetBooleanField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jboolean val);
+ void (JNICALL *SetByteField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jbyte val);
+ void (JNICALL *SetCharField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jchar val);
+ void (JNICALL *SetShortField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jshort val);
+ void (JNICALL *SetIntField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jint val);
+ void (JNICALL *SetLongField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jlong val);
+ void (JNICALL *SetFloatField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jfloat val);
+ void (JNICALL *SetDoubleField)(JNIEnv* pEnv, jobject obj, jfieldID fieldID, jdouble val);
+
+ jmethodID (JNICALL *GetStaticMethodID)(JNIEnv* pEnv, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *CallStaticObjectMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *CallStaticObjectMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jobject (JNICALL *CallStaticObjectMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jboolean (JNICALL *CallStaticBooleanMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jboolean (JNICALL *CallStaticBooleanMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jboolean (JNICALL *CallStaticBooleanMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jbyte (JNICALL *CallStaticByteMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jbyte (JNICALL *CallStaticByteMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jbyte (JNICALL *CallStaticByteMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jchar (JNICALL *CallStaticCharMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jchar (JNICALL *CallStaticCharMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jchar (JNICALL *CallStaticCharMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jshort (JNICALL *CallStaticShortMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jshort (JNICALL *CallStaticShortMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jshort (JNICALL *CallStaticShortMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jint (JNICALL *CallStaticIntMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jint (JNICALL *CallStaticIntMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jint (JNICALL *CallStaticIntMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jlong (JNICALL *CallStaticLongMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jlong (JNICALL *CallStaticLongMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jlong (JNICALL *CallStaticLongMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jfloat (JNICALL *CallStaticFloatMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jfloat (JNICALL *CallStaticFloatMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jfloat (JNICALL *CallStaticFloatMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ jdouble (JNICALL *CallStaticDoubleMethod)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, ...);
+ jdouble (JNICALL *CallStaticDoubleMethodV)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, va_list args);
+ jdouble (JNICALL *CallStaticDoubleMethodA)(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args);
+
+ void (JNICALL *CallStaticVoidMethod)(JNIEnv* pEnv, jclass cls, jmethodID methodID, ...);
+ void (JNICALL *CallStaticVoidMethodV)(JNIEnv* pEnv, jclass cls, jmethodID methodID, va_list args);
+ void (JNICALL *CallStaticVoidMethodA)(JNIEnv* pEnv, jclass cls, jmethodID methodID, jvalue * args);
+
+ jfieldID (JNICALL *GetStaticFieldID)(JNIEnv* pEnv, jclass clazz, const char *name, const char *sig);
+ jobject (JNICALL *GetStaticObjectField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jboolean (JNICALL *GetStaticBooleanField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jbyte (JNICALL *GetStaticByteField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jchar (JNICALL *GetStaticCharField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jshort (JNICALL *GetStaticShortField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jint (JNICALL *GetStaticIntField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jlong (JNICALL *GetStaticLongField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jfloat (JNICALL *GetStaticFloatField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+ jdouble (JNICALL *GetStaticDoubleField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID);
+
+ void (JNICALL *SetStaticObjectField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jobject value);
+ void (JNICALL *SetStaticBooleanField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jboolean value);
+ void (JNICALL *SetStaticByteField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jbyte value);
+ void (JNICALL *SetStaticCharField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jchar value);
+ void (JNICALL *SetStaticShortField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jshort value);
+ void (JNICALL *SetStaticIntField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jint value);
+ void (JNICALL *SetStaticLongField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jlong value);
+ void (JNICALL *SetStaticFloatField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jfloat value);
+ void (JNICALL *SetStaticDoubleField)(JNIEnv* pEnv, jclass clazz, jfieldID fieldID, jdouble value);
+
+ jstring (JNICALL *NewString)(JNIEnv* pEnv, const jchar *unicode, jsize len);
+ jsize (JNICALL *GetStringLength)(JNIEnv* pEnv, jstring str);
+ const jchar *(JNICALL *GetStringChars)(JNIEnv* pEnv, jstring str, jboolean *isCopy);
+ void (JNICALL *ReleaseStringChars)(JNIEnv* pEnv, jstring str, const jchar *chars);
+
+ jstring (JNICALL *NewStringUTF)(JNIEnv* pEnv, const char *utf);
+ jsize (JNICALL *GetStringUTFLength)(JNIEnv* pEnv, jstring str);
+ const char* (JNICALL *GetStringUTFChars)(JNIEnv* pEnv, jstring str, jboolean *isCopy);
+ void (JNICALL *ReleaseStringUTFChars)(JNIEnv* pEnv, jstring str, const char* chars);
+
+ jsize (JNICALL *GetArrayLength)(JNIEnv* pEnv, jarray array);
+
+ jobjectArray (JNICALL *NewObjectArray)(JNIEnv* pEnv, jsize len, jclass clazz, jobject init);
+ jobject (JNICALL *GetObjectArrayElement)(JNIEnv* pEnv, jobjectArray array, jsize index);
+ void (JNICALL *SetObjectArrayElement)(JNIEnv* pEnv, jobjectArray array, jsize index, jobject val);
+
+ jbooleanArray (JNICALL *NewBooleanArray)(JNIEnv* pEnv, jsize len);
+ jbyteArray (JNICALL *NewByteArray)(JNIEnv* pEnv, jsize len);
+ jcharArray (JNICALL *NewCharArray)(JNIEnv* pEnv, jsize len);
+ jshortArray (JNICALL *NewShortArray)(JNIEnv* pEnv, jsize len);
+ jintArray (JNICALL *NewIntArray)(JNIEnv* pEnv, jsize len);
+ jlongArray (JNICALL *NewLongArray)(JNIEnv* pEnv, jsize len);
+ jfloatArray (JNICALL *NewFloatArray)(JNIEnv* pEnv, jsize len);
+ jdoubleArray (JNICALL *NewDoubleArray)(JNIEnv* pEnv, jsize len);
+
+ jboolean * (JNICALL *GetBooleanArrayElements)(JNIEnv* pEnv, jbooleanArray array, jboolean *isCopy);
+ jbyte * (JNICALL *GetByteArrayElements)(JNIEnv* pEnv, jbyteArray array, jboolean *isCopy);
+ jchar * (JNICALL *GetCharArrayElements)(JNIEnv* pEnv, jcharArray array, jboolean *isCopy);
+ jshort * (JNICALL *GetShortArrayElements)(JNIEnv* pEnv, jshortArray array, jboolean *isCopy);
+ jint * (JNICALL *GetIntArrayElements)(JNIEnv* pEnv, jintArray array, jboolean *isCopy);
+ jlong * (JNICALL *GetLongArrayElements)(JNIEnv* pEnv, jlongArray array, jboolean *isCopy);
+ jfloat * (JNICALL *GetFloatArrayElements)(JNIEnv* pEnv, jfloatArray array, jboolean *isCopy);
+ jdouble * (JNICALL *GetDoubleArrayElements)(JNIEnv* pEnv, jdoubleArray array, jboolean *isCopy);
+
+ void (JNICALL *ReleaseBooleanArrayElements)(JNIEnv* pEnv, jbooleanArray array, jboolean *elems, jint mode);
+ void (JNICALL *ReleaseByteArrayElements)(JNIEnv* pEnv, jbyteArray array, jbyte *elems, jint mode);
+ void (JNICALL *ReleaseCharArrayElements)(JNIEnv* pEnv, jcharArray array, jchar *elems, jint mode);
+ void (JNICALL *ReleaseShortArrayElements)(JNIEnv* pEnv, jshortArray array, jshort *elems, jint mode);
+ void (JNICALL *ReleaseIntArrayElements)(JNIEnv* pEnv, jintArray array, jint *elems, jint mode);
+ void (JNICALL *ReleaseLongArrayElements)(JNIEnv* pEnv, jlongArray array, jlong *elems, jint mode);
+ void (JNICALL *ReleaseFloatArrayElements)(JNIEnv* pEnv, jfloatArray array, jfloat *elems, jint mode);
+ void (JNICALL *ReleaseDoubleArrayElements)(JNIEnv* pEnv, jdoubleArray array, jdouble *elems, jint mode);
+
+ void (JNICALL *GetBooleanArrayRegion)(JNIEnv* pEnv, jbooleanArray array, jsize start, jsize l, jboolean *buf);
+ void (JNICALL *GetByteArrayRegion)(JNIEnv* pEnv, jbyteArray array, jsize start, jsize len, jbyte *buf);
+ void (JNICALL *GetCharArrayRegion)(JNIEnv* pEnv, jcharArray array, jsize start, jsize len, jchar *buf);
+ void (JNICALL *GetShortArrayRegion)(JNIEnv* pEnv, jshortArray array, jsize start, jsize len, jshort *buf);
+ void (JNICALL *GetIntArrayRegion)(JNIEnv* pEnv, jintArray array, jsize start, jsize len, jint *buf);
+ void (JNICALL *GetLongArrayRegion)(JNIEnv* pEnv, jlongArray array, jsize start, jsize len, jlong *buf);
+ void (JNICALL *GetFloatArrayRegion)(JNIEnv* pEnv, jfloatArray array, jsize start, jsize len, jfloat *buf);
+ void (JNICALL *GetDoubleArrayRegion)(JNIEnv* pEnv, jdoubleArray array, jsize start, jsize len, jdouble *buf);
+
+ void (JNICALL *SetBooleanArrayRegion)(JNIEnv* pEnv, jbooleanArray array, jsize start, jsize l, jboolean *buf);
+ void (JNICALL *SetByteArrayRegion)(JNIEnv* pEnv, jbyteArray array, jsize start, jsize len, jbyte *buf);
+ void (JNICALL *SetCharArrayRegion)(JNIEnv* pEnv, jcharArray array, jsize start, jsize len, jchar *buf);
+ void (JNICALL *SetShortArrayRegion)(JNIEnv* pEnv, jshortArray array, jsize start, jsize len, jshort *buf);
+ void (JNICALL *SetIntArrayRegion)(JNIEnv* pEnv, jintArray array, jsize start, jsize len, jint *buf);
+ void (JNICALL *SetLongArrayRegion)(JNIEnv* pEnv, jlongArray array, jsize start, jsize len, jlong *buf);
+ void (JNICALL *SetFloatArrayRegion)(JNIEnv* pEnv, jfloatArray array, jsize start, jsize len, jfloat *buf);
+ void (JNICALL *SetDoubleArrayRegion)(JNIEnv* pEnv, jdoubleArray array, jsize start, jsize len, jdouble *buf);
+
+ jint (JNICALL *RegisterNatives)(JNIEnv* pEnv, jclass clazz, const JNINativeMethod *methods, jint nMethods);
+ jint (JNICALL *UnregisterNatives)(JNIEnv* pEnv, jclass clazz);
+
+ jint (JNICALL *MonitorEnter)(JNIEnv* pEnv, jobject obj);
+ jint (JNICALL *MonitorExit)(JNIEnv* pEnv, jobject obj);
+
+ jint (JNICALL *GetJavaVM)(JNIEnv* pEnv, JavaVM **vm);
+
+ void (JNICALL *GetStringRegion)(JNIEnv* pEnv, jstring str, jsize start, jsize len, jchar *buf);
+ void (JNICALL *GetStringUTFRegion)(JNIEnv* pEnv, jstring str, jsize start, jsize len, char *buf);
+
+ void* (JNICALL *GetPrimitiveArrayCritical)(JNIEnv* pEnv, jarray array, jboolean *isCopy);
+ void (JNICALL *ReleasePrimitiveArrayCritical)(JNIEnv* pEnv, jarray array, void *carray, jint mode);
+
+ const jchar* (JNICALL *GetStringCritical)(JNIEnv* pEnv, jstring string, jboolean *isCopy);
+ void (JNICALL *ReleaseStringCritical)(JNIEnv* pEnv, jstring string, const jchar *cstring);
+
+ jweak (JNICALL *NewWeakGlobalRef)(JNIEnv* pEnv, jobject obj);
+ void (JNICALL *DeleteWeakGlobalRef)(JNIEnv* pEnv, jweak ref);
+
+ jboolean (JNICALL *ExceptionCheck)(JNIEnv* pEnv);
+
+ jobject (JNICALL *NewDirectByteBuffer)(JNIEnv* pEnv, void* address, jlong capacity);
+ void* (JNICALL *GetDirectBufferAddress)(JNIEnv* pEnv, jobject buf);
+ jlong (JNICALL *GetDirectBufferCapacity)(JNIEnv* pEnv, jobject buf);
+};
+
+#endif //__JNI_H__
projects / mono.git / commitdiff