JNIEnv functions table, helpful when reverse engineering JNI

gistfile1.txt

#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>

typedef int jint;
typedef int jclass;
typedef int jobject;
typedef int jmethodID;
typedef int jfieldID;
typedef int JNIEnv;
typedef int jsize;
typedef int jboolean;
typedef int jthrowable;
typedef int jbyte;
typedef int jvalue;
typedef int jchar;
typedef int jshort;
typedef int jlong;
typedef int jfloat;
typedef int jdouble;
typedef int jstring;
typedef int jarray;
typedef int jobjectArray;
typedef int jbooleanArray;
typedef int jbyteArray;
typedef int jcharArray;
typedef int jshortArray;
typedef int jintArray;
typedef int jlongArray;
typedef int jfloatArray;
typedef int jdoubleArray;
typedef int JNINativeMethod;
typedef int JavaVM;
typedef int jweak;
typedef int jobjectRefType;

struct JNINativeInterface {
    void*       reserved0;
    void*       reserved1;
    void*       reserved2;
    void*       reserved3;

    jint        (*GetVersion)(JNIEnv *);

    jclass      (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*, jsize);
    jclass      (*FindClass)(JNIEnv*, const char*);

    jmethodID   (*FromReflectedMethod)(JNIEnv*, jobject);
    jfieldID    (*FromReflectedField)(JNIEnv*, jobject);
    /* spec doesn't show jboolean parameter */
    jobject     (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean);

    jclass      (*GetSuperclass)(JNIEnv*, jclass);
    jboolean    (*IsAssignableFrom)(JNIEnv*, jclass, jclass);

    /* spec doesn't show jboolean parameter */
    jobject     (*ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean);

    jint        (*Throw)(JNIEnv*, jthrowable);
    jint        (*ThrowNew)(JNIEnv *, jclass, const char *);
    jthrowable  (*ExceptionOccurred)(JNIEnv*);
    void        (*ExceptionDescribe)(JNIEnv*);
    void        (*ExceptionClear)(JNIEnv*);
    void        (*FatalError)(JNIEnv*, const char*);

    jint        (*PushLocalFrame)(JNIEnv*, jint);
    jobject     (*PopLocalFrame)(JNIEnv*, jobject);

    jobject     (*NewGlobalRef)(JNIEnv*, jobject);
    void        (*DeleteGlobalRef)(JNIEnv*, jobject);
    void        (*DeleteLocalRef)(JNIEnv*, jobject);
    jboolean    (*IsSameObject)(JNIEnv*, jobject, jobject);

    jobject     (*NewLocalRef)(JNIEnv*, jobject);
    jint        (*EnsureLocalCapacity)(JNIEnv*, jint);

    jobject     (*AllocObject)(JNIEnv*, jclass);
    jobject     (*NewObject)(JNIEnv*, jclass, jmethodID, ...);
    jobject     (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list);
    jobject     (*NewObjectA)(JNIEnv*, jclass, jmethodID, jvalue*);

