templates towards jni

diff --git a/Robust/src/Runtime/jni/jni-private.h b/Robust/src/Runtime/jni/jni-private.h
new file mode 100644 (file)
index 0000000..1c2f7da
--- /dev/null
+++ b/Robust/src/Runtime/jni/jni-private.h
@@ -0,0 +1,48 @@
+#ifndef JNI_PRIVATE_H
+#define JNI_PRIVATE_H
+struct c_class {
+  int type;
+  char * packagename;
+  char * classname;
+  int numMethods;
+  jmethodID * methods;
+  int numFields;
+  jfieldID *fields;
+};
+
+struct jmethodID {
+  char *methodname;
+};
+
+struct jfieldID {
+  char *fieldname;
+};
+
+jint RC_GetVersion(JNIEnv *);
+jclass RC_DefineClass(JNIEnv * env, const char * c, jobject loader, const jbyte * buf, jsize bufLen);
+jclass RC_FindClass(JNIEnv * env, const char *classname);
+jmethodID RC_FromReflectedMethod(JNIEnv * env, jobject mthdobj);
+jmethodID RC_FromReflectedField(JNIEnv * env, jobject fldobj);
+jobject RC_ToReflectedMethod(JNIEnv * env, jclass classobj, jmethodID methodobj, jboolean flag);
+jclass RC_GetSuperclass(JNIEnv * env, jclass classobj);
+jboolean RC_IsAssignableFrom(JNIEnv *, jclass, jclass);
+jobject RC_ToReflectedField(JNIEnv *, jclass, jfieldID, jboolean);
+jint RC_Throw(JNIEnv * env, jthrowable exc);
+jint RC_ThrowNew(JNIEnv * env, jclass cls, const char * str);
+jthrowable RC_ExceptionOccurred(JNIEnv * env);
+void RC_ExceptionDescribe(JNIEnv * env);
+void RC_ExceptionClear(JNIEnv * env);
+void RC_FatalError(JNIEnv * env, const char * str);
+jint RC_PushLocalFrame(JNIEnv * env, jint i);
+jobject RC_PopLocalFrame(JNIEnv * env, jobject obj);
+jobject RC_NewGlobalRef(JNIEnv * env, jobject obj);
+void RC_DeleteGlobalRef(JNIEnv * env, jobject obj);
+void RC_DeleteLocalRef(JNIEnv * env, jobject obj);
+jboolean RC_IsSameObject(JNIEnv * env, jobject obj1, jobject obj2);
+jobject RC_NewLocalRef(JNIEnv * env, jobject obj);
+jint RC_EnsureLocalCapacity(JNIEnv * env, jint capacity);
+jobject RC_AllocObject(JNIEnv * env, jclass cls);
+jobject RC_NewObject(JNIEnv * env, jclass cls, jmethodID methodobj, ...);
+jobject RC_NewObjectV(JNIEnv * env, jclass cls, jmethodID methodobj, va_list valist);
+jobject RC_NewObjectA(JNIEnv * env, jclass cls, jmethodID methodobj, const jvalue * args);
+#endif

diff --git a/Robust/src/Runtime/jni/jni-stuff.c b/Robust/src/Runtime/jni/jni-stuff.c
new file mode 100644 (file)
index 0000000..3a92f30
--- /dev/null
+++ b/Robust/src/Runtime/jni/jni-stuff.c
@@ -0,0 +1,346 @@
+#include<jni.h>
+#include<jni-private.h>
+
+jint RC_GetVersion(JNIEnv * env) {
+  return JNI_VERSION_1_1;
+}
+
+jclass RC_DefineClass(JNIEnv * env, const char * c,
+                     jobject loader, const jbyte * buf,
+                     jsize bufLen) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+//should return jclass object corresponding to classname
+jclass RC_FindClass(JNIEnv * env, const char *classname) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jmethodID RC_FromReflectedMethod(JNIEnv * env, jobject mthdobj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jmethodID RC_FromReflectedField(JNIEnv * env, jobject fldobj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jobject RC_ToReflectedMethod(JNIEnv * env, jclass classobj, jmethodID methodobj, jboolean flag) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jclass RC_GetSuperclass(JNIEnv * env, jclass classobj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jboolean RC_IsAssignableFrom(JNIEnv * env, jclass obj1, jclass obj2) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jobject RC_ToReflectedField(JNIEnv * env, jclass obj1, jfieldID fld, jboolean) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL
+}
+
+jint RC_Throw(JNIEnv * env, jthrowable obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jint RC_ThrowNew(JNIEnv *, jclass, const char *) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+}
+
+jthrowable RC_ExceptionOccurred(JNIEnv * env) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+void RC_ExceptionDescribe(JNIEnv * env) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+}
+
+void RC_ExceptionClear(JNIEnv * env) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+}
+
+void RC_FatalError(JNIEnv * env, const char * str) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+}
+
+jint RC_PushLocalFrame(JNIEnv * env, jint n) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jobject RC_PopLocalFrame(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jobject RC_NewGlobalRef(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+void RC_DeleteGlobalRef(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+}
+
+void RC_DeleteLocalRef(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+}
+
+jboolean RC_IsSameObject(JNIEnv * env, jobject obj1, jobject jobj2) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jobject RC_NewLocalRef(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jint RC_EnsureLocalCapacity(JNIEnv * env, jint capacity) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jobject RC_AllocObject(JNIEnv * env, jclass cls) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jobject RC_NewObject(JNIEnv * env, jclass cls, jmethodID mid, ...) {
+  va_list va;
+  va_start(va, mid);
+  return RC_NewObjectV(env, cls, mid, va);
+}
+
+jobject RC_NewObjectV(JNIEnv * env, jclass cls, jmethodID mid, va_list va) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jobject RC_NewObjectA(JNIEnv * env, jclass cls, jmethodID mid, const jvalue * vals) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jclass RC_GetObjectClass(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jboolean RC_IsInstanceOf(JNIEnv * env, jobject obj, jclass cls) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jmethodID RC_GetMethodID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+#define CALLMETHOD(R, T) R RC_Call ## T ## Method(JNIEnv *env, jobject obj, jmethodID mid, ...) { \
+    va_list va;                                                                \
+    va_start(va, mid);                                                 \
+    return RC_Call ## T ## MethodV(env, cls, mid, va);                 \
+  }
+
+#define CALLMETHODV(R, T) R RC_Call ## T ## MethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }                                                                    
+
+#define CALLMETHODA(R, T) R RC_Call ## T ## MethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }                                                                    
+
+#define CALLNVMETHOD(R, T) R RC_CallNonvirtual ## T ## Method(JNIEnv *env, jobject obj, jmethodID mid, ...) { \
+    va_list va;                                                                \
+    va_start(va, mid);                                                 \
+    return RC_CallNonVirtual ## T ## MethodV(env, cls, mid, va);       \
+  }
+
+#define CALLNVMETHODV(R, T) R RC_CallNonvirtual ## T ## MethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }                                                                    
+
+#define CALLNVMETHODA(R, T) R RC_CallNonvirtual ## T ## MethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }                                                                    
+
+#define GETFIELD(R, T) R Get ## T ## Field(JNIEnv *env, jobject obj, jfieldID fld) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }
+
+#define SETFIELD(R, T) void Set ## T ## Field(JNIEnv *env, jobject obj, jfieldID fld, R src) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }
+
+#define CALLSTMETHOD(R, T) R RC_CallStatic ## T ## Method(JNIEnv *env, jobject obj, jmethodID mid, ...) { \
+    va_list va;                                                                \
+    va_start(va, mid);                                                 \
+    return RC_CallStatic ## T ## MethodV(env, cls, mid, va);   \
+  }
+
+#define CALLSTMETHODV(R, T) R RC_CallStatic ## T ## MethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }                                                                    
+
+#define CALLSTMETHODA(R, T) R RC_CallStatic ## T ## MethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }                                                                    
+
+#define GETSTFIELD(R, T) R RC_GetStatic ## T ## Field(JNIEnv *env, jclass cls, jfieldID fld) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }
+
+#define SETSTFIELD(R, T) void RC_SetStatic ## T ## Field(JNIEnv *env, jclass cls, jfieldID fld, R src) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }
+
+#define NEWARRAY(R, T) R ## Array RC_New ## T ## Array(JNIEnv *env, jsize size) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return NULL;                                                       \
+  }
+
+#define GETARRAY(R, T) R * RC_Get ## T ## ArrayElements(JNIEnv *env, R ## Array, jboolean * b) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+    return 0;                                                          \
+  }
+
+#define RELEASEARRAY(R, T) void RC_Release ## T ## ArrayElements(JNIEnv *env, R ## Array array, T * ptr, jint num) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+  }
+
+#define GETARRAYREGION(R, T) void Get ## T ## ArrayRegion(JNIEnv *env, R ## Array array, jsize size1, jsize size2, R * ptr) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+  }
+
+#define SETARRAYREGION(R, T) void Set ## T ## ArrayRegion(JNIEnv *env, R ## Array array, jsize size1, jsize size2, const R * ptr) { \
+    printf("MISSING FEATURE IN %d\n",___LINE___);                      \
+  }
+
+#define CALLSET(R, T)                          \
+  CALLMETHOD(R, T)                             \
+  CALLMETHODV(R, T)                            \
+  CALLMETHODA(R, T)                            \
+  CALLNVMETHOD(R, T)                           \
+  CALLNVMETHODV(R, T)                          \
+  CALLNVMETHODA(R, T)                          \
+  GETFIELD(R, T)                               \
+  SETFIELD(R, T)                               \
+  CALLSTMETHOD(R, T)                           \
+  CALLSTMETHODV(R, T)                          \
+  CALLSTMETHODA(R, T)                          \
+  GETSTFIELD(R, T)                             \
+  SETSTFIELD(R, T)                             \
+  NEWARRAY(R, T)                               \
+  GETARRAY(R, T)                               \
+  RELEASEARRAY(R, T)                           \
+  GETARRAYREGION(R, T)                         \
+  SETARRAYREGION(R, T)
+
+CALLSET(jobject, Object);
+
+CALLSET(jboolean, Boolean);
+
+CALLSET(jbyte, Byte);
+
+CALLSET(jchar, Char);
+
+CALLSET(jshort, Short);
+
+CALLSET(jint, Int);
+
+CALLSET(jlong, Long);
+
+CALLSET(jfloat, Float);
+
+CALLSET(jdouble, Double);
+
+void RC_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID mid, ...) {
+  va_list va;                                                         
+  va_start(va, mid);                                                   
+  RC_CallVoidMethodV(env, cls, mid, va);                       
+}
+
+void RC_CallVoidMethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);                                
+}                                                                      
+
+void RC_CallVoidMethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}                                                                      
+
+void RC_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jmethodID mid, ...) {
+  va_list va;                                                         
+  va_start(va, mid);                                                   
+  RC_CallVoidMethodV(env, cls, mid, va);                       
+}
+
+void RC_CallNonvirtualVoidMethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);                                
+}                                                                      
+
+void RC_CallNonvirtualVoidMethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+}                                                                      
+
+jfieldID RC_GetFieldID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jmethodID RC_GetStaticMethodID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jfieldID RC_GetStaticFieldID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return NULL;
+}
+
+jint RC_RegisterNatives(JNIEnv * env, jclass cls, const JNINativeMethod * mid, jint num) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jint RC_UnregisterNatives(JNIEnv * env, jclass cls) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jint RC_MonitorEnter(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jint RC_MonitorExit(JNIEnv * env, jobject obj) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}
+
+jint RC_GetJavaVM(JNIEnv * env, JavaVM ** jvm) {
+  printf("MISSING FEATURE IN %d\n",___LINE___);
+  return 0;
+}