    jclass      (*GetObjectClass)(JNIEnv*, jobject);
    jboolean    (*IsInstanceOf)(JNIEnv*, jobject, jclass);
    jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);

    jobject     (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...);
    jobject     (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jobject     (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jboolean    (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...);
    jboolean    (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jboolean    (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jbyte       (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...);
    jbyte       (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jbyte       (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jchar       (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...);
    jchar       (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jchar       (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jshort      (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...);
    jshort      (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jshort      (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jint        (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...);
    jint        (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jint        (*CallIntMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jlong       (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...);
    jlong       (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jlong       (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jfloat      (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...);
    jfloat      (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jfloat      (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    jdouble     (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...);
    jdouble     (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jdouble     (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
    void        (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
    void        (*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    void        (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);

    jobject     (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jobject     (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jobject     (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    jboolean    (*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jboolean    (*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass,
                         jmethodID, va_list);
    jboolean    (*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass,
                         jmethodID, jvalue*);
    jbyte       (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jbyte       (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jbyte       (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    jchar       (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jchar       (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jchar       (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    jshort      (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jshort      (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jshort      (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    jint        (*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jint        (*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jint        (*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    jlong       (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jlong       (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jlong       (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    jfloat      (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jfloat      (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jfloat      (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    jdouble     (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jdouble     (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jdouble     (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);
    void        (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    void        (*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    void        (*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, jvalue*);

    jfieldID    (*GetFieldID)(JNIEnv*, jclass, const char*, const char*);

    jobject     (*GetObjectField)(JNIEnv*, jobject, jfieldID);
    jboolean    (*GetBooleanField)(JNIEnv*, jobject, jfieldID);
    jbyte       (*GetByteField)(JNIEnv*, jobject, jfieldID);
    jchar       (*GetCharField)(JNIEnv*, jobject, jfieldID);
    jshort      (*GetShortField)(JNIEnv*, jobject, jfieldID);
    jint        (*GetIntField)(JNIEnv*, jobject, jfieldID);
    jlong       (*GetLongField)(JNIEnv*, jobject, jfieldID);
    jfloat      (*GetFloatField)(JNIEnv*, jobject, jfieldID);
    jdouble     (*GetDoubleField)(JNIEnv*, jobject, jfieldID);

    void        (*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject);
    void        (*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean);
    void        (*SetByteField)(JNIEnv*, jobject, jfieldID, jbyte);
    void        (*SetCharField)(JNIEnv*, jobject, jfieldID, jchar);
    void        (*SetShortField)(JNIEnv*, jobject, jfieldID, jshort);
    void        (*SetIntField)(JNIEnv*, jobject, jfieldID, jint);
    void        (*SetLongField)(JNIEnv*, jobject, jfieldID, jlong);
    void        (*SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat);
    void        (*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble);

    jmethodID   (*GetStaticMethodID)(JNIEnv*, jclass, const char*, const char*);

    jobject     (*CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...);
    jobject     (*CallStaticObjectMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jobject     (*CallStaticObjectMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    jboolean    (*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...);
    jboolean    (*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID,
                        va_list);
    jboolean    (*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID,
                        jvalue*);
    jbyte       (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...);
    jbyte       (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jbyte       (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    jchar       (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...);
    jchar       (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jchar       (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    jshort      (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...);
    jshort      (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jshort      (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    jint        (*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...);
    jint        (*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jint        (*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    jlong       (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...);
    jlong       (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jlong       (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    jfloat      (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...);
    jfloat      (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jfloat      (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    jdouble     (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...);
    jdouble     (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jdouble     (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
    void        (*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...);
    void        (*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    void        (*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);

    jfieldID    (*GetStaticFieldID)(JNIEnv*, jclass, const char*,
                        const char*);

    jobject     (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID);
    jboolean    (*GetStaticBooleanField)(JNIEnv*, jclass, jfieldID);
    jbyte       (*GetStaticByteField)(JNIEnv*, jclass, jfieldID);
    jchar       (*GetStaticCharField)(JNIEnv*, jclass, jfieldID);
    jshort      (*GetStaticShortField)(JNIEnv*, jclass, jfieldID);
    jint        (*GetStaticIntField)(JNIEnv*, jclass, jfieldID);
    jlong       (*GetStaticLongField)(JNIEnv*, jclass, jfieldID);
    jfloat      (*GetStaticFloatField)(JNIEnv*, jclass, jfieldID);
    jdouble     (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID);

    void        (*SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject);
    void        (*SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean);
    void        (*SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte);
    void        (*SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar);
    void        (*SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort);
    void        (*SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint);
    void        (*SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong);
    void        (*SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat);
    void        (*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble);

    jstring     (*NewString)(JNIEnv*, const jchar*, jsize);
    jsize       (*GetStringLength)(JNIEnv*, jstring);
    const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*);
    jstring     (*NewStringUTF)(JNIEnv*, const char*);
    jsize       (*GetStringUTFLength)(JNIEnv*, jstring);
    /* JNI spec says this returns const jbyte*, but that's inconsistent */
    const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*);
    jsize       (*GetArrayLength)(JNIEnv*, jarray);
    jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject);
    jobject     (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize);
    void        (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject);

    jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize);
    jbyteArray    (*NewByteArray)(JNIEnv*, jsize);
    jcharArray    (*NewCharArray)(JNIEnv*, jsize);
    jshortArray   (*NewShortArray)(JNIEnv*, jsize);
    jintArray     (*NewIntArray)(JNIEnv*, jsize);
    jlongArray    (*NewLongArray)(JNIEnv*, jsize);
    jfloatArray   (*NewFloatArray)(JNIEnv*, jsize);
    jdoubleArray  (*NewDoubleArray)(JNIEnv*, jsize);

    jboolean*   (*GetBooleanArrayElements)(JNIEnv*, jbooleanArray, jboolean*);
    jbyte*      (*GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*);
    jchar*      (*GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*);
    jshort*     (*GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*);
    jint*       (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*);
    jlong*      (*GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*);
    jfloat*     (*GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*);
    jdouble*    (*GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*);

    void        (*ReleaseBooleanArrayElements)(JNIEnv*, jbooleanArray,
                        jboolean*, jint);
    void        (*ReleaseByteArrayElements)(JNIEnv*, jbyteArray,
                        jbyte*, jint);
    void        (*ReleaseCharArrayElements)(JNIEnv*, jcharArray,
                        jchar*, jint);
    void        (*ReleaseShortArrayElements)(JNIEnv*, jshortArray,
                        jshort*, jint);
    void        (*ReleaseIntArrayElements)(JNIEnv*, jintArray,
                        jint*, jint);
    void        (*ReleaseLongArrayElements)(JNIEnv*, jlongArray,
                        jlong*, jint);
    void        (*ReleaseFloatArrayElements)(JNIEnv*, jfloatArray,
                        jfloat*, jint);
    void        (*ReleaseDoubleArrayElements)(JNIEnv*, jdoubleArray,
                        jdouble*, jint);

    void        (*GetBooleanArrayRegion)(JNIEnv*, jbooleanArray,
                        jsize, jsize, jboolean*);
    void        (*GetByteArrayRegion)(JNIEnv*, jbyteArray,
                        jsize, jsize, jbyte*);
    void        (*GetCharArrayRegion)(JNIEnv*, jcharArray,
                        jsize, jsize, jchar*);
    void        (*GetShortArrayRegion)(JNIEnv*, jshortArray,
                        jsize, jsize, jshort*);
    void        (*GetIntArrayRegion)(JNIEnv*, jintArray,
                        jsize, jsize, jint*);
    void        (*GetLongArrayRegion)(JNIEnv*, jlongArray,
                        jsize, jsize, jlong*);
    void        (*GetFloatArrayRegion)(JNIEnv*, jfloatArray,
                        jsize, jsize, jfloat*);
    void        (*GetDoubleArrayRegion)(JNIEnv*, jdoubleArray,
                        jsize, jsize, jdouble*);

    /* spec shows these without const; some jni.h do, some don't */
    void        (*SetBooleanArrayRegion)(JNIEnv*, jbooleanArray,
                        jsize, jsize, const jboolean*);
    void        (*SetByteArrayRegion)(JNIEnv*, jbyteArray,
                        jsize, jsize, const jbyte*);
    void        (*SetCharArrayRegion)(JNIEnv*, jcharArray,
                        jsize, jsize, const jchar*);
    void        (*SetShortArrayRegion)(JNIEnv*, jshortArray,
                        jsize, jsize, const jshort*);
    void        (*SetIntArrayRegion)(JNIEnv*, jintArray,
                        jsize, jsize, const jint*);
    void        (*SetLongArrayRegion)(JNIEnv*, jlongArray,
                        jsize, jsize, const jlong*);
    void        (*SetFloatArrayRegion)(JNIEnv*, jfloatArray,
                        jsize, jsize, const jfloat*);
    void        (*SetDoubleArrayRegion)(JNIEnv*, jdoubleArray,
                        jsize, jsize, const jdouble*);

    jint        (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*,
                        jint);
    jint        (*UnregisterNatives)(JNIEnv*, jclass);
    jint        (*MonitorEnter)(JNIEnv*, jobject);
    jint        (*MonitorExit)(JNIEnv*, jobject);
    jint        (*GetJavaVM)(JNIEnv*, JavaVM**);

    void        (*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*);
    void        (*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*);

    void*       (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*);
    void        (*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint);

    const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*);

    jweak       (*NewWeakGlobalRef)(JNIEnv*, jobject);
    void        (*DeleteWeakGlobalRef)(JNIEnv*, jweak);

    jboolean    (*ExceptionCheck)(JNIEnv*);

    jobject     (*NewDirectByteBuffer)(JNIEnv*, void*, jlong);
    void*       (*GetDirectBufferAddress)(JNIEnv*, jobject);
    jlong       (*GetDirectBufferCapacity)(JNIEnv*, jobject);

    /* added in JNI 1.6 */
    jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject);
};

int main()
{
    printf( "GetVersion: %lx\n", offsetof( struct JNINativeInterface, GetVersion ) );
    printf( "DefineClass: %lx\n", offsetof( struct JNINativeInterface, DefineClass ) );
    printf( "FindClass: %lx\n", offsetof( struct JNINativeInterface, FindClass ) );
    printf( "FromReflectedMethod: %lx\n", offsetof( struct JNINativeInterface, FromReflectedMethod ) );
    printf( "FromReflectedField: %lx\n", offsetof( struct JNINativeInterface, FromReflectedField ) );
    printf( "ToReflectedMethod: %lx\n", offsetof( struct JNINativeInterface, ToReflectedMethod ) );
    printf( "GetSuperclass: %lx\n", offsetof( struct JNINativeInterface, GetSuperclass ) );
    printf( "IsAssignableFrom: %lx\n", offsetof( struct JNINativeInterface, IsAssignableFrom ) );
    printf( "ToReflectedField: %lx\n", offsetof( struct JNINativeInterface, ToReflectedField ) );
    printf( "Throw: %lx\n", offsetof( struct JNINativeInterface, Throw ) );
    printf( "ThrowNew: %lx\n", offsetof( struct JNINativeInterface, ThrowNew ) );
    printf( "ExceptionOccurred: %lx\n", offsetof( struct JNINativeInterface, ExceptionOccurred ) );
    printf( "ExceptionDescribe: %lx\n", offsetof( struct JNINativeInterface, ExceptionDescribe ) );
    printf( "ExceptionClear: %lx\n", offsetof( struct JNINativeInterface, ExceptionClear ) );
    printf( "FatalError: %lx\n", offsetof( struct JNINativeInterface, FatalError ) );
    printf( "PushLocalFrame: %lx\n", offsetof( struct JNINativeInterface, PushLocalFrame ) );
    printf( "PopLocalFrame: %lx\n", offsetof( struct JNINativeInterface, PopLocalFrame ) );
    printf( "NewGlobalRef: %lx\n", offsetof( struct JNINativeInterface, NewGlobalRef ) );
    printf( "DeleteGlobalRef: %lx\n", offsetof( struct JNINativeInterface, DeleteGlobalRef ) );
    printf( "DeleteLocalRef: %lx\n", offsetof( struct JNINativeInterface, DeleteLocalRef ) );
    printf( "IsSameObject: %lx\n", offsetof( struct JNINativeInterface, IsSameObject ) );
    printf( "NewLocalRef: %lx\n", offsetof( struct JNINativeInterface, NewLocalRef ) );
    printf( "EnsureLocalCapacity: %lx\n", offsetof( struct JNINativeInterface, EnsureLocalCapacity ) );
    printf( "AllocObject: %lx\n", offsetof( struct JNINativeInterface, AllocObject ) );
    printf( "NewObject: %lx\n", offsetof( struct JNINativeInterface, NewObject ) );
    printf( "NewObjectV: %lx\n", offsetof( struct JNINativeInterface, NewObjectV ) );
    printf( "NewObjectA: %lx\n", offsetof( struct JNINativeInterface, NewObjectA ) );
    printf( "GetObjectClass: %lx\n", offsetof( struct JNINativeInterface, GetObjectClass ) );
    printf( "IsInstanceOf: %lx\n", offsetof( struct JNINativeInterface, IsInstanceOf ) );
    printf( "GetMethodID: %lx\n", offsetof( struct JNINativeInterface, GetMethodID ) );
    printf( "CallObjectMethod: %lx\n", offsetof( struct JNINativeInterface, CallObjectMethod ) );
    printf( "CallObjectMethodV: %lx\n", offsetof( struct JNINativeInterface, CallObjectMethodV ) );
    printf( "CallObjectMethodA: %lx\n", offsetof( struct JNINativeInterface, CallObjectMethodA ) );
    printf( "CallBooleanMethod: %lx\n", offsetof( struct JNINativeInterface, CallBooleanMethod ) );
    printf( "CallBooleanMethodV: %lx\n", offsetof( struct JNINativeInterface, CallBooleanMethodV ) );
    printf( "CallBooleanMethodA: %lx\n", offsetof( struct JNINativeInterface, CallBooleanMethodA ) );
    printf( "CallByteMethod: %lx\n", offsetof( struct JNINativeInterface, CallByteMethod ) );
    printf( "CallByteMethodV: %lx\n", offsetof( struct JNINativeInterface, CallByteMethodV ) );
    printf( "CallByteMethodA: %lx\n", offsetof( struct JNINativeInterface, CallByteMethodA ) );
    printf( "CallCharMethod: %lx\n", offsetof( struct JNINativeInterface, CallCharMethod ) );
    printf( "CallCharMethodV: %lx\n", offsetof( struct JNINativeInterface, CallCharMethodV ) );
    printf( "CallCharMethodA: %lx\n", offsetof( struct JNINativeInterface, CallCharMethodA ) );
    printf( "CallShortMethod: %lx\n", offsetof( struct JNINativeInterface, CallShortMethod ) );
    printf( "CallShortMethodV: %lx\n", offsetof( struct JNINativeInterface, CallShortMethodV ) );
    printf( "CallShortMethodA: %lx\n", offsetof( struct JNINativeInterface, CallShortMethodA ) );
    printf( "CallIntMethod: %lx\n", offsetof( struct JNINativeInterface, CallIntMethod ) );
    printf( "CallIntMethodV: %lx\n", offsetof( struct JNINativeInterface, CallIntMethodV ) );
    printf( "CallIntMethodA: %lx\n", offsetof( struct JNINativeInterface, CallIntMethodA ) );
    printf( "CallLongMethod: %lx\n", offsetof( struct JNINativeInterface, CallLongMethod ) );
    printf( "CallLongMethodV: %lx\n", offsetof( struct JNINativeInterface, CallLongMethodV ) );
    printf( "CallLongMethodA: %lx\n", offsetof( struct JNINativeInterface, CallLongMethodA ) );
    printf( "CallFloatMethod: %lx\n", offsetof( struct JNINativeInterface, CallFloatMethod ) );
    printf( "CallFloatMethodV: %lx\n", offsetof( struct JNINativeInterface, CallFloatMethodV ) );
    printf( "CallFloatMethodA: %lx\n", offsetof( struct JNINativeInterface, CallFloatMethodA ) );
    printf( "CallDoubleMethod: %lx\n", offsetof( struct JNINativeInterface, CallDoubleMethod ) );
    printf( "CallDoubleMethodV: %lx\n", offsetof( struct JNINativeInterface, CallDoubleMethodV ) );
    printf( "CallDoubleMethodA: %lx\n", offsetof( struct JNINativeInterface, CallDoubleMethodA ) );
    printf( "CallVoidMethod: %lx\n", offsetof( struct JNINativeInterface, CallVoidMethod ) );
    printf( "CallVoidMethodV: %lx\n", offsetof( struct JNINativeInterface, CallVoidMethodV ) );
    printf( "CallVoidMethodA: %lx\n", offsetof( struct JNINativeInterface, CallVoidMethodA ) );
    printf( "CallNonvirtualObjectMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualObjectMethod ) );
    printf( "CallNonvirtualObjectMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualObjectMethodV ) );
    printf( "CallNonvirtualObjectMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualObjectMethodA ) );
    printf( "CallNonvirtualBooleanMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualBooleanMethod ) );
    printf( "CallNonvirtualBooleanMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualBooleanMethodV ) );
    printf( "CallNonvirtualBooleanMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualBooleanMethodA ) );
    printf( "CallNonvirtualByteMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualByteMethod ) );
    printf( "CallNonvirtualByteMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualByteMethodV ) );
    printf( "CallNonvirtualByteMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualByteMethodA ) );
    printf( "CallNonvirtualCharMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualCharMethod ) );
    printf( "CallNonvirtualCharMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualCharMethodV ) );
    printf( "CallNonvirtualCharMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualCharMethodA ) );
    printf( "CallNonvirtualShortMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualShortMethod ) );
    printf( "CallNonvirtualShortMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualShortMethodV ) );
    printf( "CallNonvirtualShortMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualShortMethodA ) );
    printf( "CallNonvirtualIntMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualIntMethod ) );
    printf( "CallNonvirtualIntMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualIntMethodV ) );
    printf( "CallNonvirtualIntMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualIntMethodA ) );
    printf( "CallNonvirtualLongMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualLongMethod ) );
    printf( "CallNonvirtualLongMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualLongMethodV ) );
    printf( "CallNonvirtualLongMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualLongMethodA ) );
    printf( "CallNonvirtualFloatMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualFloatMethod ) );
    printf( "CallNonvirtualFloatMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualFloatMethodV ) );
    printf( "CallNonvirtualFloatMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualFloatMethodA ) );
    printf( "CallNonvirtualDoubleMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualDoubleMethod ) );
    printf( "CallNonvirtualDoubleMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualDoubleMethodV ) );
    printf( "CallNonvirtualDoubleMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualDoubleMethodA ) );
    printf( "CallNonvirtualVoidMethod: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualVoidMethod ) );
    printf( "CallNonvirtualVoidMethodV: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualVoidMethodV ) );
    printf( "CallNonvirtualVoidMethodA: %lx\n", offsetof( struct JNINativeInterface, CallNonvirtualVoidMethodA ) );
    printf( "GetFieldID: %lx\n", offsetof( struct JNINativeInterface, GetFieldID ) );
    printf( "GetObjectField: %lx\n", offsetof( struct JNINativeInterface, GetObjectField ) );
    printf( "GetBooleanField: %lx\n", offsetof( struct JNINativeInterface, GetBooleanField ) );
    printf( "GetByteField: %lx\n", offsetof( struct JNINativeInterface, GetByteField ) );
    printf( "GetCharField: %lx\n", offsetof( struct JNINativeInterface, GetCharField ) );
    printf( "GetShortField: %lx\n", offsetof( struct JNINativeInterface, GetShortField ) );
    printf( "GetIntField: %lx\n", offsetof( struct JNINativeInterface, GetIntField ) );
    printf( "GetLongField: %lx\n", offsetof( struct JNINativeInterface, GetLongField ) );
    printf( "GetFloatField: %lx\n", offsetof( struct JNINativeInterface, GetFloatField ) );
    printf( "GetDoubleField: %lx\n", offsetof( struct JNINativeInterface, GetDoubleField ) );
    printf( "SetObjectField: %lx\n", offsetof( struct JNINativeInterface, SetObjectField ) );
    printf( "SetBooleanField: %lx\n", offsetof( struct JNINativeInterface, SetBooleanField ) );
    printf( "SetByteField: %lx\n", offsetof( struct JNINativeInterface, SetByteField ) );
    printf( "SetCharField: %lx\n", offsetof( struct JNINativeInterface, SetCharField ) );
    printf( "SetShortField: %lx\n", offsetof( struct JNINativeInterface, SetShortField ) );
    printf( "SetIntField: %lx\n", offsetof( struct JNINativeInterface, SetIntField ) );
    printf( "SetLongField: %lx\n", offsetof( struct JNINativeInterface, SetLongField ) );
    printf( "SetFloatField: %lx\n", offsetof( struct JNINativeInterface, SetFloatField ) );
    printf( "SetDoubleField: %lx\n", offsetof( struct JNINativeInterface, SetDoubleField ) );
    printf( "GetStaticMethodID: %lx\n", offsetof( struct JNINativeInterface, GetStaticMethodID ) );
    printf( "CallStaticObjectMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticObjectMethod ) );
    printf( "CallStaticObjectMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticObjectMethodV ) );
    printf( "CallStaticObjectMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticObjectMethodA ) );
    printf( "CallStaticBooleanMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticBooleanMethod ) );
    printf( "CallStaticBooleanMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticBooleanMethodV ) );
    printf( "CallStaticBooleanMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticBooleanMethodA ) );
    printf( "CallStaticByteMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticByteMethod ) );
    printf( "CallStaticByteMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticByteMethodV ) );
    printf( "CallStaticByteMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticByteMethodA ) );
    printf( "CallStaticCharMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticCharMethod ) );
    printf( "CallStaticCharMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticCharMethodV ) );
    printf( "CallStaticCharMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticCharMethodA ) );
    printf( "CallStaticShortMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticShortMethod ) );
    printf( "CallStaticShortMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticShortMethodV ) );
    printf( "CallStaticShortMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticShortMethodA ) );
    printf( "CallStaticIntMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticIntMethod ) );
    printf( "CallStaticIntMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticIntMethodV ) );
    printf( "CallStaticIntMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticIntMethodA ) );
    printf( "CallStaticLongMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticLongMethod ) );
    printf( "CallStaticLongMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticLongMethodV ) );
    printf( "CallStaticLongMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticLongMethodA ) );
    printf( "CallStaticFloatMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticFloatMethod ) );
    printf( "CallStaticFloatMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticFloatMethodV ) );
    printf( "CallStaticFloatMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticFloatMethodA ) );
    printf( "CallStaticDoubleMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticDoubleMethod ) );
    printf( "CallStaticDoubleMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticDoubleMethodV ) );
    printf( "CallStaticDoubleMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticDoubleMethodA ) );
    printf( "CallStaticVoidMethod: %lx\n", offsetof( struct JNINativeInterface, CallStaticVoidMethod ) );
    printf( "CallStaticVoidMethodV: %lx\n", offsetof( struct JNINativeInterface, CallStaticVoidMethodV ) );
    printf( "CallStaticVoidMethodA: %lx\n", offsetof( struct JNINativeInterface, CallStaticVoidMethodA ) );
    printf( "GetStaticFieldID: %lx\n", offsetof( struct JNINativeInterface, GetStaticFieldID ) );
    printf( "GetStaticObjectField: %lx\n", offsetof( struct JNINativeInterface, GetStaticObjectField ) );
    printf( "GetStaticBooleanField: %lx\n", offsetof( struct JNINativeInterface, GetStaticBooleanField ) );
    printf( "GetStaticByteField: %lx\n", offsetof( struct JNINativeInterface, GetStaticByteField ) );
    printf( "GetStaticCharField: %lx\n", offsetof( struct JNINativeInterface, GetStaticCharField ) );
    printf( "GetStaticShortField: %lx\n", offsetof( struct JNINativeInterface, GetStaticShortField ) );
    printf( "GetStaticIntField: %lx\n", offsetof( struct JNINativeInterface, GetStaticIntField ) );
    printf( "GetStaticLongField: %lx\n", offsetof( struct JNINativeInterface, GetStaticLongField ) );
    printf( "GetStaticFloatField: %lx\n", offsetof( struct JNINativeInterface, GetStaticFloatField ) );
    printf( "GetStaticDoubleField: %lx\n", offsetof( struct JNINativeInterface, GetStaticDoubleField ) );
    printf( "SetStaticObjectField: %lx\n", offsetof( struct JNINativeInterface, SetStaticObjectField ) );
    printf( "SetStaticBooleanField: %lx\n", offsetof( struct JNINativeInterface, SetStaticBooleanField ) );
    printf( "SetStaticByteField: %lx\n", offsetof( struct JNINativeInterface, SetStaticByteField ) );
    printf( "SetStaticCharField: %lx\n", offsetof( struct JNINativeInterface, SetStaticCharField ) );
    printf( "SetStaticShortField: %lx\n", offsetof( struct JNINativeInterface, SetStaticShortField ) );
    printf( "SetStaticIntField: %lx\n", offsetof( struct JNINativeInterface, SetStaticIntField ) );
    printf( "SetStaticLongField: %lx\n", offsetof( struct JNINativeInterface, SetStaticLongField ) );
    printf( "SetStaticFloatField: %lx\n", offsetof( struct JNINativeInterface, SetStaticFloatField ) );
    printf( "SetStaticDoubleField: %lx\n", offsetof( struct JNINativeInterface, SetStaticDoubleField ) );
    printf( "NewString: %lx\n", offsetof( struct JNINativeInterface, NewString ) );
    printf( "GetStringLength: %lx\n", offsetof( struct JNINativeInterface, GetStringLength ) );
    printf( "GetStringChars: %lx\n", offsetof( struct JNINativeInterface, GetStringChars ) );
    printf( "ReleaseStringChars: %lx\n", offsetof( struct JNINativeInterface, ReleaseStringChars ) );
    printf( "NewStringUTF: %lx\n", offsetof( struct JNINativeInterface, NewStringUTF ) );
    printf( "GetStringUTFLength: %lx\n", offsetof( struct JNINativeInterface, GetStringUTFLength ) );
    printf( "GetStringUTFChars: %lx\n", offsetof( struct JNINativeInterface, GetStringUTFChars ) );
    printf( "ReleaseStringUTFChars: %lx\n", offsetof( struct JNINativeInterface, ReleaseStringUTFChars ) );
    printf( "GetArrayLength: %lx\n", offsetof( struct JNINativeInterface, GetArrayLength ) );
    printf( "NewObjectArray: %lx\n", offsetof( struct JNINativeInterface, NewObjectArray ) );
    printf( "GetObjectArrayElement: %lx\n", offsetof( struct JNINativeInterface, GetObjectArrayElement ) );
    printf( "SetObjectArrayElement: %lx\n", offsetof( struct JNINativeInterface, SetObjectArrayElement ) );
    printf( "NewBooleanArray: %lx\n", offsetof( struct JNINativeInterface, NewBooleanArray ) );
    printf( "NewByteArray: %lx\n", offsetof( struct JNINativeInterface, NewByteArray ) );
    printf( "NewCharArray: %lx\n", offsetof( struct JNINativeInterface, NewCharArray ) );
    printf( "NewShortArray: %lx\n", offsetof( struct JNINativeInterface, NewShortArray ) );
    printf( "NewIntArray: %lx\n", offsetof( struct JNINativeInterface, NewIntArray ) );
    printf( "NewLongArray: %lx\n", offsetof( struct JNINativeInterface, NewLongArray ) );
    printf( "NewFloatArray: %lx\n", offsetof( struct JNINativeInterface, NewFloatArray ) );
    printf( "NewDoubleArray: %lx\n", offsetof( struct JNINativeInterface, NewDoubleArray ) );
    printf( "GetBooleanArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetBooleanArrayElements ) );
    printf( "GetByteArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetByteArrayElements ) );
    printf( "GetCharArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetCharArrayElements ) );
    printf( "GetShortArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetShortArrayElements ) );
    printf( "GetIntArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetIntArrayElements ) );
    printf( "GetLongArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetLongArrayElements ) );
    printf( "GetFloatArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetFloatArrayElements ) );
    printf( "GetDoubleArrayElements: %lx\n", offsetof( struct JNINativeInterface, GetDoubleArrayElements ) );
    printf( "ReleaseBooleanArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseBooleanArrayElements ) );
    printf( "ReleaseByteArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseByteArrayElements ) );
    printf( "ReleaseCharArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseCharArrayElements ) );
    printf( "ReleaseShortArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseShortArrayElements ) );
    printf( "ReleaseIntArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseIntArrayElements ) );
    printf( "ReleaseLongArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseLongArrayElements ) );
    printf( "ReleaseFloatArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseFloatArrayElements ) );
    printf( "ReleaseDoubleArrayElements: %lx\n", offsetof( struct JNINativeInterface, ReleaseDoubleArrayElements ) );
    printf( "GetBooleanArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetBooleanArrayRegion ) );
    printf( "GetByteArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetByteArrayRegion ) );
    printf( "GetCharArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetCharArrayRegion ) );
    printf( "GetShortArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetShortArrayRegion ) );
    printf( "GetIntArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetIntArrayRegion ) );
    printf( "GetLongArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetLongArrayRegion ) );
    printf( "GetFloatArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetFloatArrayRegion ) );
    printf( "GetDoubleArrayRegion: %lx\n", offsetof( struct JNINativeInterface, GetDoubleArrayRegion ) );
    printf( "SetBooleanArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetBooleanArrayRegion ) );
    printf( "SetByteArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetByteArrayRegion ) );
    printf( "SetCharArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetCharArrayRegion ) );
    printf( "SetShortArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetShortArrayRegion ) );
    printf( "SetIntArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetIntArrayRegion ) );
    printf( "SetLongArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetLongArrayRegion ) );
    printf( "SetFloatArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetFloatArrayRegion ) );
    printf( "SetDoubleArrayRegion: %lx\n", offsetof( struct JNINativeInterface, SetDoubleArrayRegion ) );
    printf( "RegisterNatives: %lx\n", offsetof( struct JNINativeInterface, RegisterNatives ) );
    printf( "UnregisterNatives: %lx\n", offsetof( struct JNINativeInterface, UnregisterNatives ) );
    printf( "MonitorEnter: %lx\n", offsetof( struct JNINativeInterface, MonitorEnter ) );
    printf( "MonitorExit: %lx\n", offsetof( struct JNINativeInterface, MonitorExit ) );
    printf( "GetJavaVM: %lx\n", offsetof( struct JNINativeInterface, GetJavaVM ) );
    printf( "GetStringRegion: %lx\n", offsetof( struct JNINativeInterface, GetStringRegion ) );
    printf( "GetStringUTFRegion: %lx\n", offsetof( struct JNINativeInterface, GetStringUTFRegion ) );
    printf( "GetPrimitiveArrayCritical: %lx\n", offsetof( struct JNINativeInterface, GetPrimitiveArrayCritical ) );
    printf( "ReleasePrimitiveArrayCritical: %lx\n", offsetof( struct JNINativeInterface, ReleasePrimitiveArrayCritical ) );
    printf( "GetStringCritical: %lx\n", offsetof( struct JNINativeInterface, GetStringCritical ) );
    printf( "ReleaseStringCritical: %lx\n", offsetof( struct JNINativeInterface, ReleaseStringCritical ) );
    printf( "NewWeakGlobalRef: %lx\n", offsetof( struct JNINativeInterface, NewWeakGlobalRef ) );
    printf( "DeleteWeakGlobalRef: %lx\n", offsetof( struct JNINativeInterface, DeleteWeakGlobalRef ) );
    printf( "ExceptionCheck: %lx\n", offsetof( struct JNINativeInterface, ExceptionCheck ) );
    printf( "NewDirectByteBuffer: %lx\n", offsetof( struct JNINativeInterface, NewDirectByteBuffer ) );
    printf( "GetDirectBufferAddress: %lx\n", offsetof( struct JNINativeInterface, GetDirectBufferAddress ) );
    printf( "GetDirectBufferCapacity: %lx\n", offsetof( struct JNINativeInterface, GetDirectBufferCapacity ) );
    printf( "GetObjectRefType: %lx\n", offsetof( struct JNINativeInterface, GetObjectRefType ) );
    return 0;
}