diff --git a/Robust/src/Runtime/jni/jni.c b/Robust/src/Runtime/jni/jni.c
new file mode 100644 (file)
index 0000000..cb0132e
--- /dev/null
+++ b/Robust/src/Runtime/jni/jni.c
@@ -0,0 +1,259 @@
+#include <jni.h>
+#include <jni-private.h>
+
+struct JNINativeInterface JNI_vtable = {
+  NULL, //void *reserved0;
+  NULL, //void *reserved1;
+  NULL, //void *reserved2;
+  NULL, //void *reserved3;
+  RC_GetVersion, //jint     (JNICALL *GetVersion)                   (JNIEnv *);
+  RC_DefineClass, //jclass   (JNICALL *DefineClass)                  (JNIEnv *, const char *, jobject, const jbyte *, jsize);
+  RC_FindClass, //jclass   (JNICALL *FindClass)                    (JNIEnv *, const char *);
+  RC_FromReflectedMethod, // jmethodID (JNICALL *FromReflectedMethod)     (JNIEnv *, jobject);
+  RC_FromRefectedField, //jfieldID  (JNICALL *FromReflectedField)         (JNIEnv *, jobject);
+  RC_ToReflectedMethod, //jobject   (JNICALL *ToReflectedMethod)          (JNIEnv *, jclass, jmethodID, jboolean);
+  RC_GetSuperclass, // jclass   (JNICALL *GetSuperclass)                (JNIEnv *, jclass);
+  RC_IsAssignableFrom, //jboolean (JNICALL *IsAssignableFrom)             (JNIEnv *, jclass, jclass);
+  RC_ToReflectedField,//jobject  (JNICALL *ToReflectedField)              (JNIEnv *, jclass, jfieldID,jboolean);
+  RC_Throw,//jint     (JNICALL *Throw)                        (JNIEnv *, jthrowable);
+  RC_ThrowNew,//jint     (JNICALL *ThrowNew)                     (JNIEnv *, jclass, const char *);
+  RC_ExceptionOccurred,//jthrowable (JNICALL *ExceptionOccurred)          (JNIEnv *);
+  RC_ExceptionDescribe,//void     (JNICALL *ExceptionDescribe)            (JNIEnv *);
+  RC_ExceptionClear, //void     (JNICALL *ExceptionClear)               (JNIEnv *);
+  RC_FatalError,//void     (JNICALL *FatalError)                   (JNIEnv *, const char *);
+  RC_PushLocalFrame,//jint     (JNICALL *PushLocalFrame)                  (JNIEnv *, jint);
+  RC_PopLocalFrame,//jobject  (JNICALL *PopLocalFrame)            (JNIEnv *, jobject);
+  RC_NewGlobalRef,//jobject  (JNICALL *NewGlobalRef)                 (JNIEnv *, jobject);
+  RC_DeleteGlobalRef,//void     (JNICALL *DeleteGlobalRef)              (JNIEnv *, jobject);
+  RC_DeleteLocalRef,//void     (JNICALL *DeleteLocalRef)               (JNIEnv *, jobject);
+  RC_IsSameObject,//jboolean (JNICALL *IsSameObject)                 (JNIEnv *, jobject,                                                     jobject);
+  RC_NewLocalRef,//jobject  (JNICALL *NewLocalRef)                (JNIEnv *, jobject);
+  RC_EnsureLocalCapacity,//jint     (JNICALL *EnsureLocalCapacity)        (JNIEnv *, jint);
+  RC_AllocObject, //jobject  (JNICALL *AllocObject)                  (JNIEnv *, jclass);
+  RC_NewObject,//jobject (JNICALL *NewObject)                     (JNIEnv *, jclass,                                                     jmethodID, ...);
+  RC_NewObjectV,//jobject (JNICALL *NewObjectV)                           (JNIEnv *, jclass,                                                     jmethodID, va_list);
+  RC_NewObjectA, //jobject (JNICALL *NewObjectA)                          (JNIEnv *, jclass,                                                     jmethodID, const jvalue *);
+  RC_GetObjectClass, //  jclass   (JNICALL *GetObjectClass)               (JNIEnv *, jobject);
+  RC_IsInstanceOf, //jboolean (JNICALL *IsInstanceOf)                 (JNIEnv *, jobject, jclass);
+  RC_GetMethodID, //jmethodID (JNICALL *GetMethodID)                 (JNIEnv *, jclass,                                                     const char *, const char *);
+  RC_CallObjectMethod, // jobject (JNICALL *CallObjectMethod)     (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallObjectMethodV, //jobject (JNICALL *CallObjectMethodV)    (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallObjectMethodA, //jobject (JNICALL *CallObjectMethodA)    (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallBooleanMethod, //jboolean (JNICALL *CallBooleanMethod)           (JNIEnv *, jobject, jmethodID,                                            ...);
+  RC_CallBooleanMethodV, //jboolean (JNICALL *CallBooleanMethodV)   (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallBooleanMethodA, //jboolean (JNICALL *CallBooleanMethodA)   (JNIEnv *, jobject, jmethodID,                                           const jvalue *);
+  RC_CallByteMethod, //jbyte (JNICALL *CallByteMethod)   (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallByteMethodV, //jbyte (JNICALL *CallByteMethodV)          (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallByteMethodA, //jbyte (JNICALL *CallByteMethodA)          (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallCharMethod, //jchar (JNICALL *CallCharMethod)    (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallCharMethodV, //jchar (JNICALL *CallCharMethodV)          (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallCharMethodA, //jchar (JNICALL *CallCharMethodA)          (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallShortMethod, //jshort (JNICALL *CallShortMethod)         (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallShortMethodV, //jshort (JNICALL *CallShortMethodV)       (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallShortMethodA, // jshort (JNICALL *CallShortMethodA)      (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallIntMethod, //jint     (JNICALL *CallIntMethod)           (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallIntMethodV, //jint    (JNICALL *CallIntMethodV)          (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallIntMethodA, //jint    (JNICALL *CallIntMethodA)          (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallLongMethod, //jlong (JNICALL *CallLongMethod)    (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallLongMethodV, //jlong (JNICALL *CallLongMethodV)          (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallLongMethodA, //jlong (JNICALL *CallLongMethodA)          (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallFloatMethod, //jfloat (JNICALL *CallFloatMethod)         (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallFloatMethodV, //jfloat (JNICALL *CallFloatMethodV)       (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallFloatMethodA,//jfloat (JNICALL *CallFloatMethodA)        (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallDoubleMethod, //jdouble (JNICALL *CallDoubleMethod)      (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallDoubleMethodV, //jdouble (JNICALL *CallDoubleMethodV)    (JNIEnv *, jobject, jmethodID,va_list);
+  RC_CallDoubleMethodA, //jdouble (JNICALL *CallDoubleMethodA)    (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallVoidMethod, //void  (JNICALL *CallVoidMethod)    (JNIEnv *, jobject, jmethodID, ...);
+  RC_CallVoidMethodV, //void  (JNICALL *CallVoidMethodV)          (JNIEnv *, jobject, jmethodID,                                            va_list);
+  RC_CallVoidMethodA, //void  (JNICALL *CallVoidMethodA)          (JNIEnv *, jobject, jmethodID,                                            const jvalue *);
+  RC_CallNonVirtualObjectMethod,// jobject   (JNICALL *CallNonvirtualObjectMethod)  (JNIEnv *, jobject, jclass,                                                    jmethodID, ...);
+  RC_CallNonVirtualObjectMethodV, //jobject   (JNICALL *CallNonvirtualObjectMethodV) (JNIEnv *, jobject, jclass,                           jmethodID, va_list);
+  RC_CallNonVirtualObjectMethodA, //jobject   (JNICALL *CallNonvirtualObjectMethodA) (JNIEnv *, jobject, jclass,                                                   jmethodID, const jvalue *);
+  RC_CallNonvirtualBooleanMethod,//jboolean  (JNICALL *CallNonvirtualBooleanMethod) (JNIEnv *, jobject, jclass,                                                    jmethodID, ...);
+  RC_CallNonvirtualBooleanMethodV, // jboolean  (JNICALL *CallNonvirtualBooleanMethodV) (JNIEnv *, jobject, jclass,                                                 jmethodID, va_list);
+  RC_CallNonvirtualBooleanMethodA, // jboolean  (JNICALL *CallNonvirtualBooleanMethodA) (JNIEnv *, jobject, jclass,                                                 jmethodID, const jvalue *);
+  RC_CallNonvirtualByteMethod,// jbyte     (JNICALL *CallNonvirtualByteMethod)    (JNIEnv *, jobject, jclass,                                              jmethodID, ...);
+  RC_CallNonvirtualByteMethodV, // jbyte     (JNICALL *CallNonvirtualByteMethodV)   (JNIEnv *, jobject, jclass,                                                    jmethodID, va_list);
+  RC_CallNonvirtualByteMethodA, //jbyte     (JNICALL *CallNonvirtualByteMethodA)   (JNIEnv *, jobject, jclass,                                             jmethodID, const jvalue *);
+  RC_CallNonvirtualCharMethod, // jchar     (JNICALL *CallNonvirtualCharMethod)           (JNIEnv *, jobject, jclass,                                              jmethodID, ...);
+  RC_CallNonvirtualCharMethodV, // jchar     (JNICALL *CallNonvirtualCharMethodV)   (JNIEnv *, jobject, jclass,                                                    jmethodID, va_list);
+  RC_CallNonvirtualCharMethodA, // jchar     (JNICALL *CallNonvirtualCharMethodA)   (JNIEnv *, jobject, jclass,                                                    jmethodID, const jvalue *);
+  RC_CallNonvirtualShortMethod, // jshort    (JNICALL *CallNonvirtualShortMethod)   (JNIEnv *, jobject, jclass,                                                    jmethodID, ...);
+  RC_CallNonvirtualShortMethodV, //jshort    (JNICALL *CallNonvirtualShortMethodV)  (JNIEnv *, jobject, jclass,                                                    jmethodID, va_list);
+  RC_CallNonvirtualShortMethodA,// jshort    (JNICALL *CallNonvirtualShortMethodA)  (JNIEnv *, jobject, jclass,                                                    jmethodID, const jvalue *);
+  RC_CallNonvirtualIntMethod, //jint       (JNICALL *CallNonvirtualIntMethod)     (JNIEnv *, jobject, jclass,                                              jmethodID, ...);
+  RC_CallNonvirtualIntMethodV , //jint             (JNICALL *CallNonvirtualIntMethodV)    (JNIEnv *, jobject, jclass,                                              jmethodID, va_list);
+  RC_CallNonvirtualIntMethodA, //jint      (JNICALL *CallNonvirtualIntMethodA)    (JNIEnv *, jobject, jclass,                                              jmethodID, const jvalue *);
+  RC_CallNonvirtualLongMethod, //jlong     (JNICALL *CallNonvirtualLongMethod)    (JNIEnv *, jobject, jclass,                                              jmethodID, ...);
+  RC_CallNonvirtualLongMethodV, //jlong     (JNICALL *CallNonvirtualLongMethodV)   (JNIEnv *, jobject, jclass,                                             jmethodID, va_list);
+  RC_CallNonvirtualLongMethodA, //jlong     (JNICALL *CallNonvirtualLongMethodA)   (JNIEnv *, jobject, jclass,                                             jmethodID, const jvalue *);
+  RC_CallNonvirtualFloatMethod, //jfloat    (JNICALL *CallNonvirtualFloatMethod)   (JNIEnv *, jobject, jclass,                                             jmethodID, ...);
+  RC_CallNonvirtualFloatMethodV, //jfloat    (JNICALL *CallNonvirtualFloatMethodV)  (JNIEnv *, jobject, jclass,                                                    jmethodID, va_list);
+  RC_CallNonvirtualFloatMethodA, //jfloat    (JNICALL *CallNonvirtualFloatMethodA)  (JNIEnv *, jobject, jclass,                                                    jmethodID, const jvalue *);
+  RC_CallNonvirtualDoubleMethod, //jdouble   (JNICALL *CallNonvirtualDoubleMethod)  (JNIEnv *, jobject, jclass,                                                    jmethodID, ...);
+  RC_CallNonvirtualDoubleMethodV, //jdouble   (JNICALL *CallNonvirtualDoubleMethodV) (JNIEnv *, jobject, jclass,                                                   jmethodID, va_list);
+  RC_CallNonvirtualDoubleMethodA, //jdouble   (JNICALL *CallNonvirtualDoubleMethodA) (JNIEnv *, jobject, jclass,                                                   jmethodID, const jvalue *);
+  RC_CallNonvirtualVoidMethod,//void      (JNICALL *CallNonvirtualVoidMethod)     (JNIEnv *, jobject, jclass,                                              jmethodID, ...);
+  RC_CallNonvirtualVoidMethodV, //void      (JNICALL *CallNonvirtualVoidMethodV)   (JNIEnv *, jobject, jclass,                                             jmethodID, va_list);
+  RC_CallNonvirtualVoidMethodA, //void      (JNICALL *CallNonvirtualVoidMethodA)   (JNIEnv *, jobject, jclass,                                             jmethodID, const jvalue *);
+
+  RC_GetFieldID, //jfieldID  (JNICALL *GetFieldID)          (JNIEnv *, jclass, const char *,                                       const char *);
+
+  RC_GetObjectField, //jobject  (JNICALL *GetObjectField)       (JNIEnv *, jobject, jfieldID);
+  RC_GetBooleanField, //jboolean (JNICALL *GetBooleanField)      (JNIEnv *, jobject, jfieldID);
+  RC_GetByteField,//jbyte    (JNICALL *GetByteField)         (JNIEnv *, jobject, jfieldID);
+  RC_GetCharField, //jchar    (JNICALL *GetCharField)         (JNIEnv *, jobject, jfieldID);
+  RC_GetShortField, //jshort   (JNICALL *GetShortField)        (JNIEnv *, jobject, jfieldID);
+  RC_GetIntField,//jint     (JNICALL *GetIntField)          (JNIEnv *, jobject, jfieldID);
+  RC_GetLongField, //jlong    (JNICALL *GetLongField)         (JNIEnv *, jobject, jfieldID);
+  RC_GetFloatField, //jfloat   (JNICALL *GetFloatField)        (JNIEnv *, jobject, jfieldID);
+  RC_GetDoubleField, //jdouble  (JNICALL *GetDoubleField)       (JNIEnv *, jobject, jfieldID);
+
+  RC_SetObjectField, //void    (JNICALL *SetObjectField)          (JNIEnv *, jobject,                                      jfieldID, jobject);
+  RC_SetBooleanField, //void   (JNICALL *SetBooleanField)         (JNIEnv *, jobject,                                      jfieldID, jboolean);
+  RC_SetByteField,// void      (JNICALL *SetByteField)            (JNIEnv *, jobject,                                      jfieldID, jbyte);
+  RC_SetCharField, //void      (JNICALL *SetCharField)            (JNIEnv *, jobject,                                      jfieldID, jchar);
+  RC_SetShortField, //void     (JNICALL *SetShortField)           (JNIEnv *, jobject,                                      jfieldID, jshort);
+  RC_SetIntField, //void       (JNICALL *SetIntField)             (JNIEnv *, jobject,                                      jfieldID, jint);
+  RC_SetLongField,//void       (JNICALL *SetLongField)            (JNIEnv *, jobject,                                      jfieldID, jlong);
+  RC_SetFloatField, //void     (JNICALL *SetFloatField)           (JNIEnv *, jobject,                                      jfieldID, jfloat);
+  RC_SetDoubleField,//void     (JNICALL *SetDoubleField)          (JNIEnv *, jobject,                                      jfieldID, jdouble);
+
+  RC_GetStaticMethodID, //jmethodID (JNICALL *GetStaticMethodID)   (JNIEnv *, jclass, const char *,                                        const char *);
+
+  RC_CallStaticObjectMethod, //jobject  (JNICALL *CallStaticObjectMethod)  (JNIEnv *, jclass, jmethodID,                                              ...);
+  RC_CallStaticObjectMethodV, //jobject  (JNICALL *CallStaticObjectMethodV) (JNIEnv *, jclass, jmethodID,                                             va_list);
+  RC_CallStaticObjectMethodA, //jobject  (JNICALL *CallStaticObjectMethodA) (JNIEnv *, jclass, jmethodID,                                             const jvalue *);
+  RC_CallStaticBooleanMethod,//jboolean (JNICALL *CallStaticBooleanMethod) (JNIEnv *, jclass, jmethodID,                                              ...);
+  RC_CallStaticBooleanMethodV, //jboolean (JNICALL *CallStaticBooleanMethodV) (JNIEnv *, jclass, jmethodID,                                            va_list);
+  RC_CallStaticBooleanMethodA, //jboolean (JNICALL *CallStaticBooleanMethodA) (JNIEnv *, jclass, jmethodID,                                            const jvalue *);
+  RC_CallStaticByteMethod, //jbyte        (JNICALL *CallStaticByteMethod)    (JNIEnv *, jclass, jmethodID,                                            ...);
+  RC_CallStaticByteMethodV, //jbyte    (JNICALL *CallStaticByteMethodV)   (JNIEnv *, jclass, jmethodID,                                               va_list);
+  RC_CallStaticByteMethodA, //jbyte    (JNICALL *CallStaticByteMethodA)   (JNIEnv *, jclass, jmethodID,                                               const jvalue *);
+  RC_CallStaticCharMethod, //jchar    (JNICALL *CallStaticCharMethod)    (JNIEnv *, jclass, jmethodID,                                        ...);
+  RC_CallStaticCharMethodV, //jchar    (JNICALL *CallStaticCharMethodV)   (JNIEnv *, jclass, jmethodID,                                               va_list);
+  RC_CallStaticCharMethodA,//  jchar    (JNICALL *CallStaticCharMethodA)   (JNIEnv *, jclass, jmethodID,                                              const jvalue *);
+  RC_CallStaticShortMethod, //jshort   (JNICALL *CallStaticShortMethod)   (JNIEnv *, jclass, jmethodID,                                               ...);
+  RC_CallStaticShortMethodV ,//jshort   (JNICALL *CallStaticShortMethodV)  (JNIEnv *, jclass, jmethodID,                                              va_list);
+  RC_CallStaticShortMethodA, //jshort   (JNICALL *CallStaticShortMethodA)  (JNIEnv *, jclass, jmethodID,                                              const jvalue *);
+  RC_CallStaticIntMethod, //jint          (JNICALL *CallStaticIntMethod)     (JNIEnv *, jclass, jmethodID,                                            ...);
+  RC_CallStaticIntMethodV, //jint         (JNICALL *CallStaticIntMethodV)    (JNIEnv *, jclass, jmethodID,                                            va_list);
+  RC_CallStaticIntMethodA, //jint         (JNICALL *CallStaticIntMethodA)    (JNIEnv *, jclass, jmethodID,                                            const jvalue *);
+  RC_CallStaticLongMethod, //jlong    (JNICALL *CallStaticLongMethod)    (JNIEnv *, jclass, jmethodID,                                        ...);
+  RC_CallStaticLongMethodV,//jlong    (JNICALL *CallStaticLongMethodV)   (JNIEnv *, jclass, jmethodID,                                        va_list);
+  RC_CallStaticLongMethodA, //jlong    (JNICALL *CallStaticLongMethodA)   (JNIEnv *, jclass, jmethodID,                                               const jvalue *);
+  RC_CallStaticFloatMethod, //jfloat   (JNICALL *CallStaticFloatMethod)   (JNIEnv *, jclass, jmethodID,                                               ...);
+  RC_CallStaticFloatMethodV, //jfloat   (JNICALL *CallStaticFloatMethodV)  (JNIEnv *, jclass, jmethodID,                                              va_list);
+  RC_CallStaticFloatMethodA,//jfloat   (JNICALL *CallStaticFloatMethodA)  (JNIEnv *, jclass, jmethodID,                                               const jvalue *);
+  RC_CallStaticDoubleMethod, //jdouble  (JNICALL *CallStaticDoubleMethod)  (JNIEnv *, jclass, jmethodID,                                              ...);
+  RC_CallStaticDoubleMethodV, //jdouble  (JNICALL *CallStaticDoubleMethodV) (JNIEnv *, jclass, jmethodID,                                             va_list);
+  RC_CallStaticDoubleMethodA,// jdouble  (JNICALL *CallStaticDoubleMethodA) (JNIEnv *, jclass, jmethodID,                                             const jvalue *);
+  RC_CallStaticVoidMethod, //void     (JNICALL *CallStaticVoidMethod)    (JNIEnv *, jclass, jmethodID,                                        ...);
+  RC_CallStaticVoidMethodV, //void     (JNICALL *CallStaticVoidMethodV)   (JNIEnv *, jclass, jmethodID,                                       va_list);
+  RC_CallStaticVoidMethodA, //void     (JNICALL *CallStaticVoidMethodA)   (JNIEnv *, jclass, jmethodID,                                               const jvalue *);
+  RC_GetStaticFieldID, //  jfieldID (JNICALL *GetStaticFieldID)        (JNIEnv *, jclass, const char *,                                               const char *);
+  RC_GetStaticObjectField, //  jobject  (JNICALL *GetStaticObjectField)    (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticBooleanField,// jboolean (JNICALL *GetStaticBooleanField)   (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticByteField,//jbyte           (JNICALL *GetStaticByteField)      (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticCharField,//jchar           (JNICALL *GetStaticCharField)      (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticShortField,//jshort   (JNICALL *GetStaticShortField)     (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticIntField,//jint     (JNICALL *GetStaticIntField)       (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticLongField,//jlong           (JNICALL *GetStaticLongField)      (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticFloatField,//jfloat   (JNICALL *GetStaticFloatField)     (JNIEnv *, jclass, jfieldID);
+  RC_GetStaticDoubleField,//jdouble  (JNICALL *GetStaticDoubleField)    (JNIEnv *, jclass, jfieldID);
+
+  RC_SetStaticObjectField,//void       (JNICALL *SetStaticObjectField)    (JNIEnv *, jclass,                                       jfieldID, jobject);
+  RC_SetStaticBooleanField,//void      (JNICALL *SetStaticBooleanField)   (JNIEnv *, jclass,                                       jfieldID, jboolean);
+  RC_SetStaticByteField,//void         (JNICALL *SetStaticByteField)      (JNIEnv *, jclass,                                       jfieldID, jbyte);
+  RC_SetStaticCharField,//void         (JNICALL *SetStaticCharField)      (JNIEnv *, jclass,                                       jfieldID, jchar);
+  RC_SetStaticShortField,//void        (JNICALL *SetStaticShortField)     (JNIEnv *, jclass,                                       jfieldID, jshort);
+  RC_SetStaticIntField,//void  (JNICALL *SetStaticIntField)       (JNIEnv *, jclass,                                       jfieldID, jint);
+  RC_SetStaticLongField,//void         (JNICALL *SetStaticLongField)      (JNIEnv *, jclass,                                       jfieldID, jlong);
+  RC_SetStaticFloatField,//void        (JNICALL *SetStaticFloatField)     (JNIEnv *, jclass,                                       jfieldID, jfloat);
+  RC_SetStaticDoubleField,//void       (JNICALL *SetStaticDoubleField)    (JNIEnv *, jclass,                                       jfieldID, jdouble);
+
+  RC_NewString,//jstring  (JNICALL *NewString)            (JNIEnv *, const jchar *, jsize);
+  RC_GetStringLength,//jsize    (JNICALL *GetStringLength)      (JNIEnv *, jstring);
+  RC_GetStringChars,//const jchar * (JNICALL *GetStringChars)  (JNIEnv *, jstring, jboolean *);
+  RC_ReleaseStringChars,//void     (JNICALL *ReleaseStringChars)   (JNIEnv *, jstring, const jchar *);
+  RC_NewStringUTF,//jstring  (JNICALL *NewStringUTF)         (JNIEnv *, const char *);
+  RC_GetStringUTFLength,//jsize    (JNICALL *GetStringUTFLength)   (JNIEnv *, jstring);
+  RC_GetStringUTFChars,//const char * (JNICALL *GetStringUTFChars) (JNIEnv *, jstring, jboolean *);
+  RC_ReleaseStringUTFChars,//void     (JNICALL *ReleaseStringUTFChars) (JNIEnv *, jstring, const char *);
+  RC_GetArrayLength,//jsize    (JNICALL *GetArrayLength)       (JNIEnv *, jarray);
+  RC_NewObjectArray,//jobjectArray (JNICALL *NewObjectArray)    (JNIEnv *, jsize, jclass, jobject);
+  RC_GetObjectArrayElement,//jobject  (JNICALL *GetObjectArrayElement) (JNIEnv *, jobjectArray, jsize);
+  RC_SetObjectArrayElement,//void     (JNICALL *SetObjectArrayElement) (JNIEnv *, jobjectArray, jsize,                                      jobject);
+
+  RC_NewBooleanArray,//jbooleanArray (JNICALL *NewBooleanArray)           (JNIEnv *, jsize);
+  RC_NewByteArray,//jbyteArray    (JNICALL *NewByteArray)                 (JNIEnv *, jsize);
+  RC_NewCharArray,//jcharArray    (JNICALL *NewCharArray)                 (JNIEnv *, jsize);
+  RC_NewShortArray,//jshortArray   (JNICALL *NewShortArray)       (JNIEnv *, jsize);
+  RC_NewIntArray,//jintArray     (JNICALL *NewIntArray)                   (JNIEnv *, jsize);
+  RC_NewLongArray,//jlongArray    (JNICALL *NewLongArray)                 (JNIEnv *, jsize);
+  RC_NewFloatArray,//jfloatArray   (JNICALL *NewFloatArray)       (JNIEnv *, jsize);
+  RC_NewDoubleArray,//jdoubleArray  (JNICALL *NewDoubleArray)     (JNIEnv *, jsize);
+
+  RC_GetBooleanArrayElements,//jboolean *      (JNICALL *GetBooleanArrayElements) (JNIEnv *, jbooleanArray,                                                jboolean *);
+  RC_GetByteArrayElements,//jbyte *    (JNICALL *GetByteArrayElements)    (JNIEnv *, jbyteArray,                                                   jboolean *);
+  RC_GetCharArrayElements,//jchar *    (JNICALL *GetCharArrayElements)    (JNIEnv *, jcharArray,                                                   jboolean *);
+  RC_GetShortArrayElements,//jshort *  (JNICALL *GetShortArrayElements)   (JNIEnv *, jshortArray,                                                  jboolean *);
+  RC_GetIntArrayElements,//jint *      (JNICALL *GetIntArrayElements)     (JNIEnv *, jintArray,                                                    jboolean *);
+  RC_GetLongArrayElements,//jlong *    (JNICALL *GetLongArrayElements)    (JNIEnv *, jlongArray,                                                   jboolean *);
+  RC_GetFloatArrayElements,//jfloat *  (JNICALL *GetFloatArrayElements)   (JNIEnv *, jfloatArray,                                                  jboolean *);
+  RC_GetDoubleArrayElements,//jdouble *        (JNICALL *GetDoubleArrayElements)  (JNIEnv *, jdoubleArray,                                                 jboolean *);
+
+  RC_ReleaseBooleanArrayElements,//void                (JNICALL *ReleaseBooleanArrayElements) (JNIEnv *, jbooleanArray,                                                        jboolean *, jint);
+  RC_ReleaseByteArrayElements,//void           (JNICALL *ReleaseByteArrayElements)    (JNIEnv *, jbyteArray,                                                   jbyte *, jint);
+  RC_ReleaseCharArrayElements,//void           (JNICALL *ReleaseCharArrayElements)    (JNIEnv *, jcharArray,                                                   jchar *, jint);
+  RC_ReleaseShortArrayElements,//void          (JNICALL *ReleaseShortArrayElements)   (JNIEnv *, jshortArray,                                                  jshort *, jint);
+  RC_ReleaseIntArrayElements,//void            (JNICALL *ReleaseIntArrayElements)     (JNIEnv *, jintArray,                                                    jint *, jint);
+  RC_ReleaseLongArrayElements,//void           (JNICALL *ReleaseLongArrayElements)    (JNIEnv *, jlongArray,                                                   jlong *, jint);
+  RC_ReleaseFloatArrayElements,//void          (JNICALL *ReleaseFloatArrayElements)   (JNIEnv *, jfloatArray,                                                  jfloat *, jint);
+  RC_ReleaseDoubleArrayElements,//void         (JNICALL *ReleaseDoubleArrayElements)  (JNIEnv *, jdoubleArray,                                                 jdouble *, jint);
+  RC_GetBooleanArrayRegion,//void              (JNICALL *GetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,                                                jsize, jsize, jboolean *);
+  RC_GetByteArrayRegion,//void                 (JNICALL *GetByteArrayRegion)      (JNIEnv *, jbyteArray,                                                   jsize, jsize, jbyte *);
+  RC_GetCharArrayRegion,//void                 (JNICALL *GetCharArrayRegion)      (JNIEnv *, jcharArray,                                                   jsize, jsize, jchar *);
+  RC_GetShortArrayRegion,//void                (JNICALL *GetShortArrayRegion)     (JNIEnv *, jshortArray,                                                  jsize, jsize, jshort *);
+  RC_GetIntArrayRegion,//void          (JNICALL *GetIntArrayRegion)       (JNIEnv *, jintArray,                                                    jsize, jsize, jint *);
+  RC_GetLongArrayRegion,//void                 (JNICALL *GetLongArrayRegion)      (JNIEnv *, jlongArray,                                                   jsize, jsize, jlong *);
+  RC_GetFloatArrayRegion,//void                (JNICALL *GetFloatArrayRegion)     (JNIEnv *, jfloatArray,                                                  jsize, jsize, jfloat *);
+  RC_GetDoubleArrayRegion,//void               (JNICALL *GetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,                                                 jsize, jsize, jdouble *);
+
+  RC_SetBooleanArrayRegion,//void              (JNICALL *SetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,                                                jsize, jsize,                                                    const jboolean *);
+  RC_SetByteArrayRegion,//void                 (JNICALL *SetByteArrayRegion)      (JNIEnv *, jbyteArray,                                                   jsize, jsize,                                                    const jbyte *);
+  RC_SetCharArrayRegion,//void                 (JNICALL *SetCharArrayRegion)      (JNIEnv *, jcharArray,                                                   jsize, jsize,                                                    const jchar *);
+  RC_SetShortArrayRegion,//void                (JNICALL *SetShortArrayRegion)     (JNIEnv *, jshortArray,                                                  jsize, jsize,                                                    const jshort *);
+  RC_SetIntArrayRegion,//void          (JNICALL *SetIntArrayRegion)       (JNIEnv *, jintArray,                                                    jsize, jsize,                                                    const jint *);
+  RC_SetLongArrayRegion,//void                 (JNICALL *SetLongArrayRegion)      (JNIEnv *, jlongArray,                                                   jsize, jsize,                                                    const jlong *);
+  RC_SetFloatArrayRegion,//void                (JNICALL *SetFloatArrayRegion)     (JNIEnv *, jfloatArray,                                                  jsize, jsize,                                                    const jfloat *);
+  RC_SetDoubleArrayRegion,//void               (JNICALL *SetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,                                                 jsize, jsize,                                                    const jdouble *);
+
+  RC_RegisterNatives,//jint     (JNICALL *RegisterNatives)              (JNIEnv *, jclass,                                                 const JNINativeMethod *,                                                jint);
+  RC_UnregisterNatives,//jint     (JNICALL *UnregisterNatives)            (JNIEnv *, jclass);
+  RC_MonitorEnter,//jint     (JNICALL *MonitorEnter)                 (JNIEnv *, jobject);
+  RC_MonitorExit,//jint     (JNICALL *MonitorExit)                  (JNIEnv *, jobject);
+  RC_GetJavaVM,//jint     (JNICALL *GetJavaVM)                    (JNIEnv *, JavaVM **);
+
+  /* ---- JNI 1.2 functions ---- */
+
+  NULL, //void    (JNICALL *GetStringRegion)              (JNIEnv *, jstring, jsize,                                               jsize, jchar *);
+  NULL, //void     (JNICALL *GetStringUTFRegion)          (JNIEnv *, jstring, jsize,                                               jsize, char *);
+  NULL, //void * (JNICALL *GetPrimitiveArrayCritical)      (JNIEnv *, jarray,                                                     jboolean *);
+  NULL, //void   (JNICALL *ReleasePrimitiveArrayCritical)  (JNIEnv *, jarray, void *,                                                     jint);
+  NULL, // const jchar * (JNICALL *GetStringCritical)       (JNIEnv *, jstring,                                                     jboolean *);
+  NULL, //void          (JNICALL *ReleaseStringCritical)   (JNIEnv *, jstring,                                                   const jchar *);
+  NULL, //  jweak  (JNICALL *NewWeakGlobalRef)               (JNIEnv *, jobject);
+  NULL, //void   (JNICALL *DeleteWeakGlobalRef)            (JNIEnv *, jweak);
+  NULL, //  jboolean   (JNICALL *ExceptionCheck)          (JNIEnv *);
+
+  /* ---- JNI 1.4 functions ---- */
+
+  NULL, //jobject (JNICALL *NewDirectByteBuffer)           (JNIEnv *, void *, jlong);
+  NULL, //void *  (JNICALL *GetDirectBufferAddress)        (JNIEnv *, jobject);
+  NULL, //jlong   (JNICALL *GetDirectBufferCapacity)       (JNIEnv *, jobject);
+
+  /* ---- JNI 1.6 functions ---- */
+
+  NULL, //jobjectRefType (JNICALL *GetObjectRefType)       (JNIEnv *, jobject);
+};

diff --git a/Robust/src/Runtime/jni/jni.h b/Robust/src/Runtime/jni/jni.h
new file mode 100644 (file)
index 0000000..1c4e697
--- /dev/null
+++ b/Robust/src/Runtime/jni/jni.h
@@ -0,0 +1,1679 @@
+/* jni.h
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008  Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+/* Note: this file must be compilable by the C compiler (for now,
+   assuming GNU C is ok).  This means you must never use `//'
+   comments, and all C++-specific code must be conditional on
+   __cplusplus.  */
+
+#ifndef _CLASSPATH_JNI_H
+#define _CLASSPATH_JNI_H
+
+/* We include <stdio.h> for compatibility with Sun's <jni.h>.  */
+#include <stdio.h>
+
+#include <stdarg.h>
+
+#include "jni_md.h"
+
+/* The VM might define jobject and friends.  */
+#ifndef _CLASSPATH_VM_JNI_TYPES_DEFINED
+
+# ifdef __cplusplus
+
+/* Define dummy classes and then define the JNI types as pointers.  */
+struct __jobject {};
+struct __jclass : __jobject {};
+struct __jstring : __jobject {};
+struct __jthrowable : __jobject {};
+struct __jweak : __jobject {};
+struct __jarray : __jobject {};
+struct __jobjectArray : __jarray {};
+struct __jbyteArray : __jarray {};
+struct __jshortArray : __jarray {};
+struct __jintArray : __jarray {};
+struct __jlongArray : __jarray {};
+struct __jbooleanArray : __jarray {};
+struct __jcharArray : __jarray {};
+struct __jfloatArray : __jarray {};
+struct __jdoubleArray : __jarray {};
+
+typedef __jobject *jobject;
+typedef __jclass *jclass;
+typedef __jstring *jstring;
+typedef __jthrowable *jthrowable;
+typedef __jweak *jweak;
+typedef __jarray *jarray;
+typedef __jobjectArray *jobjectArray;
+typedef __jbyteArray *jbyteArray;
+typedef __jshortArray *jshortArray;
+typedef __jintArray *jintArray;
+typedef __jlongArray *jlongArray;
+typedef __jbooleanArray *jbooleanArray;
+typedef __jcharArray *jcharArray;
+typedef __jfloatArray *jfloatArray;
+typedef __jdoubleArray *jdoubleArray;
+
+#define JNI_TRUE true
+#define JNI_FALSE false
+
+typedef struct _Jv_JNIEnv JNIEnv;
+typedef struct _Jv_JavaVM JavaVM;
+
+# else /* __cplusplus */
+
+/* For C, simply define the class types as generic pointers.  */
+typedef void *jobject;
+typedef jobject jclass;
+typedef jobject jstring;
+typedef jobject jthrowable;
+typedef jobject jweak;
+typedef jobject jarray;
+typedef jobject jobjectArray;
+typedef jobject jbyteArray;
+typedef jobject jshortArray;
+typedef jobject jintArray;
+typedef jobject jlongArray;
+typedef jobject jbooleanArray;
+typedef jobject jcharArray;
+typedef jobject jfloatArray;
+typedef jobject jdoubleArray;
+
+#define JNI_TRUE  1
+#define JNI_FALSE 0
+
+typedef const struct JNINativeInterface_ *JNIEnv;
+typedef const struct JNIInvokeInterface_ *JavaVM;
+
+# endif /* __cplusplus */
+
+#endif /* _CLASSPATH_VM_JNI_TYPES_DEFINED */
+
+/* 
+ * Before jni.h is #included within a typical JVM, the source code should 
+ * #define _JNI_VM_INTERNAL_TYPES_DEFINED and provide the real declarations
+ * for 'jobject', 'jfieldID', 'jmethodID' and other implementation types.
+ * If _JNI_VM_INTERNAL_TYPES_DEFINED is not defined, the following 
+ * declares the old versions of the types.
+ */
+#ifndef _CLASSPATH_VM_INTERNAL_TYPES_DEFINED
+struct _jfieldID;
+struct _jmethodID;
+typedef struct _jfieldID *jfieldID;
+typedef struct _jmethodID *jmethodID;
+#endif 
+
+/* Version numbers.  */
+#define JNI_VERSION_1_1 0x00010001
+#define JNI_VERSION_1_2 0x00010002
+#define JNI_VERSION_1_4 0x00010004
+#define JNI_VERSION_1_6 0x00010006
+
+/* Used when releasing array elements.  */
+#define JNI_COMMIT 1
+#define JNI_ABORT  2
+
+/* Error codes */
+#define JNI_OK            0
+#define JNI_ERR          (-1)
+#define JNI_EDETACHED    (-2)
+#define JNI_EVERSION     (-3)
+
+enum _jobjectRefType
+{
+  JNIInvalidRefType    = 0,
+  JNILocalRefType      = 1,
+  JNIGlobalRefType     = 2,
+  JNIWeakGlobalRefType = 3 
+};
+
+typedef enum _jobjectRefType jobjectRefType;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* These functions might be defined in libraries which we load; the
+   JNI implementation calls them at the appropriate times.  */
+extern JNIEXPORT jint JNICALL JNI_OnLoad (JavaVM *, void *);
+extern JNIEXPORT void JNICALL JNI_OnUnload (JavaVM *, void *);
+
+/* This can be defined as JNIIMPORT or JNIEXPORT by the md file,
+   depending on whether this is the implementation or a user.  */
+#ifndef _CLASSPATH_JNIIMPEXP
+#define _CLASSPATH_JNIIMPEXP JNIIMPORT
+#endif
+
+/* These functions are called by user code to start using the
+   invocation API.  */
+extern _CLASSPATH_JNIIMPEXP jint JNICALL
+JNI_GetDefaultJavaVMInitArgs (void *);
+
+extern _CLASSPATH_JNIIMPEXP jint JNICALL
+JNI_CreateJavaVM (JavaVM **, void **, void *);
+
+extern _CLASSPATH_JNIIMPEXP jint JNICALL
+JNI_GetCreatedJavaVMs (JavaVM **, jsize, jsize *);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+typedef union jvalue
+{
+  jboolean z;
+  jbyte    b;
+  jchar    c;
+  jshort   s;
+  jint     i;
+  jlong    j;
+  jfloat   f;
+  jdouble  d;
+  jobject  l;
+} jvalue;
+
+/* This structure is used when registering native methods.  */
+typedef struct
+{
+  char *name;
+  char *signature;
+  void *fnPtr;                 /* Sigh.  */
+} JNINativeMethod;
+
+struct JNINativeInterface_
+{
+  void *reserved0;
+  void *reserved1;
+  void *reserved2;
+  void *reserved3;
+
+  jint     (JNICALL *GetVersion)                   (JNIEnv *);
+  jclass   (JNICALL *DefineClass)                  (JNIEnv *, const char *,
+                                                   jobject, const jbyte *,
+                                                   jsize);
+  jclass   (JNICALL *FindClass)                    (JNIEnv *, const char *);
+
+  jmethodID (JNICALL *FromReflectedMethod)        (JNIEnv *, jobject);
+  jfieldID  (JNICALL *FromReflectedField)         (JNIEnv *, jobject);
+  jobject   (JNICALL *ToReflectedMethod)          (JNIEnv *, jclass,
+                                                   jmethodID, jboolean);
+
+  jclass   (JNICALL *GetSuperclass)                (JNIEnv *, jclass);
+  jboolean (JNICALL *IsAssignableFrom)             (JNIEnv *, jclass, jclass);
+
+  jobject  (JNICALL *ToReflectedField)            (JNIEnv *, jclass, jfieldID,
+                                                    jboolean);
+
+  jint     (JNICALL *Throw)                        (JNIEnv *, jthrowable);
+  jint     (JNICALL *ThrowNew)                     (JNIEnv *, jclass, 
+                                                    const char *);
+  jthrowable (JNICALL *ExceptionOccurred)          (JNIEnv *);
+  void     (JNICALL *ExceptionDescribe)            (JNIEnv *);
+  void     (JNICALL *ExceptionClear)               (JNIEnv *);
+  void     (JNICALL *FatalError)                   (JNIEnv *, const char *);
+
+  jint     (JNICALL *PushLocalFrame)              (JNIEnv *, jint);
+  jobject  (JNICALL *PopLocalFrame)               (JNIEnv *, jobject);
+
+  jobject  (JNICALL *NewGlobalRef)                 (JNIEnv *, jobject);
+  void     (JNICALL *DeleteGlobalRef)              (JNIEnv *, jobject);
+  void     (JNICALL *DeleteLocalRef)               (JNIEnv *, jobject);
+  jboolean (JNICALL *IsSameObject)                 (JNIEnv *, jobject, 
+                                                    jobject);
+
+  jobject  (JNICALL *NewLocalRef)                 (JNIEnv *, jobject);
+  jint     (JNICALL *EnsureLocalCapacity)         (JNIEnv *, jint);
+
+  jobject  (JNICALL *AllocObject)                  (JNIEnv *, jclass);
+  jobject (JNICALL *NewObject)                    (JNIEnv *, jclass, 
+                                                    jmethodID, ...);
+  jobject (JNICALL *NewObjectV)                           (JNIEnv *, jclass, 
+                                                    jmethodID, va_list);
+  jobject (JNICALL *NewObjectA)                           (JNIEnv *, jclass, 
+                                                    jmethodID, const jvalue *);
+
+  jclass   (JNICALL *GetObjectClass)               (JNIEnv *, jobject);
+  jboolean (JNICALL *IsInstanceOf)                 (JNIEnv *, jobject, jclass);
+  jmethodID (JNICALL *GetMethodID)                 (JNIEnv *, jclass, 
+                                                    const char *, const char *);
+
+  jobject (JNICALL *CallObjectMethod)     (JNIEnv *, jobject, jmethodID, ...);
+  jobject (JNICALL *CallObjectMethodV)    (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jobject (JNICALL *CallObjectMethodA)    (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jboolean (JNICALL *CallBooleanMethod)           (JNIEnv *, jobject, jmethodID,
+                                            ...);
+  jboolean (JNICALL *CallBooleanMethodV)   (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jboolean (JNICALL *CallBooleanMethodA)   (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jbyte (JNICALL *CallByteMethod)   (JNIEnv *, jobject, jmethodID, ...);
+  jbyte (JNICALL *CallByteMethodV)        (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jbyte (JNICALL *CallByteMethodA)        (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jchar (JNICALL *CallCharMethod)         (JNIEnv *, jobject, jmethodID, ...);
+  jchar (JNICALL *CallCharMethodV)        (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jchar (JNICALL *CallCharMethodA)        (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jshort (JNICALL *CallShortMethod)       (JNIEnv *, jobject, jmethodID, ...);
+  jshort (JNICALL *CallShortMethodV)      (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jshort (JNICALL *CallShortMethodA)      (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jint         (JNICALL *CallIntMethod)           (JNIEnv *, jobject, jmethodID, ...);
+  jint         (JNICALL *CallIntMethodV)          (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jint         (JNICALL *CallIntMethodA)          (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jlong (JNICALL *CallLongMethod)         (JNIEnv *, jobject, jmethodID, ...);
+  jlong (JNICALL *CallLongMethodV)        (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jlong (JNICALL *CallLongMethodA)        (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jfloat (JNICALL *CallFloatMethod)       (JNIEnv *, jobject, jmethodID, ...);
+  jfloat (JNICALL *CallFloatMethodV)      (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jfloat (JNICALL *CallFloatMethodA)      (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  jdouble (JNICALL *CallDoubleMethod)     (JNIEnv *, jobject, jmethodID, ...);
+  jdouble (JNICALL *CallDoubleMethodV)    (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  jdouble (JNICALL *CallDoubleMethodA)    (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+  void  (JNICALL *CallVoidMethod)         (JNIEnv *, jobject, jmethodID, ...);
+  void  (JNICALL *CallVoidMethodV)        (JNIEnv *, jobject, jmethodID,
+                                            va_list);
+  void  (JNICALL *CallVoidMethodA)        (JNIEnv *, jobject, jmethodID,
+                                            const jvalue *);
+
+  jobject   (JNICALL *CallNonvirtualObjectMethod)  (JNIEnv *, jobject, jclass,
+                                                    jmethodID, ...);
+  jobject   (JNICALL *CallNonvirtualObjectMethodV) (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jobject   (JNICALL *CallNonvirtualObjectMethodA) (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  jboolean  (JNICALL *CallNonvirtualBooleanMethod) (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jboolean  (JNICALL *CallNonvirtualBooleanMethodV) (JNIEnv *, jobject, jclass,
+                                                    jmethodID, va_list);
+  jboolean  (JNICALL *CallNonvirtualBooleanMethodA) (JNIEnv *, jobject, jclass,
+                                                    jmethodID, const jvalue *);
+  jbyte     (JNICALL *CallNonvirtualByteMethod)           (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jbyte     (JNICALL *CallNonvirtualByteMethodV)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jbyte     (JNICALL *CallNonvirtualByteMethodA)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  jchar     (JNICALL *CallNonvirtualCharMethod)           (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jchar     (JNICALL *CallNonvirtualCharMethodV)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jchar     (JNICALL *CallNonvirtualCharMethodA)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  jshort    (JNICALL *CallNonvirtualShortMethod)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jshort    (JNICALL *CallNonvirtualShortMethodV)  (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jshort    (JNICALL *CallNonvirtualShortMethodA)  (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  jint             (JNICALL *CallNonvirtualIntMethod)     (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jint             (JNICALL *CallNonvirtualIntMethodV)    (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jint             (JNICALL *CallNonvirtualIntMethodA)    (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  jlong     (JNICALL *CallNonvirtualLongMethod)           (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jlong     (JNICALL *CallNonvirtualLongMethodV)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jlong     (JNICALL *CallNonvirtualLongMethodA)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  jfloat    (JNICALL *CallNonvirtualFloatMethod)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jfloat    (JNICALL *CallNonvirtualFloatMethodV)  (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jfloat    (JNICALL *CallNonvirtualFloatMethodA)  (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  jdouble   (JNICALL *CallNonvirtualDoubleMethod)  (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  jdouble   (JNICALL *CallNonvirtualDoubleMethodV) (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  jdouble   (JNICALL *CallNonvirtualDoubleMethodA) (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+  void      (JNICALL *CallNonvirtualVoidMethod)           (JNIEnv *, jobject, jclass,
+                                                   jmethodID, ...);
+  void      (JNICALL *CallNonvirtualVoidMethodV)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, va_list);
+  void      (JNICALL *CallNonvirtualVoidMethodA)   (JNIEnv *, jobject, jclass,
+                                                   jmethodID, const jvalue *);
+
+  jfieldID  (JNICALL *GetFieldID)          (JNIEnv *, jclass, const char *,
+                                           const char *);
+
+  jobject  (JNICALL *GetObjectField)       (JNIEnv *, jobject, jfieldID);
+  jboolean (JNICALL *GetBooleanField)      (JNIEnv *, jobject, jfieldID);
+  jbyte    (JNICALL *GetByteField)         (JNIEnv *, jobject, jfieldID);
+  jchar    (JNICALL *GetCharField)         (JNIEnv *, jobject, jfieldID);
+  jshort   (JNICALL *GetShortField)        (JNIEnv *, jobject, jfieldID);
+  jint     (JNICALL *GetIntField)          (JNIEnv *, jobject, jfieldID);
+  jlong    (JNICALL *GetLongField)         (JNIEnv *, jobject, jfieldID);
+  jfloat   (JNICALL *GetFloatField)        (JNIEnv *, jobject, jfieldID);
+  jdouble  (JNICALL *GetDoubleField)       (JNIEnv *, jobject, jfieldID);
+
+  void (JNICALL *SetObjectField)          (JNIEnv *, jobject,
+                                           jfieldID, jobject);
+  void (JNICALL *SetBooleanField)         (JNIEnv *, jobject,
+                                           jfieldID, jboolean);
+  void (JNICALL *SetByteField)            (JNIEnv *, jobject,
+                                           jfieldID, jbyte);
+  void (JNICALL *SetCharField)            (JNIEnv *, jobject,
+                                           jfieldID, jchar);
+  void (JNICALL *SetShortField)           (JNIEnv *, jobject,
+                                           jfieldID, jshort);
+  void (JNICALL *SetIntField)             (JNIEnv *, jobject,
+                                           jfieldID, jint);
+  void (JNICALL *SetLongField)            (JNIEnv *, jobject,
+                                           jfieldID, jlong);
+  void (JNICALL *SetFloatField)           (JNIEnv *, jobject,
+                                           jfieldID, jfloat);
+  void (JNICALL *SetDoubleField)          (JNIEnv *, jobject,
+                                           jfieldID, jdouble);
+
+  jmethodID (JNICALL *GetStaticMethodID)   (JNIEnv *, jclass, const char *,
+                                           const char *);
+
+  jobject  (JNICALL *CallStaticObjectMethod)  (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jobject  (JNICALL *CallStaticObjectMethodV) (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jobject  (JNICALL *CallStaticObjectMethodA) (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  jboolean (JNICALL *CallStaticBooleanMethod) (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jboolean (JNICALL *CallStaticBooleanMethodV) (JNIEnv *, jclass, jmethodID,
+                                               va_list);
+  jboolean (JNICALL *CallStaticBooleanMethodA) (JNIEnv *, jclass, jmethodID,
+                                               const jvalue *);
+  jbyte           (JNICALL *CallStaticByteMethod)    (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jbyte    (JNICALL *CallStaticByteMethodV)   (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jbyte    (JNICALL *CallStaticByteMethodA)   (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  jchar    (JNICALL *CallStaticCharMethod)    (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jchar    (JNICALL *CallStaticCharMethodV)   (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jchar    (JNICALL *CallStaticCharMethodA)   (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  jshort   (JNICALL *CallStaticShortMethod)   (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jshort   (JNICALL *CallStaticShortMethodV)  (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jshort   (JNICALL *CallStaticShortMethodA)  (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  jint            (JNICALL *CallStaticIntMethod)     (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jint            (JNICALL *CallStaticIntMethodV)    (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jint            (JNICALL *CallStaticIntMethodA)    (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  jlong    (JNICALL *CallStaticLongMethod)    (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jlong    (JNICALL *CallStaticLongMethodV)   (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jlong    (JNICALL *CallStaticLongMethodA)   (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  jfloat   (JNICALL *CallStaticFloatMethod)   (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jfloat   (JNICALL *CallStaticFloatMethodV)  (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jfloat   (JNICALL *CallStaticFloatMethodA)  (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  jdouble  (JNICALL *CallStaticDoubleMethod)  (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  jdouble  (JNICALL *CallStaticDoubleMethodV) (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  jdouble  (JNICALL *CallStaticDoubleMethodA) (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+  void     (JNICALL *CallStaticVoidMethod)    (JNIEnv *, jclass, jmethodID,
+                                              ...);
+  void     (JNICALL *CallStaticVoidMethodV)   (JNIEnv *, jclass, jmethodID,
+                                              va_list);
+  void     (JNICALL *CallStaticVoidMethodA)   (JNIEnv *, jclass, jmethodID,
+                                              const jvalue *);
+
+  jfieldID (JNICALL *GetStaticFieldID)        (JNIEnv *, jclass, const char *,
+                                              const char *);
+
+  jobject  (JNICALL *GetStaticObjectField)    (JNIEnv *, jclass, jfieldID);
+  jboolean (JNICALL *GetStaticBooleanField)   (JNIEnv *, jclass, jfieldID);
+  jbyte           (JNICALL *GetStaticByteField)      (JNIEnv *, jclass, jfieldID);
+  jchar           (JNICALL *GetStaticCharField)      (JNIEnv *, jclass, jfieldID);
+  jshort   (JNICALL *GetStaticShortField)     (JNIEnv *, jclass, jfieldID);
+  jint    (JNICALL *GetStaticIntField)       (JNIEnv *, jclass, jfieldID);
+  jlong           (JNICALL *GetStaticLongField)      (JNIEnv *, jclass, jfieldID);
+  jfloat   (JNICALL *GetStaticFloatField)     (JNIEnv *, jclass, jfieldID);
+  jdouble  (JNICALL *GetStaticDoubleField)    (JNIEnv *, jclass, jfieldID);
+
+  void         (JNICALL *SetStaticObjectField)    (JNIEnv *, jclass,
+                                           jfieldID, jobject);
+  void         (JNICALL *SetStaticBooleanField)   (JNIEnv *, jclass,
+                                           jfieldID, jboolean);
+  void         (JNICALL *SetStaticByteField)      (JNIEnv *, jclass,
+                                           jfieldID, jbyte);
+  void         (JNICALL *SetStaticCharField)      (JNIEnv *, jclass,
+                                           jfieldID, jchar);
+  void         (JNICALL *SetStaticShortField)     (JNIEnv *, jclass,
+                                           jfieldID, jshort);
+  void         (JNICALL *SetStaticIntField)       (JNIEnv *, jclass,
+                                           jfieldID, jint);
+  void         (JNICALL *SetStaticLongField)      (JNIEnv *, jclass,
+                                           jfieldID, jlong);
+  void         (JNICALL *SetStaticFloatField)     (JNIEnv *, jclass,
+                                           jfieldID, jfloat);
+  void         (JNICALL *SetStaticDoubleField)    (JNIEnv *, jclass,
+                                           jfieldID, jdouble);
+
+  jstring  (JNICALL *NewString)            (JNIEnv *, const jchar *, jsize);
+  jsize    (JNICALL *GetStringLength)      (JNIEnv *, jstring);
+  const jchar * (JNICALL *GetStringChars)  (JNIEnv *, jstring, jboolean *);
+  void     (JNICALL *ReleaseStringChars)   (JNIEnv *, jstring, const jchar *);
+  jstring  (JNICALL *NewStringUTF)         (JNIEnv *, const char *);
+  jsize    (JNICALL *GetStringUTFLength)   (JNIEnv *, jstring);
+  const char * (JNICALL *GetStringUTFChars) (JNIEnv *, jstring, jboolean *);
+  void     (JNICALL *ReleaseStringUTFChars) (JNIEnv *, jstring, const char *);
+  jsize    (JNICALL *GetArrayLength)       (JNIEnv *, jarray);
+  jobjectArray (JNICALL *NewObjectArray)    (JNIEnv *, jsize, jclass, jobject);
+  jobject  (JNICALL *GetObjectArrayElement) (JNIEnv *, jobjectArray, jsize);
+  void     (JNICALL *SetObjectArrayElement) (JNIEnv *, jobjectArray, jsize,
+                                            jobject);
+
+  jbooleanArray (JNICALL *NewBooleanArray)        (JNIEnv *, jsize);
+  jbyteArray    (JNICALL *NewByteArray)                   (JNIEnv *, jsize);
+  jcharArray    (JNICALL *NewCharArray)                   (JNIEnv *, jsize);
+  jshortArray   (JNICALL *NewShortArray)          (JNIEnv *, jsize);
+  jintArray     (JNICALL *NewIntArray)            (JNIEnv *, jsize);
+  jlongArray    (JNICALL *NewLongArray)                   (JNIEnv *, jsize);
+  jfloatArray   (JNICALL *NewFloatArray)          (JNIEnv *, jsize);
+  jdoubleArray  (JNICALL *NewDoubleArray)         (JNIEnv *, jsize);
+
+  jboolean *   (JNICALL *GetBooleanArrayElements) (JNIEnv *, jbooleanArray,
+                                                   jboolean *);
+  jbyte *      (JNICALL *GetByteArrayElements)    (JNIEnv *, jbyteArray,
+                                                   jboolean *);
+  jchar *      (JNICALL *GetCharArrayElements)    (JNIEnv *, jcharArray,
+                                                   jboolean *);
+  jshort *     (JNICALL *GetShortArrayElements)   (JNIEnv *, jshortArray,
+                                                   jboolean *);
+  jint *       (JNICALL *GetIntArrayElements)     (JNIEnv *, jintArray,
+                                                   jboolean *);
+  jlong *      (JNICALL *GetLongArrayElements)    (JNIEnv *, jlongArray,
+                                                   jboolean *);
+  jfloat *     (JNICALL *GetFloatArrayElements)   (JNIEnv *, jfloatArray,
+                                                   jboolean *);
+  jdouble *    (JNICALL *GetDoubleArrayElements)  (JNIEnv *, jdoubleArray,
+                                                   jboolean *);
+
+  void         (JNICALL *ReleaseBooleanArrayElements) (JNIEnv *, jbooleanArray,
+                                                       jboolean *, jint);
+  void         (JNICALL *ReleaseByteArrayElements)    (JNIEnv *, jbyteArray,
+                                                       jbyte *, jint);
+  void         (JNICALL *ReleaseCharArrayElements)    (JNIEnv *, jcharArray,
+                                                       jchar *, jint);
+  void         (JNICALL *ReleaseShortArrayElements)   (JNIEnv *, jshortArray,
+                                                       jshort *, jint);
+  void         (JNICALL *ReleaseIntArrayElements)     (JNIEnv *, jintArray,
+                                                       jint *, jint);
+  void         (JNICALL *ReleaseLongArrayElements)    (JNIEnv *, jlongArray,
+                                                       jlong *, jint);
+  void         (JNICALL *ReleaseFloatArrayElements)   (JNIEnv *, jfloatArray,
+                                                       jfloat *, jint);
+  void         (JNICALL *ReleaseDoubleArrayElements)  (JNIEnv *, jdoubleArray,
+                                                       jdouble *, jint);
+
+  void                 (JNICALL *GetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,
+                                                   jsize, jsize, jboolean *);
+  void                 (JNICALL *GetByteArrayRegion)      (JNIEnv *, jbyteArray,
+                                                   jsize, jsize, jbyte *);
+  void                 (JNICALL *GetCharArrayRegion)      (JNIEnv *, jcharArray,
+                                                   jsize, jsize, jchar *);
+  void                 (JNICALL *GetShortArrayRegion)     (JNIEnv *, jshortArray,
+                                                   jsize, jsize, jshort *);
+  void                 (JNICALL *GetIntArrayRegion)       (JNIEnv *, jintArray,
+                                                   jsize, jsize, jint *);
+  void                 (JNICALL *GetLongArrayRegion)      (JNIEnv *, jlongArray,
+                                                   jsize, jsize, jlong *);
+  void                 (JNICALL *GetFloatArrayRegion)     (JNIEnv *, jfloatArray,
+                                                   jsize, jsize, jfloat *);
+  void                 (JNICALL *GetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,
+                                                   jsize, jsize, jdouble *);
+
+  void                 (JNICALL *SetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,
+                                                   jsize, jsize,
+                                                    const jboolean *);
+  void                 (JNICALL *SetByteArrayRegion)      (JNIEnv *, jbyteArray,
+                                                   jsize, jsize,
+                                                    const jbyte *);
+  void                 (JNICALL *SetCharArrayRegion)      (JNIEnv *, jcharArray,
+                                                   jsize, jsize,
+                                                    const jchar *);
+  void                 (JNICALL *SetShortArrayRegion)     (JNIEnv *, jshortArray,
+                                                   jsize, jsize,
+                                                    const jshort *);
+  void                 (JNICALL *SetIntArrayRegion)       (JNIEnv *, jintArray,
+                                                   jsize, jsize,
+                                                    const jint *);
+  void                 (JNICALL *SetLongArrayRegion)      (JNIEnv *, jlongArray,
+                                                   jsize, jsize,
+                                                    const jlong *);
+  void                 (JNICALL *SetFloatArrayRegion)     (JNIEnv *, jfloatArray,
+                                                   jsize, jsize,
+                                                    const jfloat *);
+  void                 (JNICALL *SetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,
+                                                   jsize, jsize,
+                                                    const jdouble *);
+
+  jint     (JNICALL *RegisterNatives)              (JNIEnv *, jclass,
+                                                   const JNINativeMethod *, 
+                                                   jint);
+  jint     (JNICALL *UnregisterNatives)            (JNIEnv *, jclass);
+  jint     (JNICALL *MonitorEnter)                 (JNIEnv *, jobject);
+  jint     (JNICALL *MonitorExit)                  (JNIEnv *, jobject);
+  jint     (JNICALL *GetJavaVM)                    (JNIEnv *, JavaVM **);
+
+  /* ---- JNI 1.2 functions ---- */
+
+  void    (JNICALL *GetStringRegion)              (JNIEnv *, jstring, jsize,
+                                                   jsize, jchar *);
+  void     (JNICALL *GetStringUTFRegion)          (JNIEnv *, jstring, jsize,
+                                                   jsize, char *);
+
+  void * (JNICALL *GetPrimitiveArrayCritical)      (JNIEnv *, jarray, 
+                                                    jboolean *);
+  void   (JNICALL *ReleasePrimitiveArrayCritical)  (JNIEnv *, jarray, void *, 
+                                                    jint);
+
+  const jchar * (JNICALL *GetStringCritical)       (JNIEnv *, jstring, 
+                                                    jboolean *);
+  void          (JNICALL *ReleaseStringCritical)   (JNIEnv *, jstring, 
+                                                    const jchar *);
+
+  jweak  (JNICALL *NewWeakGlobalRef)               (JNIEnv *, jobject);
+  void   (JNICALL *DeleteWeakGlobalRef)            (JNIEnv *, jweak);
+
+  jboolean     (JNICALL *ExceptionCheck)          (JNIEnv *);
+
+  /* ---- JNI 1.4 functions ---- */
+
+  jobject (JNICALL *NewDirectByteBuffer)           (JNIEnv *, void *, jlong);
+  void *  (JNICALL *GetDirectBufferAddress)        (JNIEnv *, jobject);
+  jlong   (JNICALL *GetDirectBufferCapacity)       (JNIEnv *, jobject);
+
+  /* ---- JNI 1.6 functions ---- */
+
+  jobjectRefType (JNICALL *GetObjectRefType)       (JNIEnv *, jobject);
+};
+
+#ifdef __cplusplus
+
+class _Jv_JNIEnv
+{
+public:
+  /* The method table.  */
+  struct JNINativeInterface_ *functions;
+
+#ifdef _CLASSPATH_JNIENV_CONTENTS
+  _CLASSPATH_JNIENV_CONTENTS
+#endif
+
+  jint GetVersion ()
+  { return functions->GetVersion (this); }
+
+  jclass DefineClass (const char *name, jobject obj0, const jbyte * val1,
+                     jsize val2)
+  { return functions->DefineClass (this, name, obj0, val1, val2); }
+
+  jclass FindClass (const char * val0)
+  { return functions->FindClass (this, val0); }
+
+  jmethodID FromReflectedMethod (jobject obj0)
+  { return functions->FromReflectedMethod (this, obj0); }
+
+  jfieldID FromReflectedField (jobject obj0)
+  { return functions->FromReflectedField (this, obj0); }
+
+  jobject ToReflectedMethod (jclass cl0, jmethodID meth1, jboolean val2)
+  { return functions->ToReflectedMethod (this, cl0, meth1, val2); }
+
+  jclass GetSuperclass (jclass cl0)
+  { return functions->GetSuperclass (this, cl0); }
+
+  jboolean IsAssignableFrom (jclass cl0, jclass cl1)
+  { return functions->IsAssignableFrom (this, cl0, cl1); }
+
+  jobject ToReflectedField (jclass cl0, jfieldID fld1, jboolean val2)
+  { return functions->ToReflectedField (this, cl0, fld1, val2); }
+
+  jint Throw (jthrowable val0)
+  { return functions->Throw (this, val0); }
+
+  jint ThrowNew (jclass cl0, const char * val1)
+  { return functions->ThrowNew (this, cl0, val1); }
+
+  jthrowable ExceptionOccurred ()
+  { return functions->ExceptionOccurred (this); }
+
+  void ExceptionDescribe ()
+  { functions->ExceptionDescribe (this); }
+
+  void ExceptionClear ()
+  { functions->ExceptionClear (this); }
+
+  void FatalError (const char * val0)
+  { functions->FatalError (this, val0); }
+
+  jint PushLocalFrame (jint val0)
+  { return functions->PushLocalFrame (this, val0); }
+
+  jobject PopLocalFrame (jobject obj0)
+  { return functions->PopLocalFrame (this, obj0); }
+
+  jobject NewGlobalRef (jobject obj0)
+  { return functions->NewGlobalRef (this, obj0); }
+
+  void DeleteGlobalRef (jobject obj0)
+  { functions->DeleteGlobalRef (this, obj0); }
+
+  void DeleteLocalRef (jobject obj0)
+  { functions->DeleteLocalRef (this, obj0); }
+
+  jboolean IsSameObject (jobject obj0, jobject obj1)
+  { return functions->IsSameObject (this, obj0, obj1); }
+
+  jobject NewLocalRef (jobject obj0)
+  { return functions->NewLocalRef (this, obj0); }
+
+  jint EnsureLocalCapacity (jint val0)
+  { return functions->EnsureLocalCapacity (this, val0); }
+
+  jobject AllocObject (jclass cl0)
+  { return functions->AllocObject (this, cl0); }
+
+  jobject NewObject (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jobject result = functions->NewObjectV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jobject NewObjectV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->NewObjectV (this, cl0, meth1, val2); }
+
+  jobject NewObjectA (jclass cl0, jmethodID meth1, jvalue * val2)
+  { return functions->NewObjectA (this, cl0, meth1, val2); }
+
+  jclass GetObjectClass (jobject obj0)
+  { return functions->GetObjectClass (this, obj0); }
+
+  jboolean IsInstanceOf (jobject obj0, jclass cl1)
+  { return functions->IsInstanceOf (this, obj0, cl1); }
+
+  jmethodID GetMethodID (jclass cl0, const char * val1, const char * val2)
+  { return functions->GetMethodID (this, cl0, val1, val2); }
+
+  jobject CallObjectMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jobject result = functions->CallObjectMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jobject CallObjectMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallObjectMethodV (this, obj0, meth1, val2); }
+
+  jobject CallObjectMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
+  { return functions->CallObjectMethodA (this, obj0, meth1, val2); }
+
+  jboolean CallBooleanMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jboolean result = functions->CallBooleanMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jboolean CallBooleanMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallBooleanMethodV (this, obj0, meth1, val2); }
+
+  jboolean CallBooleanMethodA (jobject obj0, jmethodID meth1,
+                               const jvalue * val2)
+  { return functions->CallBooleanMethodA (this, obj0, meth1, val2); }
+
+  jbyte CallByteMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jbyte result = functions->CallByteMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jbyte CallByteMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallByteMethodV (this, obj0, meth1, val2); }
+
+  jbyte CallByteMethodA (jobject obj0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallByteMethodA (this, obj0, meth1, val2); }
+
+  jchar CallCharMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jchar result = functions->CallCharMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jchar CallCharMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallCharMethodV (this, obj0, meth1, val2); }
+
+  jchar CallCharMethodA (jobject obj0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallCharMethodA (this, obj0, meth1, val2); }
+
+  jshort CallShortMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jshort result = functions->CallShortMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jshort CallShortMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallShortMethodV (this, obj0, meth1, val2); }
+
+  jshort CallShortMethodA (jobject obj0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallShortMethodA (this, obj0, meth1, val2); }
+
+  jint CallIntMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jint result = functions->CallIntMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jint CallIntMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallIntMethodV (this, obj0, meth1, val2); }
+
+  jint CallIntMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
+  { return functions->CallIntMethodA (this, obj0, meth1, val2); }
+
+  jlong CallLongMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jlong result = functions->CallLongMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jlong CallLongMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallLongMethodV (this, obj0, meth1, val2); }
+
+  jlong CallLongMethodA (jobject obj0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallLongMethodA (this, obj0, meth1, val2); }
+
+  jfloat CallFloatMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jfloat result = functions->CallFloatMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jfloat CallFloatMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallFloatMethodV (this, obj0, meth1, val2); }
+
+  jfloat CallFloatMethodA (jobject obj0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallFloatMethodA (this, obj0, meth1, val2); }
+
+  jdouble CallDoubleMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jdouble result = functions->CallDoubleMethodV (this, obj0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jdouble CallDoubleMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { return functions->CallDoubleMethodV (this, obj0, meth1, val2); }
+
+  jdouble CallDoubleMethodA (jobject obj0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallDoubleMethodA (this, obj0, meth1, val2); }
+
+  void CallVoidMethod (jobject obj0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    functions->CallVoidMethodV (this, obj0, meth1, args);
+    va_end (args);
+  }
+
+  void CallVoidMethodV (jobject obj0, jmethodID meth1, va_list val2)
+  { functions->CallVoidMethodV (this, obj0, meth1, val2); }
+
+  void CallVoidMethodA (jobject obj0, jmethodID meth1, const jvalue * val2)
+  { functions->CallVoidMethodA (this, obj0, meth1, val2); }
+
+  jobject CallNonvirtualObjectMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jobject result = functions->CallNonvirtualObjectMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jobject CallNonvirtualObjectMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualObjectMethodV (this, obj0, cl1, meth2, val3); }
+
+  jobject CallNonvirtualObjectMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualObjectMethodA (this, obj0, cl1, meth2, val3); }
+
+  jboolean CallNonvirtualBooleanMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jboolean result = functions->CallNonvirtualBooleanMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jboolean CallNonvirtualBooleanMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualBooleanMethodV (this, obj0, cl1, meth2, val3); }
+
+  jboolean CallNonvirtualBooleanMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualBooleanMethodA (this, obj0, cl1, meth2, val3); }
+
+  jbyte CallNonvirtualByteMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jbyte result = functions->CallNonvirtualByteMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jbyte CallNonvirtualByteMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualByteMethodV (this, obj0, cl1, meth2, val3); }
+
+  jbyte CallNonvirtualByteMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualByteMethodA (this, obj0, cl1, meth2, val3); }
+
+  jchar CallNonvirtualCharMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jchar result = functions->CallNonvirtualCharMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jchar CallNonvirtualCharMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualCharMethodV (this, obj0, cl1, meth2, val3); }
+
+  jchar CallNonvirtualCharMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualCharMethodA (this, obj0, cl1, meth2, val3); }
+
+  jshort CallNonvirtualShortMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jshort result = functions->CallNonvirtualShortMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jshort CallNonvirtualShortMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualShortMethodV (this, obj0, cl1, meth2, val3); }
+
+  jshort CallNonvirtualShortMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualShortMethodA (this, obj0, cl1, meth2, val3); }
+
+  jint CallNonvirtualIntMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jint result = functions->CallNonvirtualIntMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jint CallNonvirtualIntMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualIntMethodV (this, obj0, cl1, meth2, val3); }
+
+  jint CallNonvirtualIntMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualIntMethodA (this, obj0, cl1, meth2, val3); }
+
+  jlong CallNonvirtualLongMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jlong result = functions->CallNonvirtualLongMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jlong CallNonvirtualLongMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualLongMethodV (this, obj0, cl1, meth2, val3); }
+
+  jlong CallNonvirtualLongMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualLongMethodA (this, obj0, cl1, meth2, val3); }
+
+  jfloat CallNonvirtualFloatMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jfloat result = functions->CallNonvirtualFloatMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jfloat CallNonvirtualFloatMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualFloatMethodV (this, obj0, cl1, meth2, val3); }
+
+  jfloat CallNonvirtualFloatMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualFloatMethodA (this, obj0, cl1, meth2, val3); }
+
+  jdouble CallNonvirtualDoubleMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    jdouble result = functions->CallNonvirtualDoubleMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+    return result;
+  }
+
+  jdouble CallNonvirtualDoubleMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { return functions->CallNonvirtualDoubleMethodV (this, obj0, cl1, meth2, val3); }
+
+  jdouble CallNonvirtualDoubleMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { return functions->CallNonvirtualDoubleMethodA (this, obj0, cl1, meth2, val3); }
+
+  void CallNonvirtualVoidMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
+  {
+    va_list args;
+    va_start (args, meth2);
+    functions->CallNonvirtualVoidMethodV (this, obj0, cl1, meth2, args);
+    va_end (args);
+  }
+
+  void CallNonvirtualVoidMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
+  { functions->CallNonvirtualVoidMethodV (this, obj0, cl1, meth2, val3); }
+
+  void CallNonvirtualVoidMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3)
+  { functions->CallNonvirtualVoidMethodA (this, obj0, cl1, meth2, val3); }
+
+  jfieldID GetFieldID (jclass cl0, const char * val1, const char * val2)
+  { return functions->GetFieldID (this, cl0, val1, val2); }
+
+  jobject GetObjectField (jobject obj0, jfieldID fld1)
+  { return functions->GetObjectField (this, obj0, fld1); }
+
+  jboolean GetBooleanField (jobject obj0, jfieldID fld1)
+  { return functions->GetBooleanField (this, obj0, fld1); }
+
+  jbyte GetByteField (jobject obj0, jfieldID fld1)
+  { return functions->GetByteField (this, obj0, fld1); }
+
+  jchar GetCharField (jobject obj0, jfieldID fld1)
+  { return functions->GetCharField (this, obj0, fld1); }
+
+  jshort GetShortField (jobject obj0, jfieldID fld1)
+  { return functions->GetShortField (this, obj0, fld1); }
+
+  jint GetIntField (jobject obj0, jfieldID fld1)
+  { return functions->GetIntField (this, obj0, fld1); }
+
+  jlong GetLongField (jobject obj0, jfieldID fld1)
+  { return functions->GetLongField (this, obj0, fld1); }
+
+  jfloat GetFloatField (jobject obj0, jfieldID fld1)
+  { return functions->GetFloatField (this, obj0, fld1); }
+
+  jdouble GetDoubleField (jobject obj0, jfieldID fld1)
+  { return functions->GetDoubleField (this, obj0, fld1); }
+
+  void SetObjectField (jobject obj0, jfieldID fld1, jobject obj2)
+  { functions->SetObjectField (this, obj0, fld1, obj2); }
+
+  void SetBooleanField (jobject obj0, jfieldID fld1, jboolean val2)
+  { functions->SetBooleanField (this, obj0, fld1, val2); }
+
+  void SetByteField (jobject obj0, jfieldID fld1, jbyte val2)
+  { functions->SetByteField (this, obj0, fld1, val2); }
+
+  void SetCharField (jobject obj0, jfieldID fld1, jchar val2)
+  { functions->SetCharField (this, obj0, fld1, val2); }
+
+  void SetShortField (jobject obj0, jfieldID fld1, jshort val2)
+  { functions->SetShortField (this, obj0, fld1, val2); }
+
+  void SetIntField (jobject obj0, jfieldID fld1, jint val2)
+  { functions->SetIntField (this, obj0, fld1, val2); }
+
+  void SetLongField (jobject obj0, jfieldID fld1, jlong val2)
+  { functions->SetLongField (this, obj0, fld1, val2); }
+
+  void SetFloatField (jobject obj0, jfieldID fld1, jfloat val2)
+  { functions->SetFloatField (this, obj0, fld1, val2); }
+
+  void SetDoubleField (jobject obj0, jfieldID fld1, jdouble val2)
+  { functions->SetDoubleField (this, obj0, fld1, val2); }
+
+  jmethodID GetStaticMethodID (jclass cl0, const char * val1, const char * val2)
+  { return functions->GetStaticMethodID (this, cl0, val1, val2); }
+
+  jobject CallStaticObjectMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jobject result = functions->CallStaticObjectMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jobject CallStaticObjectMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticObjectMethodV (this, cl0, meth1, val2); }
+
+  jobject CallStaticObjectMethodA (jclass cl0, jmethodID meth1,
+                                   const jvalue * val2)
+  { return functions->CallStaticObjectMethodA (this, cl0, meth1, val2); }
+
+  jboolean CallStaticBooleanMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jboolean result = functions->CallStaticBooleanMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jboolean CallStaticBooleanMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticBooleanMethodV (this, cl0, meth1, val2); }
+
+  jboolean CallStaticBooleanMethodA (jclass cl0, jmethodID meth1,
+                                     const jvalue * val2)
+  { return functions->CallStaticBooleanMethodA (this, cl0, meth1, val2); }
+
+  jbyte CallStaticByteMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jbyte result = functions->CallStaticByteMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jbyte CallStaticByteMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticByteMethodV (this, cl0, meth1, val2); }
+
+  jbyte CallStaticByteMethodA (jclass cl0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallStaticByteMethodA (this, cl0, meth1, val2); }
+
+  jchar CallStaticCharMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jchar result = functions->CallStaticCharMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jchar CallStaticCharMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticCharMethodV (this, cl0, meth1, val2); }
+
+  jchar CallStaticCharMethodA (jclass cl0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallStaticCharMethodA (this, cl0, meth1, val2); }
+
+  jshort CallStaticShortMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jshort result = functions->CallStaticShortMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jshort CallStaticShortMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticShortMethodV (this, cl0, meth1, val2); }
+
+  jshort CallStaticShortMethodA (jclass cl0, jmethodID meth1,
+                                 const jvalue * val2)
+  { return functions->CallStaticShortMethodA (this, cl0, meth1, val2); }
+
+  jint CallStaticIntMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jint result = functions->CallStaticIntMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jint CallStaticIntMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticIntMethodV (this, cl0, meth1, val2); }
+
+  jint CallStaticIntMethodA (jclass cl0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallStaticIntMethodA (this, cl0, meth1, val2); }
+
+  jlong CallStaticLongMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jlong result = functions->CallStaticLongMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jlong CallStaticLongMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticLongMethodV (this, cl0, meth1, val2); }
+
+  jlong CallStaticLongMethodA (jclass cl0, jmethodID meth1, const jvalue * val2)
+  { return functions->CallStaticLongMethodA (this, cl0, meth1, val2); }
+
+  jfloat CallStaticFloatMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jfloat result = functions->CallStaticFloatMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jfloat CallStaticFloatMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticFloatMethodV (this, cl0, meth1, val2); }
+
+  jfloat CallStaticFloatMethodA (jclass cl0, jmethodID meth1,
+                                 const jvalue * val2)
+  { return functions->CallStaticFloatMethodA (this, cl0, meth1, val2); }
+
+  jdouble CallStaticDoubleMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    jdouble result = functions->CallStaticDoubleMethodV (this, cl0, meth1, args);
+    va_end (args);
+    return result;
+  }
+
+  jdouble CallStaticDoubleMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { return functions->CallStaticDoubleMethodV (this, cl0, meth1, val2); }
+
+  jdouble CallStaticDoubleMethodA (jclass cl0, jmethodID meth1,
+                                   const jvalue * val2)
+  { return functions->CallStaticDoubleMethodA (this, cl0, meth1, val2); }
+
+  void CallStaticVoidMethod (jclass cl0, jmethodID meth1, ...)
+  {
+    va_list args;
+    va_start (args, meth1);
+    functions->CallStaticVoidMethodV (this, cl0, meth1, args);
+    va_end (args);
+  }
+
+  void CallStaticVoidMethodV (jclass cl0, jmethodID meth1, va_list val2)
+  { functions->CallStaticVoidMethodV (this, cl0, meth1, val2); }
+
+  void CallStaticVoidMethodA (jclass cl0, jmethodID meth1, const jvalue * val2)
+  { functions->CallStaticVoidMethodA (this, cl0, meth1, val2); }
+
+  jfieldID GetStaticFieldID (jclass cl0, const char * val1, const char * val2)
+  { return functions->GetStaticFieldID (this, cl0, val1, val2); }
+
+  jobject GetStaticObjectField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticObjectField (this, cl0, fld1); }
+
+  jboolean GetStaticBooleanField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticBooleanField (this, cl0, fld1); }
+
+  jbyte GetStaticByteField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticByteField (this, cl0, fld1); }
+
+  jchar GetStaticCharField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticCharField (this, cl0, fld1); }
+
+  jshort GetStaticShortField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticShortField (this, cl0, fld1); }
+
+  jint GetStaticIntField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticIntField (this, cl0, fld1); }
+
+  jlong GetStaticLongField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticLongField (this, cl0, fld1); }
+
+  jfloat GetStaticFloatField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticFloatField (this, cl0, fld1); }
+
+  jdouble GetStaticDoubleField (jclass cl0, jfieldID fld1)
+  { return functions->GetStaticDoubleField (this, cl0, fld1); }
+
+  void SetStaticObjectField (jclass cl0, jfieldID fld1, jobject obj2)
+  { functions->SetStaticObjectField (this, cl0, fld1, obj2); }
+
+  void SetStaticBooleanField (jclass cl0, jfieldID fld1, jboolean val2)
+  { functions->SetStaticBooleanField (this, cl0, fld1, val2); }
+
+  void SetStaticByteField (jclass cl0, jfieldID fld1, jbyte val2)
+  { functions->SetStaticByteField (this, cl0, fld1, val2); }
+
+  void SetStaticCharField (jclass cl0, jfieldID fld1, jchar val2)
+  { functions->SetStaticCharField (this, cl0, fld1, val2); }
+
+  void SetStaticShortField (jclass cl0, jfieldID fld1, jshort val2)
+  { functions->SetStaticShortField (this, cl0, fld1, val2); }
+
+  void SetStaticIntField (jclass cl0, jfieldID fld1, jint val2)
+  { functions->SetStaticIntField (this, cl0, fld1, val2); }
+
+  void SetStaticLongField (jclass cl0, jfieldID fld1, jlong val2)
+  { functions->SetStaticLongField (this, cl0, fld1, val2); }
+
+  void SetStaticFloatField (jclass cl0, jfieldID fld1, jfloat val2)
+  { functions->SetStaticFloatField (this, cl0, fld1, val2); }
+
+  void SetStaticDoubleField (jclass cl0, jfieldID fld1, jdouble val2)
+  { functions->SetStaticDoubleField (this, cl0, fld1, val2); }
+
+  jstring NewString (const jchar * val0, jsize val1)
+  { return functions->NewString (this, val0, val1); }
+
+  jint GetStringLength (jstring val0)
+  { return functions->GetStringLength (this, val0); }
+
+  const jchar * GetStringChars (jstring val0, jboolean * val1)
+  { return functions->GetStringChars (this, val0, val1); }
+
+  void ReleaseStringChars (jstring val0, const jchar * val1)
+  { functions->ReleaseStringChars (this, val0, val1); }
+
+  jstring NewStringUTF (const char * val0)
+  { return functions->NewStringUTF (this, val0); }
+
+  jsize GetStringUTFLength (jstring val0)
+  { return functions->GetStringUTFLength (this, val0); }
+
+  const char * GetStringUTFChars (jstring val0, jboolean * val1)
+  { return functions->GetStringUTFChars (this, val0, val1); }
+
+  void ReleaseStringUTFChars (jstring val0, const char * val1)
+  { functions->ReleaseStringUTFChars (this, val0, val1); }
+
+  jsize GetArrayLength (jarray val0)
+  { return functions->GetArrayLength (this, val0); }
+
+  jobjectArray NewObjectArray (jsize val0, jclass cl1, jobject obj2)
+  { return functions->NewObjectArray (this, val0, cl1, obj2); }
+
+  jobject GetObjectArrayElement (jobjectArray val0, jsize val1)
+  { return functions->GetObjectArrayElement (this, val0, val1); }
+
+  void SetObjectArrayElement (jobjectArray val0, jsize val1, jobject obj2)
+  { functions->SetObjectArrayElement (this, val0, val1, obj2); }
+
+  jbooleanArray NewBooleanArray (jsize val0)
+  { return functions->NewBooleanArray (this, val0); }
+
+  jbyteArray NewByteArray (jsize val0)
+  { return functions->NewByteArray (this, val0); }
+
+  jcharArray NewCharArray (jsize val0)
+  { return functions->NewCharArray (this, val0); }
+
+  jshortArray NewShortArray (jsize val0)
+  { return functions->NewShortArray (this, val0); }
+
+  jintArray NewIntArray (jsize val0)
+  { return functions->NewIntArray (this, val0); }
+
+  jlongArray NewLongArray (jsize val0)
+  { return functions->NewLongArray (this, val0); }
+
+  jfloatArray NewFloatArray (jsize val0)
+  { return functions->NewFloatArray (this, val0); }
+
+  jdoubleArray NewDoubleArray (jsize val0)
+  { return functions->NewDoubleArray (this, val0); }
+
+  jboolean * GetBooleanArrayElements (jbooleanArray val0, jboolean * val1)
+  { return functions->GetBooleanArrayElements (this, val0, val1); }
+
+  jbyte * GetByteArrayElements (jbyteArray val0, jboolean * val1)
+  { return functions->GetByteArrayElements (this, val0, val1); }
+
+  jchar * GetCharArrayElements (jcharArray val0, jboolean * val1)
+  { return functions->GetCharArrayElements (this, val0, val1); }
+
+  jshort * GetShortArrayElements (jshortArray val0, jboolean * val1)
+  { return functions->GetShortArrayElements (this, val0, val1); }
+
+  jint * GetIntArrayElements (jintArray val0, jboolean * val1)
+  { return functions->GetIntArrayElements (this, val0, val1); }
+
+  jlong * GetLongArrayElements (jlongArray val0, jboolean * val1)
+  { return functions->GetLongArrayElements (this, val0, val1); }
+
+  jfloat * GetFloatArrayElements (jfloatArray val0, jboolean * val1)
+  { return functions->GetFloatArrayElements (this, val0, val1); }
+
+  jdouble * GetDoubleArrayElements (jdoubleArray val0, jboolean * val1)
+  { return functions->GetDoubleArrayElements (this, val0, val1); }
+
+  void ReleaseBooleanArrayElements (jbooleanArray val0, jboolean * val1, jint val2)
+  { functions->ReleaseBooleanArrayElements (this, val0, val1, val2); }
+
+  void ReleaseByteArrayElements (jbyteArray val0, jbyte * val1, jint val2)
+  { functions->ReleaseByteArrayElements (this, val0, val1, val2); }
+
+  void ReleaseCharArrayElements (jcharArray val0, jchar * val1, jint val2)
+  { functions->ReleaseCharArrayElements (this, val0, val1, val2); }
+
+  void ReleaseShortArrayElements (jshortArray val0, jshort * val1, jint val2)
+  { functions->ReleaseShortArrayElements (this, val0, val1, val2); }
+
+  void ReleaseIntArrayElements (jintArray val0, jint * val1, jint val2)
+  { functions->ReleaseIntArrayElements (this, val0, val1, val2); }
+
+  void ReleaseLongArrayElements (jlongArray val0, jlong * val1, jint val2)
+  { functions->ReleaseLongArrayElements (this, val0, val1, val2); }
+
+  void ReleaseFloatArrayElements (jfloatArray val0, jfloat * val1, jint val2)
+  { functions->ReleaseFloatArrayElements (this, val0, val1, val2); }
+
+  void ReleaseDoubleArrayElements (jdoubleArray val0, jdouble * val1, jint val2)
+  { functions->ReleaseDoubleArrayElements (this, val0, val1, val2); }
+
+  void GetBooleanArrayRegion (jbooleanArray val0, jsize val1, jsize val2, jboolean * val3)
+  { functions->GetBooleanArrayRegion (this, val0, val1, val2, val3); }
+
+  void GetByteArrayRegion (jbyteArray val0, jsize val1, jsize val2, jbyte * val3)
+  { functions->GetByteArrayRegion (this, val0, val1, val2, val3); }
+
+  void GetCharArrayRegion (jcharArray val0, jsize val1, jsize val2, jchar * val3)
+  { functions->GetCharArrayRegion (this, val0, val1, val2, val3); }
+
+  void GetShortArrayRegion (jshortArray val0, jsize val1, jsize val2, jshort * val3)
+  { functions->GetShortArrayRegion (this, val0, val1, val2, val3); }
+
+  void GetIntArrayRegion (jintArray val0, jsize val1, jsize val2, jint * val3)
+  { functions->GetIntArrayRegion (this, val0, val1, val2, val3); }
+
+  void GetLongArrayRegion (jlongArray val0, jsize val1, jsize val2, jlong * val3)
+  { functions->GetLongArrayRegion (this, val0, val1, val2, val3); }
+
+  void GetFloatArrayRegion (jfloatArray val0, jsize val1, jsize val2, jfloat * val3)
+  { functions->GetFloatArrayRegion (this, val0, val1, val2, val3); }
+
+  void GetDoubleArrayRegion (jdoubleArray val0, jsize val1, jsize val2, jdouble * val3)
+  { functions->GetDoubleArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetBooleanArrayRegion (jbooleanArray val0, jsize val1, jsize val2, jboolean * val3)
+  { functions->SetBooleanArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetByteArrayRegion (jbyteArray val0, jsize val1, jsize val2, jbyte * val3)
+  { functions->SetByteArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetCharArrayRegion (jcharArray val0, jsize val1, jsize val2, jchar * val3)
+  { functions->SetCharArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetShortArrayRegion (jshortArray val0, jsize val1, jsize val2, jshort * val3)
+  { functions->SetShortArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetIntArrayRegion (jintArray val0, jsize val1, jsize val2, jint * val3)
+  { functions->SetIntArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetLongArrayRegion (jlongArray val0, jsize val1, jsize val2, jlong * val3)
+  { functions->SetLongArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetFloatArrayRegion (jfloatArray val0, jsize val1, jsize val2, jfloat * val3)
+  { functions->SetFloatArrayRegion (this, val0, val1, val2, val3); }
+
+  void SetDoubleArrayRegion (jdoubleArray val0, jsize val1, jsize val2, jdouble * val3)
+  { functions->SetDoubleArrayRegion (this, val0, val1, val2, val3); }
+
+  jint RegisterNatives (jclass cl0, const JNINativeMethod * val1, jint val2)
+  { return functions->RegisterNatives (this, cl0, val1, val2); }
+
+  jint UnregisterNatives (jclass cl0)
+  { return functions->UnregisterNatives (this, cl0); }
+
+  jint MonitorEnter (jobject obj0)
+  { return functions->MonitorEnter (this, obj0); }
+
+  jint MonitorExit (jobject obj0)
+  { return functions->MonitorExit (this, obj0); }
+
+  jint GetJavaVM (JavaVM ** val0)
+  { return functions->GetJavaVM (this, val0); }
+
+  /* ---- JNI 1.2 functions ---- */
+
+  void GetStringRegion (jstring val0, jsize val1, jsize val2, jchar * val3)
+  { functions->GetStringRegion (this, val0, val1, val2, val3); }
+
+  void GetStringUTFRegion (jstring val0, jsize val1, jsize val2, char * val3)
+  { functions->GetStringUTFRegion (this, val0, val1, val2, val3); }
+
+  void * GetPrimitiveArrayCritical (jarray val0, jboolean * val1)
+  { return functions->GetPrimitiveArrayCritical (this, val0, val1); }
+
+  void ReleasePrimitiveArrayCritical (jarray val0, void * val1, jint val2)
+  { functions->ReleasePrimitiveArrayCritical (this, val0, val1, val2); }
+
+  const jchar * GetStringCritical (jstring val0, jboolean * val1)
+  { return functions->GetStringCritical (this, val0, val1); }
+
+  void ReleaseStringCritical (jstring val0, const jchar * val1)
+  { functions->ReleaseStringCritical (this, val0, val1); }
+
+  jweak NewWeakGlobalRef (jobject obj0)
+  { return functions->NewWeakGlobalRef (this, obj0); }
+
+  void DeleteWeakGlobalRef (jweak val0)
+  { functions->DeleteWeakGlobalRef (this, val0); }
+
+  jboolean ExceptionCheck ()
+  { return functions->ExceptionCheck (this); }
+
+  /* ---- JNI 1.4 functions ---- */
+
+  jobject NewDirectByteBuffer (void *addr, jlong capacity)
+  { return functions->NewDirectByteBuffer (this, addr, capacity); }
+
+  void *GetDirectBufferAddress (jobject buf)
+  { return functions->GetDirectBufferAddress (this, buf); }
+
+  jlong GetDirectBufferCapacity (jobject buf)
+  { return functions->GetDirectBufferCapacity (this, buf); }
+
+  /* ---- JNI 1.6 functions ---- */
+
+  jobjectRefType GetObjectRefType (jobject obj)
+  { return functions->GetObjectRefType (this, obj); }
+};
+
+#endif /* __cplusplus */
+
+/*
+ * Invocation API.
+ */
+
+struct JNIInvokeInterface_
+{
+  void *reserved0;
+  void *reserved1;
+  void *reserved2;
+
+  jint (JNICALL *DestroyJavaVM)         (JavaVM *);
+  jint (JNICALL *AttachCurrentThread)   (JavaVM *, void **, void *);
+  jint (JNICALL *DetachCurrentThread)   (JavaVM *);
+  jint (JNICALL *GetEnv)                (JavaVM *, void **, jint);
+  jint (JNICALL *AttachCurrentThreadAsDaemon) (JavaVM *, void **, void *);
+};
+
+#ifdef __cplusplus
+
+class _Jv_JavaVM
+{
+public:
+  const struct JNIInvokeInterface_ *functions;
+
+  jint DestroyJavaVM ()
+  { return functions->DestroyJavaVM (this); }
+
+  jint AttachCurrentThread (void **penv, void *args)
+  { return functions->AttachCurrentThread (this, penv, args); }
+
+  jint DetachCurrentThread ()
+  { return functions->DetachCurrentThread (this); }
+
+  jint GetEnv (void **penv, jint version)
+  { return functions->GetEnv (this, penv, version); }
+
+  jint AttachCurrentThreadAsDaemon (void **penv, void *args)
+  { return functions->AttachCurrentThreadAsDaemon (this, penv, args); }
+};
+
+#endif /* __cplusplus */
+
+typedef struct JavaVMAttachArgs
+{
+  jint version;                        /* Must be JNI_VERSION_1_2.  */
+  char *name;                  /* The name of the thread (or NULL).  */
+  jobject group;               /* Global ref of a ThreadGroup object
+                                  (or NULL).  */
+} JavaVMAttachArgs;
+
+typedef struct JavaVMOption
+{
+  char *optionString;
+  void *extraInfo;
+} JavaVMOption;
+
+typedef struct JavaVMInitArgs
+{
+  /* Must be JNI_VERSION_1_2.  */
+  jint version;
+
+  /* Number of options.  */
+  jint nOptions;
+
+  /* Options to the VM.  */
+  JavaVMOption *options;
+
+  /* Whether we should ignore unrecognized options.  */
+  jboolean ignoreUnrecognized;
+} JavaVMInitArgs;
+
+typedef struct JDK1_1InitArgs
+{
+  /* VM version.  Should be JNI_VERSION_1_1.  Note that before JDK
+     1.1.2, this field was named 'reserved0'.  (I don't know what the
+     current 'reserved0' field was named then.)  */
+  jint version;
+
+  /* A null-terminated array of environment strings, each of the form
+     "KEY=VALUE".  This is used to set system properties.  Note that
+     before JDK 1.1.2, this field was named 'reserved1'.  */
+  char **properties;
+
+  jint checkSource;
+  jint nativeStackSize;
+  jint javaStackSize;
+  jint minHeapSize;
+  jint maxHeapSize;
+  jint verifyMode;
+  const char *classpath;
+
+  jint (JNICALL *vfprintf) (FILE *file, const char *fmt, va_list args);
+  void (JNICALL *exit) (jint value);
+  void (JNICALL *abort) (void);
+
+  jint enableClassGC;
+  jint enableVerboseGC;
+  jint disableAsyncGC;
+
+  jint reserved0;
+  jint reserved1;
+  jint reserved2;
+} JDK1_1InitArgs;
+
+typedef struct JDK1_1AttachArgs
+{
+  /* Dummy field since C cannot have empty structs.  The name and type
+     are chosen to comply with the spec.  */
+  void *__padding;
+} JDK1_1AttachArgs;
+
+\f
+/* Keep c-font-lock-extra-types in alphabetical order. */
+/*
+Local Variables:
+c-font-lock-extra-types: ("\\sw+_t" \
+   "JNIEnv" "JNINativeMethod" "JavaVM" "JavaVMOption" "jarray" \
+   "jboolean" "jbooleanArray" "jbyte" "jbyteArray" "jchar"  "jcharArray" \
+   "jclass" "jdouble" "jdoubleArray" "jfieldID" "jfloat" "jfloatArray" \
+   "jint" "jintArray" "jlong" "jlongArray" "jmethodID" "jobject" \
+   "jstring" "jthrowable" "jvalue" "jweak")
+End:
+*/
+
+#endif /* _CLASSPATH_JNI_H */

diff --git a/Robust/src/Runtime/jni/jni_md-x86-linux-gnu.h b/Robust/src/Runtime/jni/jni_md-x86-linux-gnu.h
new file mode 100644 (file)
index 0000000..989dbfe
--- /dev/null
+++ b/Robust/src/Runtime/jni/jni_md-x86-linux-gnu.h
@@ -0,0 +1,45 @@
+/* jni_md.h
+   Copyright (C) 2001, 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+#ifndef __CLASSPATH_JNI_MD_H__
+#define __CLASSPATH_JNI_MD_H__
+
+/* Define some defaults */
+#define JNICALL
+#define JNIEXPORT
+#define JNIIMPORT
+
+typedef unsigned char jboolean;
+typedef signed char jbyte;
+typedef unsigned short jchar;
+typedef short jshort;
+typedef int jint;
+typedef long long jlong;
+typedef float jfloat;
+typedef double jdouble;
+typedef jint jsize;
+
+#endif /* __CLASSPATH_JNI_MD_H__ */

diff --git a/Robust/src/Runtime/jni/jni_md.h b/Robust/src/Runtime/jni/jni_md.h
new file mode 100644 (file)
index 0000000..989dbfe
--- /dev/null
+++ b/Robust/src/Runtime/jni/jni_md.h
@@ -0,0 +1,45 @@
+/* jni_md.h
+   Copyright (C) 2001, 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+#ifndef __CLASSPATH_JNI_MD_H__
+#define __CLASSPATH_JNI_MD_H__
+
+/* Define some defaults */
+#define JNICALL
+#define JNIEXPORT
+#define JNIIMPORT
+
+typedef unsigned char jboolean;
+typedef signed char jbyte;
+typedef unsigned short jchar;
+typedef short jshort;
+typedef int jint;
+typedef long long jlong;
+typedef float jfloat;
+typedef double jdouble;
+typedef jint jsize;
+
+#endif /* __CLASSPATH_JNI_MD_H__ */