harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ge...@apache.org
Subject svn commit: r350181 [144/198] - in /incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core: ./ depends/ depends/files/ depends/jars/ depends/libs/ depends/libs/linux.IA32/ depends/libs/win.IA32/ depends/oss/ depends/oss/linux.IA32/ depends/oss/win....
Date Thu, 01 Dec 2005 06:04:00 GMT
Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jni.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jni.h?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jni.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jni.h Wed Nov 30 21:29:27 2005
@@ -0,0 +1,722 @@
+/* Copyright 1991, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(JNI_H)
+#define JNI_H
+
+#include "jniport.h"
+#include <stdio.h>  /* For 1.1 version of args (i.e., vfprintf) */
+#include <stdarg.h> /* For va_list */
+#if defined(JNI_JCL_H)
+#include "jni_jcl.h"
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+/* Boolean values */
+#define JNI_FALSE 0
+#define JNI_TRUE 1
+/* Codes for ReleaseXArrayElements */
+#define JNI_COMMIT 1
+#define JNI_ABORT 2
+/* JNI version numbers */
+#define JNI_VERSION_1_1 0x00010001
+#define JNI_VERSION_1_2 0x00010002
+#define JNI_VERSION_1_4 0x00010004
+#define JVMEXT_VERSION_1_1 0x7E010001
+/* Error codes */
+#define JNI_OK 0
+#define JNI_ERR (-1)
+#define JNI_EDETACHED	(-2)
+#define JNI_EVERSION		(-3)
+#define JNI_ENOMEM		(-4)
+#define JNI_EEXIST			(-5)
+#define JNI_EINVAL			(-6)
+typedef unsigned char jboolean;
+/* jbyte is platform specific */
+typedef unsigned short jchar;
+typedef short jshort;
+/* jint is platform specific */
+/* jlong is platform specific */
+typedef float jfloat;
+typedef double jdouble;
+typedef jint jsize;
+#if defined(__cplusplus)
+class _jobject {};
+class _jweak : public _jobject {};
+class _jclass : public _jobject {};
+class _jstring : public _jobject {};
+class _jthrowable : public _jobject {};
+class _jarray : public _jobject {};
+class _jobjectArray : public _jarray {};
+class _jbooleanArray : public _jarray {};
+class _jbyteArray : public _jarray {};
+class _jcharArray : public _jarray {};
+class _jshortArray : public _jarray {};
+class _jintArray : public _jarray {};
+class _jlongArray : public _jarray {};
+class _jfloatArray : public _jarray {};
+class _jdoubleArray : public _jarray {};
+typedef _jobject * jobject;
+typedef _jweak * jweak;
+typedef _jclass * jclass;
+typedef _jstring * jstring;
+typedef _jthrowable * jthrowable;
+typedef _jarray * jarray;
+typedef _jobjectArray * jobjectArray;
+typedef _jbooleanArray * jbooleanArray;
+typedef _jbyteArray * jbyteArray;
+typedef _jcharArray * jcharArray;
+typedef _jshortArray * jshortArray;
+typedef _jintArray * jintArray;
+typedef _jlongArray * jlongArray;
+typedef _jfloatArray * jfloatArray;
+typedef _jdoubleArray * jdoubleArray;
+#else
+struct _jobject;
+typedef struct _jobject * jobject;
+typedef jobject jweak;
+typedef jobject jclass;
+typedef jobject jstring;
+typedef jobject jthrowable;
+typedef jobject jarray;
+typedef jarray jobjectArray;
+typedef jarray jbooleanArray;
+typedef jarray jbyteArray;
+typedef jarray jcharArray;
+typedef jarray jshortArray;
+typedef jarray jintArray;
+typedef jarray jlongArray;
+typedef jarray jfloatArray;
+typedef jarray jdoubleArray;
+#endif
+struct _jfieldID;
+typedef struct _jfieldID *jfieldID;
+struct _jmethodID;
+typedef struct _jmethodID *jmethodID;
+/* Used for CallXXXMethodA API */
+typedef union jvalue {
+	jboolean z;
+	jbyte    b;
+	jchar    c;
+	jshort   s;
+	jint     i;
+	jlong    j;
+	jfloat   f;
+	jdouble  d;
+	jobject  l;
+} jvalue;
+typedef struct {
+	char *name;
+	char *signature;
+	void *fnPtr;
+} JNINativeMethod;
+/**
+ * JavaVMQuery structure
+ */
+struct JavaVMQuery;
+typedef struct JavaVMQuery JavaVMQuery;
+/**
+ * used in QueryGCStatus.
+ */
+#define JNI_GCQUERY_NURSERY_HEAP (jint) 0x3
+#define JNI_GCQUERY_MATURE_HEAP (jint) 0x4
+/**
+ * GCStatus structure.
+ */
+typedef struct GCStatus {
+	jint heap;
+	jint count;
+	jlong freestorage; 
+	jlong totalstorage;
+} GCStatus;
+struct JNINativeInterface_;
+struct JNIEnv_;
+struct JNIInvokeInterface_;
+struct JavaVM_;
+#if defined(__cplusplus)
+typedef  JNIEnv_ JNIEnv;
+typedef JavaVM_ JavaVM;
+#else
+typedef const struct JNINativeInterface_ *JNIEnv;
+typedef const struct JNIInvokeInterface_ *JavaVM;
+#endif
+struct JNINativeInterface_ {
+	void *reserved0;
+	void *reserved1;
+	void *reserved2;
+	void *reserved3;
+jint (JNICALL * GetVersion)(JNIEnv *env);
+	jclass (JNICALL * DefineClass)(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize bufLen);
+	jclass (JNICALL * FindClass)(JNIEnv *env, const char *name);
+	jmethodID (JNICALL * FromReflectedMethod)(JNIEnv *env, jobject method);
+	jfieldID (JNICALL * FromReflectedField)(JNIEnv *env, jobject field);
+	jobject (JNICALL * ToReflectedMethod)(JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
+	jclass (JNICALL * GetSuperclass)(JNIEnv *env, jclass clazz);
+	jboolean (JNICALL * IsAssignableFrom)(JNIEnv *env, jclass clazz1, jclass clazz2);
+	jobject (JNICALL * ToReflectedField)(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
+	jint (JNICALL * Throw)(JNIEnv *env, jthrowable obj);
+	jint (JNICALL * ThrowNew)(JNIEnv *env, jclass clazz, const char *message);
+	jthrowable (JNICALL * ExceptionOccurred)(JNIEnv *env);
+	void (JNICALL * ExceptionDescribe)(JNIEnv *env);
+	void (JNICALL * ExceptionClear)(JNIEnv *env);
+	void (JNICALL * FatalError)(JNIEnv *env, const char *msg);
+	jint (JNICALL * PushLocalFrame)(JNIEnv *env, jint capacity);
+	jobject (JNICALL * PopLocalFrame)(JNIEnv *env, jobject result);
+	jobject (JNICALL * NewGlobalRef)(JNIEnv *env, jobject obj);
+	void (JNICALL * DeleteGlobalRef)(JNIEnv *env, jobject gref);
+	void (JNICALL * DeleteLocalRef)(JNIEnv *env, jobject localRef);
+	jboolean (JNICALL * IsSameObject)(JNIEnv *env, jobject ref1, jobject ref2);
+	jobject (JNICALL * NewLocalRef)(JNIEnv *env, jobject ref);
+	jint (JNICALL * EnsureLocalCapacity)(JNIEnv *env, jint capacity);
+	jobject (JNICALL * AllocObject)(JNIEnv *env, jclass clazz);
+	jobject (JNICALL * NewObject)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jobject (JNICALL * NewObjectV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jobject (JNICALL * NewObjectA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jclass (JNICALL * GetObjectClass)(JNIEnv *env, jobject obj);
+	jboolean (JNICALL * IsInstanceOf)(JNIEnv *env, jobject obj, jclass clazz);
+	jmethodID (JNICALL * GetMethodID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
+	jobject (JNICALL * CallObjectMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jobject (JNICALL * CallObjectMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jobject (JNICALL * CallObjectMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
+	jboolean (JNICALL * CallBooleanMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jboolean (JNICALL * CallBooleanMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jboolean (JNICALL * CallBooleanMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
+	jbyte (JNICALL * CallByteMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jbyte (JNICALL * CallByteMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jbyte (JNICALL * CallByteMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
+	jchar (JNICALL * CallCharMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jchar (JNICALL * CallCharMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jchar (JNICALL * CallCharMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
+	jshort (JNICALL * CallShortMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jshort (JNICALL * CallShortMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jshort (JNICALL * CallShortMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
+	jint (JNICALL * CallIntMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jint (JNICALL * CallIntMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jint (JNICALL * CallIntMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
+	jlong (JNICALL * CallLongMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jlong (JNICALL * CallLongMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jlong (JNICALL * CallLongMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
+	jfloat (JNICALL * CallFloatMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jfloat (JNICALL * CallFloatMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jfloat (JNICALL * CallFloatMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
+	jdouble (JNICALL * CallDoubleMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	jdouble (JNICALL * CallDoubleMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	jdouble (JNICALL * CallDoubleMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
+	void (JNICALL * CallVoidMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);
+	void (JNICALL * CallVoidMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+	void (JNICALL * CallVoidMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
+	jobject (JNICALL * CallNonvirtualObjectMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jobject (JNICALL * CallNonvirtualObjectMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jobject (JNICALL * CallNonvirtualObjectMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+	jboolean (JNICALL * CallNonvirtualBooleanMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jboolean (JNICALL * CallNonvirtualBooleanMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jboolean (JNICALL * CallNonvirtualBooleanMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+	jbyte (JNICALL * CallNonvirtualByteMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jbyte (JNICALL * CallNonvirtualByteMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jbyte (JNICALL * CallNonvirtualByteMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+	jchar (JNICALL * CallNonvirtualCharMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jchar (JNICALL * CallNonvirtualCharMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jchar (JNICALL * CallNonvirtualCharMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+	jshort (JNICALL * CallNonvirtualShortMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jshort (JNICALL * CallNonvirtualShortMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jshort (JNICALL * CallNonvirtualShortMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+	jint (JNICALL * CallNonvirtualIntMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jint (JNICALL * CallNonvirtualIntMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jint (JNICALL * CallNonvirtualIntMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+	jlong (JNICALL * CallNonvirtualLongMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jlong (JNICALL * CallNonvirtualLongMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jlong (JNICALL * CallNonvirtualLongMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+	jfloat (JNICALL * CallNonvirtualFloatMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jfloat (JNICALL * CallNonvirtualFloatMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jfloat (JNICALL * CallNonvirtualFloatMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+	jdouble (JNICALL * CallNonvirtualDoubleMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	jdouble (JNICALL * CallNonvirtualDoubleMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	jdouble (JNICALL * CallNonvirtualDoubleMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
+	void (JNICALL * CallNonvirtualVoidMethod)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+	void (JNICALL * CallNonvirtualVoidMethodV)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
+	void (JNICALL * CallNonvirtualVoidMethodA)(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
+	jfieldID (JNICALL * GetFieldID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
+	jobject (JNICALL * GetObjectField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jboolean (JNICALL * GetBooleanField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jbyte (JNICALL * GetByteField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jchar (JNICALL * GetCharField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jshort (JNICALL * GetShortField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jint (JNICALL * GetIntField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jlong (JNICALL * GetLongField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jfloat (JNICALL * GetFloatField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	jdouble (JNICALL * GetDoubleField)(JNIEnv *env, jobject obj, jfieldID fieldID);
+	void (JNICALL * SetObjectField)(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value);
+	void (JNICALL * SetBooleanField)(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value);
+	void (JNICALL * SetByteField)(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value);
+	void (JNICALL * SetCharField)(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value);
+	void (JNICALL * SetShortField)(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value);
+	void (JNICALL * SetIntField)(JNIEnv *env, jobject obj, jfieldID fieldID, jint value);
+	void (JNICALL * SetLongField)(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value);
+	void (JNICALL * SetFloatField)(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value);
+	void (JNICALL * SetDoubleField)(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value);
+	jmethodID (JNICALL * GetStaticMethodID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
+	jobject (JNICALL * CallStaticObjectMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jobject (JNICALL * CallStaticObjectMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jobject (JNICALL * CallStaticObjectMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jboolean (JNICALL * CallStaticBooleanMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jboolean (JNICALL * CallStaticBooleanMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jboolean (JNICALL * CallStaticBooleanMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jbyte (JNICALL * CallStaticByteMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jbyte (JNICALL * CallStaticByteMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jbyte (JNICALL * CallStaticByteMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jchar (JNICALL * CallStaticCharMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jchar (JNICALL * CallStaticCharMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jchar (JNICALL * CallStaticCharMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jshort (JNICALL * CallStaticShortMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jshort (JNICALL * CallStaticShortMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jshort (JNICALL * CallStaticShortMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jint (JNICALL * CallStaticIntMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jint (JNICALL * CallStaticIntMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jint (JNICALL * CallStaticIntMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jlong (JNICALL * CallStaticLongMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jlong (JNICALL * CallStaticLongMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jlong (JNICALL * CallStaticLongMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jfloat (JNICALL * CallStaticFloatMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jfloat (JNICALL * CallStaticFloatMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jfloat (JNICALL * CallStaticFloatMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	jdouble (JNICALL * CallStaticDoubleMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	jdouble (JNICALL * CallStaticDoubleMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	jdouble (JNICALL * CallStaticDoubleMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
+	void (JNICALL * CallStaticVoidMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+	void (JNICALL * CallStaticVoidMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+	void (JNICALL * CallStaticVoidMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args);
+	jfieldID (JNICALL * GetStaticFieldID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
+	jobject (JNICALL * GetStaticObjectField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jboolean (JNICALL * GetStaticBooleanField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jbyte (JNICALL * GetStaticByteField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jchar (JNICALL * GetStaticCharField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jshort (JNICALL * GetStaticShortField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jint (JNICALL * GetStaticIntField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jlong (JNICALL * GetStaticLongField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jfloat (JNICALL * GetStaticFloatField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	jdouble (JNICALL * GetStaticDoubleField)(JNIEnv *env, jclass clazz, jfieldID fieldID);
+	void (JNICALL * SetStaticObjectField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
+	void (JNICALL * SetStaticBooleanField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
+	void (JNICALL * SetStaticByteField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
+	void (JNICALL * SetStaticCharField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
+	void (JNICALL * SetStaticShortField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
+	void (JNICALL * SetStaticIntField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
+	void (JNICALL * SetStaticLongField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
+	void (JNICALL * SetStaticFloatField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
+	void (JNICALL * SetStaticDoubleField)(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
+	jstring (JNICALL * NewString)(JNIEnv *env, const jchar *unicodeChars, jsize len);
+	jsize (JNICALL * GetStringLength)(JNIEnv *env, jstring string);
+	const jchar *(JNICALL * GetStringChars)(JNIEnv *env, jstring string, jboolean *isCopy);
+	void (JNICALL * ReleaseStringChars)(JNIEnv *env, jstring string, const jchar *utf);
+	jstring (JNICALL * NewStringUTF)(JNIEnv *env, const char *bytes);
+	jsize (JNICALL * GetStringUTFLength)(JNIEnv *env, jstring string);
+	const char* (JNICALL * GetStringUTFChars)(JNIEnv *env, jstring string, jboolean *isCopy);
+	void (JNICALL * ReleaseStringUTFChars)(JNIEnv *env, jstring string, const char* utf);
+	jsize (JNICALL * GetArrayLength)(JNIEnv *env, jarray array);
+	jobjectArray (JNICALL * NewObjectArray)(JNIEnv *env, jsize length, jclass clazz, jobject initialElement);
+	jobject (JNICALL * GetObjectArrayElement)(JNIEnv *env, jobjectArray array, jsize index);
+	void (JNICALL * SetObjectArrayElement)(JNIEnv *env, jobjectArray array, jsize index, jobject value);
+	jbooleanArray (JNICALL * NewBooleanArray)(JNIEnv *env, jsize length);
+	jbyteArray (JNICALL * NewByteArray)(JNIEnv *env, jsize length);
+	jcharArray (JNICALL * NewCharArray)(JNIEnv *env, jsize length);
+	jshortArray (JNICALL * NewShortArray)(JNIEnv *env, jsize length);
+	jintArray (JNICALL * NewIntArray)(JNIEnv *env, jsize length);
+	jlongArray (JNICALL * NewLongArray)(JNIEnv *env, jsize length);
+	jfloatArray (JNICALL * NewFloatArray)(JNIEnv *env, jsize length);
+	jdoubleArray (JNICALL * NewDoubleArray)(JNIEnv *env, jsize length);
+	jboolean * (JNICALL * GetBooleanArrayElements)(JNIEnv *env, jbooleanArray array, jboolean *isCopy);
+	jbyte * (JNICALL * GetByteArrayElements)(JNIEnv *env, jbyteArray array, jboolean *isCopy);
+	jchar * (JNICALL * GetCharArrayElements)(JNIEnv *env, jcharArray array, jboolean *isCopy);
+	jshort * (JNICALL * GetShortArrayElements)(JNIEnv *env, jshortArray array, jboolean *isCopy);
+	jint * (JNICALL * GetIntArrayElements)(JNIEnv *env, jintArray array, jboolean *isCopy);
+	jlong * (JNICALL * GetLongArrayElements)(JNIEnv *env, jlongArray array, jboolean *isCopy);
+	jfloat * (JNICALL * GetFloatArrayElements)(JNIEnv *env, jfloatArray array, jboolean *isCopy);
+	jdouble * (JNICALL * GetDoubleArrayElements)(JNIEnv *env, jdoubleArray array, jboolean *isCopy);
+	void (JNICALL * ReleaseBooleanArrayElements)(JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
+	void (JNICALL * ReleaseByteArrayElements)(JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
+	void (JNICALL * ReleaseCharArrayElements)(JNIEnv *env, jcharArray array, jchar *elems, jint mode);
+	void (JNICALL * ReleaseShortArrayElements)(JNIEnv *env, jshortArray array, jshort *elems, jint mode);
+	void (JNICALL * ReleaseIntArrayElements)(JNIEnv *env, jintArray array, jint *elems, jint mode);
+	void (JNICALL * ReleaseLongArrayElements)(JNIEnv *env, jlongArray array, jlong *elems, jint mode);
+	void (JNICALL * ReleaseFloatArrayElements)(JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
+	void (JNICALL * ReleaseDoubleArrayElements)(JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
+	void (JNICALL * GetBooleanArrayRegion)(JNIEnv *env, jbooleanArray array, jsize start, jsize len, jboolean *buf);
+	void (JNICALL * GetByteArrayRegion)(JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
+	void (JNICALL * GetCharArrayRegion)(JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
+	void (JNICALL * GetShortArrayRegion)(JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
+	void (JNICALL * GetIntArrayRegion)(JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
+	void (JNICALL * GetLongArrayRegion)(JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
+	void (JNICALL * GetFloatArrayRegion)(JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
+	void (JNICALL * GetDoubleArrayRegion)(JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
+	void (JNICALL * SetBooleanArrayRegion)(JNIEnv *env, jbooleanArray array, jsize start, jsize len, jboolean *buf);
+	void (JNICALL * SetByteArrayRegion)(JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
+	void (JNICALL * SetCharArrayRegion)(JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
+	void (JNICALL * SetShortArrayRegion)(JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
+	void (JNICALL * SetIntArrayRegion)(JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
+	void (JNICALL * SetLongArrayRegion)(JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
+	void (JNICALL * SetFloatArrayRegion)(JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
+	void (JNICALL * SetDoubleArrayRegion)(JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
+	jint (JNICALL * RegisterNatives)(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods);
+	jint (JNICALL * UnregisterNatives)(JNIEnv *env, jclass clazz);
+	jint (JNICALL * MonitorEnter)(JNIEnv *env, jobject obj);
+	jint (JNICALL * MonitorExit)(JNIEnv *env, jobject obj);
+	jint (JNICALL * GetJavaVM)(JNIEnv *env, JavaVM **vm);
+	void (JNICALL * GetStringRegion)(JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
+	void (JNICALL * GetStringUTFRegion)(JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
+	void * (JNICALL * GetPrimitiveArrayCritical)(JNIEnv *env, jarray array, jboolean *isCopy);
+	void (JNICALL * ReleasePrimitiveArrayCritical)(JNIEnv *env, jarray array, void *carray, jint mode);
+	jchar * (JNICALL * GetStringCritical)(JNIEnv *env, jstring string, jboolean *isCopy);
+	void (JNICALL * ReleaseStringCritical)(JNIEnv *env, jstring string, const jchar *carray);
+	jweak (JNICALL * NewWeakGlobalRef)(JNIEnv *env, jobject obj);
+	void (JNICALL * DeleteWeakGlobalRef)(JNIEnv *env, jweak obj);
+	jboolean (JNICALL * ExceptionCheck)(JNIEnv *env);
+	jobject (JNICALL * NewDirectByteBuffer)(JNIEnv *env, void *address, jlong capacity);
+	void * (JNICALL * GetDirectBufferAddress)(JNIEnv *env, jobject buf);
+	jlong (JNICALL * GetDirectBufferCapacity)(JNIEnv *env, jobject buf);
+};
+struct JNIEnv_ {
+	const struct JNINativeInterface_ *functions;
+	void *reserved0;
+	void *reserved1[6];
+#if defined(__cplusplus)
+	jint GetVersion() { return functions->GetVersion(this); }
+	jclass DefineClass(const char *name, jobject loader, const jbyte *buf, jsize bufLen) { return functions->DefineClass(this, name, loader, buf, bufLen); }
+	jclass FindClass(const char *name) { return functions->FindClass(this, name); }
+	jmethodID FromReflectedMethod(jobject method) { return functions->FromReflectedMethod(this, method); }
+	jfieldID FromReflectedField(jobject field) { return functions->FromReflectedField(this, field); }
+	jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) { return functions->ToReflectedMethod(this, cls, methodID, isStatic); }
+	jclass GetSuperclass(jclass clazz) { return functions->GetSuperclass(this, clazz); }
+	jboolean IsAssignableFrom(jclass clazz1, jclass clazz2) { return functions->IsAssignableFrom(this, clazz1, clazz2); }
+	jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) { return functions->ToReflectedField(this, cls, fieldID, isStatic); }
+	jint Throw(jthrowable obj) { return functions->Throw(this, obj); }
+	jint ThrowNew(jclass clazz, const char *message) { return functions->ThrowNew(this, clazz, message); }
+	jthrowable ExceptionOccurred() { return functions->ExceptionOccurred(this); }
+	void ExceptionDescribe() { functions->ExceptionDescribe(this); }
+	void ExceptionClear() { functions->ExceptionClear(this); }
+	void FatalError(const char *msg) { functions->FatalError(this, msg); }
+	jint PushLocalFrame(jint capacity) { return functions->PushLocalFrame(this, capacity); }
+	jobject PopLocalFrame(jobject result) { return functions->PopLocalFrame(this, result); }
+	jobject NewGlobalRef(jobject obj) { return functions->NewGlobalRef(this, obj); }
+	void DeleteGlobalRef(jobject gref) { functions->DeleteGlobalRef(this, gref); }
+	void DeleteLocalRef(jobject localRef) { functions->DeleteLocalRef(this, localRef); }
+	jboolean IsSameObject(jobject ref1, jobject ref2) { return functions->IsSameObject(this, ref1, ref2); }
+	jobject NewLocalRef(jobject ref) { return functions->NewLocalRef(this, ref); }
+	jint EnsureLocalCapacity(jint capacity) { return functions->EnsureLocalCapacity(this, capacity); }
+	jobject AllocObject(jclass clazz) { return functions->AllocObject(this, clazz); }
+	jobject NewObject(jclass clazz, jmethodID methodID, ...) { jobject retval; va_list parms; va_start(parms, methodID); retval = functions->NewObjectV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args) { return functions->NewObjectV(this, clazz, methodID, args); }
+	jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->NewObjectA(this, clazz, methodID, args); }
+	jclass GetObjectClass(jobject obj) { return functions->GetObjectClass(this, obj); }
+	jboolean IsInstanceOf(jobject obj, jclass clazz) { return functions->IsInstanceOf(this, obj, clazz); }
+	jmethodID GetMethodID(jclass clazz, const char *name, const char *sig) { return functions->GetMethodID(this, clazz, name, sig); }
+	jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { jobject retval; va_list parms; va_start(parms, methodID); retval = functions->CallObjectMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jobject CallObjectMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallObjectMethodV(this, obj, methodID, args); }
+	jobject CallObjectMethodA(jobject obj, jmethodID methodID, jvalue * args) { return functions->CallObjectMethodA(this, obj, methodID,  args); }
+	jboolean CallBooleanMethod(jobject obj, jmethodID methodID, ...) { jboolean retval; va_list parms; va_start(parms, methodID); retval = functions->CallBooleanMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallBooleanMethodV(this, obj, methodID, args); }
+	jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, jvalue * args) { return functions->CallBooleanMethodA(this, obj, methodID,  args); }
+	jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { jbyte retval; va_list parms; va_start(parms, methodID); retval = functions->CallByteMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jbyte CallByteMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallByteMethodV(this, obj, methodID, args); }
+	jbyte CallByteMethodA(jobject obj, jmethodID methodID, jvalue *args) { return functions->CallByteMethodA(this, obj, methodID, args); }
+	jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { jchar retval; va_list parms; va_start(parms, methodID); retval = functions->CallCharMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jchar CallCharMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallCharMethodV(this, obj, methodID, args); }
+	jchar CallCharMethodA(jobject obj, jmethodID methodID, jvalue *args) { return functions->CallCharMethodA(this, obj, methodID, args); }
+	jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { jshort retval; va_list parms; va_start(parms, methodID); retval = functions->CallShortMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jshort CallShortMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallShortMethodV(this, obj, methodID, args); }
+	jshort CallShortMethodA(jobject obj, jmethodID methodID, jvalue *args) { return functions->CallShortMethodA(this, obj, methodID, args); }
+	jint CallIntMethod(jobject obj, jmethodID methodID, ...) { jint retval; va_list parms; va_start(parms, methodID); retval = functions->CallIntMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jint CallIntMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallIntMethodV(this, obj, methodID, args); }
+	jint CallIntMethodA(jobject obj, jmethodID methodID, jvalue *args) { return functions->CallIntMethodA(this, obj, methodID, args); }
+	jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { jlong retval; va_list parms; va_start(parms, methodID); retval = functions->CallLongMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jlong CallLongMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallLongMethodV(this, obj, methodID, args); }
+	jlong CallLongMethodA(jobject obj, jmethodID methodID, jvalue *args) { return functions->CallLongMethodA(this, obj, methodID, args); }
+	jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { jfloat retval; va_list parms; va_start(parms, methodID); retval = functions->CallFloatMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jfloat CallFloatMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallFloatMethodV(this, obj, methodID, args); }
+	jfloat CallFloatMethodA(jobject obj, jmethodID methodID, jvalue *args) { return functions->CallFloatMethodA(this, obj, methodID, args); }
+	jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { jdouble retval; va_list parms; va_start(parms, methodID); retval = functions->CallDoubleMethodV(this, obj, methodID, parms); va_end(parms); return retval; }
+	jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, va_list args) { return functions->CallDoubleMethodV(this, obj, methodID, args); }
+	jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, jvalue *args) { return functions->CallDoubleMethodA(this, obj, methodID, args); }
+	void CallVoidMethod(jobject obj, jmethodID methodID, ...) { va_list parms; va_start(parms, methodID); functions->CallVoidMethodV(this, obj, methodID, parms); va_end(parms); }
+	void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args) { functions->CallVoidMethodV(this, obj, methodID, args); }
+	void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue * args) { functions->CallVoidMethodA(this, obj, methodID,  args); }
+	jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jobject retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualObjectMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualObjectMethodV(this, obj, clazz, methodID, args); }
+	jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue * args) { return functions->CallNonvirtualObjectMethodA(this, obj, clazz, methodID,  args); }
+	jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jboolean retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualBooleanMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualBooleanMethodV(this, obj, clazz, methodID, args); }
+	jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue * args) { return functions->CallNonvirtualBooleanMethodA(this, obj, clazz, methodID,  args); }
+	jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jbyte retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualByteMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualByteMethodV(this, obj, clazz, methodID, args); }
+	jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallNonvirtualByteMethodA(this, obj, clazz, methodID, args); }
+	jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jchar retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualCharMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualCharMethodV(this, obj, clazz, methodID, args); }
+	jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallNonvirtualCharMethodA(this, obj, clazz, methodID, args); }
+	jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jshort retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualShortMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualShortMethodV(this, obj, clazz, methodID, args); }
+	jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallNonvirtualShortMethodA(this, obj, clazz, methodID, args); }
+	jint CallNonvirtualIntMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jint retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualIntMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualIntMethodV(this, obj, clazz, methodID, args); }
+	jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallNonvirtualIntMethodA(this, obj, clazz, methodID, args); }
+	jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jlong retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualLongMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualLongMethodV(this, obj, clazz, methodID, args); }
+	jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallNonvirtualLongMethodA(this, obj, clazz, methodID, args); }
+	jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jfloat retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualFloatMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualFloatMethodV(this, obj, clazz, methodID, args); }
+	jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallNonvirtualFloatMethodA(this, obj, clazz, methodID, args); }
+	jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { jdouble retval; va_list parms; va_start(parms, methodID); retval = functions->CallNonvirtualDoubleMethodV(this, obj, clazz, methodID, parms); va_end(parms); return retval; }
+	jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { return functions->CallNonvirtualDoubleMethodV(this, obj, clazz, methodID, args); }
+	jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallNonvirtualDoubleMethodA(this, obj, clazz, methodID, args); }
+	void CallNonvirtualVoidMethod(jobject obj, jclass clazz, jmethodID methodID, ...) { va_list parms; va_start(parms, methodID); functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, parms); va_end(parms); }
+	void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, jmethodID methodID, va_list args) { functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); }
+	void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, jmethodID methodID, jvalue * args) { functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID,  args); }
+	jfieldID GetFieldID(jclass clazz, const char *name, const char *sig) { return functions->GetFieldID(this, clazz, name, sig); }
+	jobject GetObjectField(jobject obj, jfieldID fieldID) { return functions->GetObjectField(this, obj, fieldID); }
+	jboolean GetBooleanField(jobject obj, jfieldID fieldID) { return functions->GetBooleanField(this, obj, fieldID); }
+	jbyte GetByteField(jobject obj, jfieldID fieldID) { return functions->GetByteField(this, obj, fieldID); }
+	jchar GetCharField(jobject obj, jfieldID fieldID) { return functions->GetCharField(this, obj, fieldID); }
+	jshort GetShortField(jobject obj, jfieldID fieldID) { return functions->GetShortField(this, obj, fieldID); }
+	jint GetIntField(jobject obj, jfieldID fieldID) { return functions->GetIntField(this, obj, fieldID); }
+	jlong GetLongField(jobject obj, jfieldID fieldID) { return functions->GetLongField(this, obj, fieldID); }
+	jfloat GetFloatField(jobject obj, jfieldID fieldID) { return functions->GetFloatField(this, obj, fieldID); }
+	jdouble GetDoubleField(jobject obj, jfieldID fieldID) { return functions->GetDoubleField(this, obj, fieldID); }
+	void SetObjectField(jobject obj, jfieldID fieldID, jobject value) { functions->SetObjectField(this, obj, fieldID, value); }
+	void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value) { functions->SetBooleanField(this, obj, fieldID, value); }
+	void SetByteField(jobject obj, jfieldID fieldID, jbyte value) { functions->SetByteField(this, obj, fieldID, value); }
+	void SetCharField(jobject obj, jfieldID fieldID, jchar value) { functions->SetCharField(this, obj, fieldID, value); }
+	void SetShortField(jobject obj, jfieldID fieldID, jshort value) { functions->SetShortField(this, obj, fieldID, value); }
+	void SetIntField(jobject obj, jfieldID fieldID, jint value) { functions->SetIntField(this, obj, fieldID, value); }
+	void SetLongField(jobject obj, jfieldID fieldID, jlong value) { functions->SetLongField(this, obj, fieldID, value); }
+	void SetFloatField(jobject obj, jfieldID fieldID, jfloat value) { functions->SetFloatField(this, obj, fieldID, value); }
+	void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value) { functions->SetDoubleField(this, obj, fieldID, value); }
+	jmethodID GetStaticMethodID(jclass clazz, const char *name, const char *sig) { return functions->GetStaticMethodID(this, clazz, name, sig); }
+	jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, ...) { jobject retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticObjectMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticObjectMethodV(this, clazz, methodID, args); }
+	jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticObjectMethodA(this, clazz, methodID, args); }
+	jboolean CallStaticBooleanMethod(jclass clazz, jmethodID methodID, ...) { jboolean retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticBooleanMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jboolean CallStaticBooleanMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticBooleanMethodV(this, clazz, methodID, args); }
+	jboolean CallStaticBooleanMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticBooleanMethodA(this, clazz, methodID, args); }
+	jbyte CallStaticByteMethod(jclass clazz, jmethodID methodID, ...) { jbyte retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticByteMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jbyte CallStaticByteMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticByteMethodV(this, clazz, methodID, args); }
+	jbyte CallStaticByteMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticByteMethodA(this, clazz, methodID, args); }
+	jchar CallStaticCharMethod(jclass clazz, jmethodID methodID, ...) { jchar retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticCharMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jchar CallStaticCharMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticCharMethodV(this, clazz, methodID, args); }
+	jchar CallStaticCharMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticCharMethodA(this, clazz, methodID, args); }
+	jshort CallStaticShortMethod(jclass clazz, jmethodID methodID, ...) { jshort retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticShortMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jshort CallStaticShortMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticShortMethodV(this, clazz, methodID, args); }
+	jshort CallStaticShortMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticShortMethodA(this, clazz, methodID, args); }
+	jint CallStaticIntMethod(jclass clazz, jmethodID methodID, ...) { jint retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticIntMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jint CallStaticIntMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticIntMethodV(this, clazz, methodID, args); }
+	jint CallStaticIntMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticIntMethodA(this, clazz, methodID, args); }
+	jlong CallStaticLongMethod(jclass clazz, jmethodID methodID, ...) { jlong retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticLongMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jlong CallStaticLongMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticLongMethodV(this, clazz, methodID, args); }
+	jlong CallStaticLongMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticLongMethodA(this, clazz, methodID, args); }
+	jfloat CallStaticFloatMethod(jclass clazz, jmethodID methodID, ...) { jfloat retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticFloatMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jfloat CallStaticFloatMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticFloatMethodV(this, clazz, methodID, args); }
+	jfloat CallStaticFloatMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticFloatMethodA(this, clazz, methodID, args); }
+	jdouble CallStaticDoubleMethod(jclass clazz, jmethodID methodID, ...) { jdouble retval; va_list parms; va_start(parms, methodID); retval = functions->CallStaticDoubleMethodV(this, clazz, methodID, parms); va_end(parms); return retval; }
+	jdouble CallStaticDoubleMethodV(jclass clazz, jmethodID methodID, va_list args) { return functions->CallStaticDoubleMethodV(this, clazz, methodID, args); }
+	jdouble CallStaticDoubleMethodA(jclass clazz, jmethodID methodID, jvalue *args) { return functions->CallStaticDoubleMethodA(this, clazz, methodID, args); }
+	void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...) { va_list parms; va_start(parms, methodID); functions->CallStaticVoidMethodV(this, clazz, methodID, parms); va_end(parms); }
+	void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args) { functions->CallStaticVoidMethodV(this, clazz, methodID, args); }
+	void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, jvalue * args) { functions->CallStaticVoidMethodA(this, clazz, methodID,  args); }
+	jfieldID GetStaticFieldID(jclass clazz, const char *name, const char *sig) { return functions->GetStaticFieldID(this, clazz, name, sig); }
+	jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { return functions->GetStaticObjectField(this, clazz, fieldID); }
+	jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) { return functions->GetStaticBooleanField(this, clazz, fieldID); }
+	jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) { return functions->GetStaticByteField(this, clazz, fieldID); }
+	jchar GetStaticCharField(jclass clazz, jfieldID fieldID) { return functions->GetStaticCharField(this, clazz, fieldID); }
+	jshort GetStaticShortField(jclass clazz, jfieldID fieldID) { return functions->GetStaticShortField(this, clazz, fieldID); }
+	jint GetStaticIntField(jclass clazz, jfieldID fieldID) { return functions->GetStaticIntField(this, clazz, fieldID); }
+	jlong GetStaticLongField(jclass clazz, jfieldID fieldID) { return functions->GetStaticLongField(this, clazz, fieldID); }
+	jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) { return functions->GetStaticFloatField(this, clazz, fieldID); }
+	jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) { return functions->GetStaticDoubleField(this, clazz, fieldID); }
+	void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value) { functions->SetStaticObjectField(this, clazz, fieldID, value); }
+	void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value) { functions->SetStaticBooleanField(this, clazz, fieldID, value); }
+	void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value) { functions->SetStaticByteField(this, clazz, fieldID, value); }
+	void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value) { functions->SetStaticCharField(this, clazz, fieldID, value); }
+	void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value) { functions->SetStaticShortField(this, clazz, fieldID, value); }
+	void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value) { functions->SetStaticIntField(this, clazz, fieldID, value); }
+	void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value) { functions->SetStaticLongField(this, clazz, fieldID, value); }
+	void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value) { functions->SetStaticFloatField(this, clazz, fieldID, value); }
+	void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value) { functions->SetStaticDoubleField(this, clazz, fieldID, value); }
+	jstring NewString(const jchar *unicodeChars, jsize len) { return functions->NewString(this, unicodeChars, len); }
+	jsize GetStringLength(jstring string) { return functions->GetStringLength(this, string); }
+	const jchar* GetStringChars(jstring string, jboolean *isCopy) { return functions->GetStringChars(this, string, isCopy); }
+	void ReleaseStringChars(jstring string, const jchar *utf) { functions->ReleaseStringChars(this, string, utf); }
+	jstring NewStringUTF(const char *bytes) { return functions->NewStringUTF(this, bytes); }
+	jsize GetStringUTFLength(jstring string) { return functions->GetStringUTFLength(this, string); }
+	const char* GetStringUTFChars(jstring string, jboolean *isCopy) { return functions->GetStringUTFChars(this, string, isCopy); }
+	void ReleaseStringUTFChars(jstring string, const char* utf) { functions->ReleaseStringUTFChars(this, string, utf); }
+	jsize GetArrayLength(jarray array) { return functions->GetArrayLength(this, array); }
+	jobjectArray NewObjectArray(jsize length, jclass clazz, jobject initialElement) { return functions->NewObjectArray(this, length, clazz, initialElement); }
+	jobject GetObjectArrayElement(jobjectArray array, jsize index) { return functions->GetObjectArrayElement(this, array, index); }
+	void SetObjectArrayElement(jobjectArray array, jsize index, jobject value) { functions->SetObjectArrayElement(this, array, index, value); }
+	jbooleanArray NewBooleanArray(jsize length) { return functions->NewBooleanArray(this, length); }
+	jbyteArray NewByteArray(jsize length) { return functions->NewByteArray(this, length); }
+	jcharArray NewCharArray(jsize length) { return functions->NewCharArray(this, length); }
+	jshortArray NewShortArray(jsize length) { return functions->NewShortArray(this, length); }
+	jintArray NewIntArray(jsize length) { return functions->NewIntArray(this, length); }
+	jlongArray NewLongArray(jsize length) { return functions->NewLongArray(this, length); }
+	jfloatArray NewFloatArray(jsize length) { return functions->NewFloatArray(this, length); }
+	jdoubleArray NewDoubleArray(jsize length) { return functions->NewDoubleArray(this, length); }
+	jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) { return functions->GetBooleanArrayElements(this, array, isCopy); }
+	jbyte* GetByteArrayElements(jbyteArray array, jboolean *isCopy) { return functions->GetByteArrayElements(this, array, isCopy); }
+	jchar*  GetCharArrayElements(jcharArray array, jboolean *isCopy) { return functions->GetCharArrayElements(this, array, isCopy); }
+	jshort* GetShortArrayElements(jshortArray array, jboolean *isCopy) { return functions->GetShortArrayElements(this, array, isCopy); }
+	jint* GetIntArrayElements(jintArray array, jboolean *isCopy) { return functions->GetIntArrayElements(this, array, isCopy); }
+	jlong* GetLongArrayElements(jlongArray array, jboolean *isCopy) { return functions->GetLongArrayElements(this, array, isCopy); }
+	jfloat* GetFloatArrayElements(jfloatArray array, jboolean *isCopy) { return functions->GetFloatArrayElements(this, array, isCopy); }
+	jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) { return functions->GetDoubleArrayElements(this, array, isCopy); }
+	void ReleaseBooleanArrayElements(jbooleanArray array, jboolean *elems, jint mode) { functions->ReleaseBooleanArrayElements(this, array, elems, mode); }
+	void ReleaseByteArrayElements(jbyteArray array, jbyte *elems, jint mode) { functions->ReleaseByteArrayElements(this, array, elems, mode); }
+	void ReleaseCharArrayElements(jcharArray array, jchar *elems, jint mode) { functions->ReleaseCharArrayElements(this, array, elems, mode); }
+	void ReleaseShortArrayElements(jshortArray array, jshort *elems, jint mode) { functions->ReleaseShortArrayElements(this, array, elems, mode); }
+	void ReleaseIntArrayElements(jintArray array, jint *elems, jint mode) { functions->ReleaseIntArrayElements(this, array, elems, mode); }
+	void ReleaseLongArrayElements(jlongArray array, jlong *elems, jint mode) { functions->ReleaseLongArrayElements(this, array, elems, mode); }
+	void ReleaseFloatArrayElements(jfloatArray array, jfloat *elems, jint mode) { functions->ReleaseFloatArrayElements(this, array, elems, mode); }
+	void ReleaseDoubleArrayElements(jdoubleArray array, jdouble *elems, jint mode) { functions->ReleaseDoubleArrayElements(this, array, elems, mode); }
+	void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, jboolean *buf) { functions->GetBooleanArrayRegion(this, array, start, len, buf); }
+	void GetByteArrayRegion(jbyteArray array, jsize start, jsize len, jbyte *buf) { functions->GetByteArrayRegion(this, array, start, len, buf); }
+	void GetCharArrayRegion(jcharArray array, jsize start, jsize len, jchar *buf) { functions->GetCharArrayRegion(this, array, start, len, buf); }
+	void GetShortArrayRegion(jshortArray array, jsize start, jsize len, jshort *buf) { functions->GetShortArrayRegion(this, array, start, len, buf); }
+	void GetIntArrayRegion(jintArray array, jsize start, jsize len, jint *buf) { functions->GetIntArrayRegion(this, array, start, len, buf); }
+	void GetLongArrayRegion(jlongArray array, jsize start, jsize len, jlong *buf) { functions->GetLongArrayRegion(this, array, start, len, buf); }
+	void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len, jfloat *buf) { functions->GetFloatArrayRegion(this, array, start, len, buf); }
+	void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, jdouble *buf) { functions->GetDoubleArrayRegion(this, array, start, len, buf); }
+	void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, jboolean *buf) { functions->SetBooleanArrayRegion(this, array, start, len, buf); }
+	void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, jbyte *buf) { functions->SetByteArrayRegion(this, array, start, len, buf); }
+	void SetCharArrayRegion(jcharArray array, jsize start, jsize len, jchar *buf) { functions->SetCharArrayRegion(this, array, start, len, buf); }
+	void SetShortArrayRegion(jshortArray array, jsize start, jsize len, jshort *buf) { functions->SetShortArrayRegion(this, array, start, len, buf); }
+	void SetIntArrayRegion(jintArray array, jsize start, jsize len, jint *buf) { functions->SetIntArrayRegion(this, array, start, len, buf); }
+	void SetLongArrayRegion(jlongArray array, jsize start, jsize len, jlong *buf) { functions->SetLongArrayRegion(this, array, start, len, buf); }
+	void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, jfloat *buf) { functions->SetFloatArrayRegion(this, array, start, len, buf); }
+	void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, jdouble *buf) { functions->SetDoubleArrayRegion(this, array, start, len, buf); }
+	jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, jint nMethods) { return functions->RegisterNatives(this, clazz, methods, nMethods); }
+	jint UnregisterNatives(jclass clazz) { return functions->UnregisterNatives(this, clazz); }
+	jint MonitorEnter(jobject obj) { return functions->MonitorEnter(this, obj); }
+	jint MonitorExit(jobject obj) { return functions->MonitorExit(this, obj); }
+	jint GetJavaVM(JavaVM **vm) { return functions->GetJavaVM(this, vm); }
+	void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) { functions->GetStringRegion(this, str, start, len, buf); }
+	void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) { functions->GetStringUTFRegion(this, str, start, len, buf); }
+	void* GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) { return functions->GetPrimitiveArrayCritical(this, array, isCopy); }
+	void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) { functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); }
+	jchar* GetStringCritical(jstring string, jboolean *isCopy) { return functions->GetStringCritical(this, string, isCopy); }
+	void ReleaseStringCritical(jstring string, const jchar *carray) { functions->ReleaseStringCritical(this, string, carray); }
+	jweak NewWeakGlobalRef(jobject obj) { return functions->NewWeakGlobalRef(this, obj); }
+	void DeleteWeakGlobalRef(jweak obj) { functions->DeleteWeakGlobalRef(this, obj); }
+	jboolean ExceptionCheck() { return functions->ExceptionCheck(this); }
+	jobject NewDirectByteBuffer(void *address, jlong capacity) { return functions->NewDirectByteBuffer(this, address, capacity); }
+	void* GetDirectBufferAddress(jobject buf) { return functions->GetDirectBufferAddress(this, buf); }
+	jlong GetDirectBufferCapacity(jobject buf) { return functions->GetDirectBufferCapacity(this, buf); }
+#endif
+};
+/* 1.1 Args */
+typedef struct JDK1_1InitArgs {
+	jint version;
+	char **properties;
+	jint checkSource; 
+	jint nativeStackSize;
+	jint javaStackSize;
+	jint minHeapSize;
+	jint maxHeapSize;
+	jint verifyMode;
+	const char *classpath;
+	jint (JNICALL * vfprintf)(FILE *fp, const char *format, va_list args);
+	void (JNICALL * exit)(jint code);
+	void (JNICALL * abort)();
+	jint enableClassGC;
+	jint enableVerboseGC;
+	jint disableAsyncGC;
+	jint verbose;
+	jint debugAgent;
+	jint debugPort;
+} JDK1_1InitArgs;
+typedef struct JDK1_1AttachArgs {
+	void * __padding; /* C compilers don't allow empty structures. */
+} JDK1_1AttachArgs;
+/* 1.2 args */
+typedef struct JavaVMOption {
+	char *optionString;
+	void *extraInfo;
+} JavaVMOption;
+typedef struct JavaVMInitArgs {
+	jint version;
+	jint nOptions;
+	JavaVMOption *options;
+	jboolean ignoreUnrecognized;
+} JavaVMInitArgs;
+typedef struct {
+	jint version;
+	char *name;
+	jobject group;
+} JavaVMAttachArgs;
+struct JNIInvokeInterface_ {
+	void *reserved0;
+	void *reserved1;
+	void *reserved2;
+	jint (JNICALL * DestroyJavaVM)(JavaVM *vm);
+	jint (JNICALL * AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
+	jint (JNICALL * DetachCurrentThread)(JavaVM *vm);
+	jint (JNICALL * GetEnv)(JavaVM *vm, void **penv, jint version);
+	jint (JNICALL * AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
+};
+struct JavaVM_ {
+	const struct JNIInvokeInterface_ *functions;
+	void *reserved0;
+	void *reserved1;
+	void *reserved2;
+#if defined(__cplusplus)
+	jint DestroyJavaVM() { return functions->DestroyJavaVM(this); }
+	jint AttachCurrentThread(void ** p_env, void * args) { return functions->AttachCurrentThread(this, p_env, args); }
+	jint DetachCurrentThread() { return functions->DetachCurrentThread(this); }
+	jint GetEnv(void ** p_env, jint version) { return functions->GetEnv(this, p_env, version); }
+	jint AttachCurrentThreadAsDaemon(void ** p_env, void * args) { return functions->AttachCurrentThreadAsDaemon(this, p_env, args); }
+#endif
+};
+struct JVMExtensionInterface_ {
+	char eyecatcher[4];
+	jint length;
+	jint version;
+	jint modification;
+	JavaVM *vm;
+	jint (JNICALL * ResetJavaVM)(JavaVM *vm);
+	jint (JNICALL * QueryJavaVM)(JavaVM *vm, jint nQueries, JavaVMQuery *queries);
+	jint (JNICALL * QueryGCStatus)(JavaVM *vm, jint *nheaps, GCStatus *status, jint statusSize); 
+};
+struct JVMExt_ {
+	const struct JVMExtensionInterface_ *functions;
+#if defined(__cplusplus)
+	jint ResetJavaVM() {return functions->ResetJavaVM(functions->vm);}
+	jint QueryJavaVM(jint nQueries, JavaVMQuery *queries) { return functions->QueryJavaVM(functions->vm, nQueries, queries);}
+	jint QueryGCStatus(jint *nheaps, GCStatus *status, jint statusSize){ return functions->QueryGCStatus(functions->vm, nheaps, status, statusSize); }                                                 
+#endif
+};
+#if defined(__cplusplus)
+typedef  JVMExt_ JVMExt;
+#else
+typedef const struct JVMExtensionInterface_ *JVMExt;
+#endif
+jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *);
+jint JNICALL JNI_CreateJavaVM(JavaVM **, void **, void *);
+jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
+#if defined(__cplusplus)
+}
+#endif
+#endif /* JNI_H */
+
+
+
+

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jniport.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jniport.h?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jniport.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jniport.h Wed Nov 30 21:29:27 2005
@@ -0,0 +1,44 @@
+/* Copyright 1991, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(jniport_h)
+#define jniport_h
+
+#if defined(WIN32)||(defined(_WIN32))
+#define JNIEXPORT __declspec(dllexport)
+#define JNICALL __stdcall
+
+typedef signed char jbyte;
+typedef int jint;
+typedef __int64 jlong;
+
+#else
+
+#define JNIEXPORT
+typedef signed char jbyte;
+typedef long long jlong;
+typedef int jint;
+
+#endif /* WIN32 */
+
+#if !defined(JNICALL)
+#define JNICALL
+#endif
+
+#if !defined(JNIEXPORT)
+#define JNIEXPORT
+#endif
+
+#endif /* jniport_h */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jsig.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jsig.h?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jsig.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jsig.h Wed Nov 30 21:29:27 2005
@@ -0,0 +1,45 @@
+/* Copyright 2003, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(jsig_h)
+#define jsig_h
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include <signal.h>
+
+#if defined(WIN32)
+#if !defined(JSIGDLLSPEC)
+#define JSIGDLLSPEC __declspec(dllimport)
+#endif
+typedef void (__cdecl *sig_handler_t)(int);
+JSIGDLLSPEC int jsig_handler(int sig, void *siginfo, void *uc);
+JSIGDLLSPEC sig_handler_t jsig_primary_signal(int sig, sig_handler_t disp);
+#else /* UNIX */
+typedef void (*sig_handler_t)(int);
+int jsig_handler(int sig, void *siginfo, void *uc);
+int  jsig_primary_sigaction(int sig, const struct sigaction *act, struct sigaction *oact);
+sig_handler_t jsig_primary_signal(int sig, sig_handler_t disp);
+#endif /* UNIX */
+
+#if defined(__cplusplus)
+}
+#endif
+#define JSIG_RC_DEFAULT_ACTION_REQUIRED 0
+#define JSIG_RC_SIGNAL_HANDLED 1
+
+#endif     /* jsig_h */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmpi.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmpi.h?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmpi.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmpi.h Wed Nov 30 21:29:27 2005
@@ -0,0 +1,425 @@
+/* Copyright 1991, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(jvmpi_h)
+#define jvmpi_h
+
+#include "jni.h"
+
+/* JVMPI Constants */
+#define JVMPI_VERSION_1 ((jint)0x10000001)
+#define JVMPI_VERSION_1_1 ((jint)0x10000002)
+#define JVMPI_VERSION_1_2 ((jint)0x10000003)
+#define JVMPI_VERSION_HOTSPOT ((jint)0x10000002)
+/* for compatability with older specs */
+#define JVMPI_EVENT_LOAD_COMPILED_METHOD JVMPI_EVENT_COMPILED_METHOD_LOAD
+#define JVMPI_EVENT_UNLOAD_COMPILED_METHOD JVMPI_EVENT_COMPILED_METHOD_UNLOAD
+#define JVMPI_EVENT_METHOD_ENTRY		((jint)1)
+#define JVMPI_EVENT_METHOD_ENTRY2		((jint)2)
+#define JVMPI_EVENT_METHOD_EXIT		((jint)3)
+#define JVMPI_EVENT_OBJECT_ALLOC		((jint)4)
+#define JVMPI_EVENT_OBJECT_FREE		((jint)5)
+#define JVMPI_EVENT_OBJECT_MOVE		((jint)6)
+#define JVMPI_EVENT_COMPILED_METHOD_LOAD		((jint)7)
+#define JVMPI_EVENT_COMPILED_METHOD_UNLOAD		((jint)8)
+#define JVMPI_EVENT_INSTRUCTION_START		((jint)9)		/* added in JVMPI_VERSION_1_2 */
+#define JVMPI_EVENT_UNUSED_10		((jint)10)
+#define JVMPI_EVENT_UNUSED_11		((jint)11)
+#define JVMPI_EVENT_UNUSED_12		((jint)12)
+#define JVMPI_EVENT_UNUSED_13		((jint)13)
+#define JVMPI_EVENT_UNUSED_14		((jint)14)
+#define JVMPI_EVENT_UNUSED_15		((jint)15)
+#define JVMPI_EVENT_UNUSED_16		((jint)16)
+#define JVMPI_EVENT_UNUSED_17		((jint)17)
+#define JVMPI_EVENT_UNUSED_18		((jint)18)
+#define JVMPI_EVENT_UNUSED_19		((jint)19)
+#define JVMPI_EVENT_UNUSED_20		((jint)20)
+#define JVMPI_EVENT_UNUSED_21		((jint)21)
+#define JVMPI_EVENT_UNUSED_22		((jint)22)
+#define JVMPI_EVENT_UNUSED_23		((jint)23)
+#define JVMPI_EVENT_UNUSED_24		((jint)24)
+#define JVMPI_EVENT_UNUSED_25		((jint)25)
+#define JVMPI_EVENT_UNUSED_26		((jint)26)
+#define JVMPI_EVENT_UNUSED_27		((jint)27)
+#define JVMPI_EVENT_UNUSED_28		((jint)28)
+#define JVMPI_EVENT_UNUSED_29		((jint)29)
+#define JVMPI_EVENT_UNUSED_30		((jint)30)
+#define JVMPI_EVENT_UNUSED_31		((jint)31)
+#define JVMPI_EVENT_UNUSED_32		((jint)32)
+#define JVMPI_EVENT_THREAD_START		((jint)33)
+#define JVMPI_EVENT_THREAD_END		((jint)34)
+#define JVMPI_EVENT_CLASS_LOAD_HOOK		((jint)35)
+#define JVMPI_EVENT_UNUSED_36		((jint)36)
+#define JVMPI_EVENT_HEAP_DUMP		((jint)37)
+#define JVMPI_EVENT_JNI_GLOBALREF_ALLOC		((jint)38)
+#define JVMPI_EVENT_JNI_GLOBALREF_FREE		((jint)39)
+#define JVMPI_EVENT_JNI_WEAK_GLOBALREF_ALLOC		((jint)40)
+#define JVMPI_EVENT_JNI_WEAK_GLOBALREF_FREE		((jint)41)
+#define JVMPI_EVENT_CLASS_LOAD		((jint)42)
+#define JVMPI_EVENT_CLASS_UNLOAD		((jint)43)
+#define JVMPI_EVENT_DATA_DUMP_REQUEST		((jint)44)
+#define JVMPI_EVENT_DATA_RESET_REQUEST		((jint)45)
+#define JVMPI_EVENT_JVM_INIT_DONE		((jint)46)
+#define JVMPI_EVENT_JVM_SHUT_DOWN		((jint)47)
+#define JVMPI_EVENT_ARENA_NEW		((jint)48)
+#define JVMPI_EVENT_ARENA_DELETE		((jint)49)
+#define JVMPI_EVENT_OBJECT_DUMP		((jint)50)
+#define JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTER		((jint)51)
+#define JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTERED		((jint)52)
+#define JVMPI_EVENT_RAW_MONITOR_CONTENDED_EXIT		((jint)53)
+#define JVMPI_EVENT_MONITOR_CONTENDED_ENTER		((jint)54)
+#define JVMPI_EVENT_MONITOR_CONTENDED_ENTERED		((jint)55)
+#define JVMPI_EVENT_MONITOR_CONTENDED_EXIT		((jint)56)
+#define JVMPI_EVENT_MONITOR_WAIT		((jint)57)
+#define JVMPI_EVENT_MONITOR_WAITED		((jint)58)
+#define JVMPI_EVENT_MONITOR_DUMP		((jint)59)
+#define JVMPI_EVENT_GC_START		((jint)60)
+#define JVMPI_EVENT_GC_FINISH		((jint)61)
+#define JVMPI_MAX_EVENT_TYPE_VAL		((jint)61)
+/* IBM-Specific Profiling Events */
+#define JVMPI_EVENT_DISABLE_COMPATIBILITY         ((jint )2000)
+#define JVMPI_EVENT_GEN_COMPILED_METHOD           ((jint )2001)
+#define JVMPI_EVENT_GEN_INLINE_METHOD             ((jint )2002)
+#define JVMPI_EVENT_GEN_BUILTIN_METHOD            ((jint )2003)
+#define JVMPI_EVENT_COMPILED_METHOD_ENTRY         ((jint )2004)
+#define JVMPI_EVENT_COMPILED_METHOD_ENTRY2        ((jint )2005)
+#define JVMPI_EVENT_COMPILED_METHOD_EXIT          ((jint )2006)
+#define JVMPI_EVENT_INLINE_METHOD_ENTRY           ((jint )2007)
+#define JVMPI_EVENT_INLINE_METHOD_ENTRY2          ((jint )2008)
+#define JVMPI_EVENT_BUILTIN_METHOD_ENTRY          ((jint )2009)
+#define JVMPI_EVENT_BUILTIN_METHOD_ENTRY2         ((jint )2010)
+#define JVMPI_EVENT_NATIVE_METHOD_ENTRY           ((jint )2011)
+#define JVMPI_EVENT_NATIVE_METHOD_ENTRY2          ((jint )2012)
+#define JVMPI_EVENT_COMPILING_START               ((jint )2013)
+#define JVMPI_EVENT_COMPILING_END                 ((jint )2014)
+#define JVMPI_EVENT_COMPILER_GC_START             ((jint )2015)
+#define JVMPI_EVENT_COMPILER_GC_END               ((jint )2016)
+#define JVMPI_EVENT_OBJ_ALLOC_FAILURE             ((jint )2017)
+#define JVMPI_EVENT_COMPILED_METHOD_LOAD2         ((jint )2018)
+#define JVMPI_EVENT_JLM                           ((jint )2019)
+#define JVMPI_EVENT_JLMTS                         ((jint )2020)
+#define JVMPI_EVENT_MONITOR_JLM_DUMP              ((jint )2021)
+#define JVMPI_EVENT_TRANSFER                      ((jint )2022)
+#define JVMPI_EVENT_SEGMENT                       ((jint )2023)
+#define JVMPI_MIN_IBM_INTERNAL_OPTION_VAL ((jint) 2000)
+#define JVMPI_MAX_IBM_INTERNAL_OPTION_VAL ((jint) 2023)
+#define JVMPI_REQUESTED_EVENT		((jint)0x10000000)
+#define JVMPI_SUCCESS		((jint)0)
+#define JVMPI_NOT_AVAILABLE		((jint)1)
+#define JVMPI_FAIL		((jint)-1)
+enum {
+	JVMPI_THREAD_RUNNABLE = 1,
+	JVMPI_THREAD_MONITOR_WAIT,
+	JVMPI_THREAD_CONDVAR_WAIT
+};
+#define JVMPI_THREAD_SUSPENDED		0x8000
+#define JVMPI_THREAD_INTERRUPTED		0x4000
+#define JVMPI_MINIMUM_PRIORITY		1
+#define JVMPI_MAXIMUM_PRIORITY		10
+#define JVMPI_NORMAL_PRIORITY		5
+#define JVMPI_NORMAL_OBJECT		((jint)0)
+#define JVMPI_CLASS						((jint)2)
+#define JVMPI_BOOLEAN					((jint)4)
+#define JVMPI_CHAR						((jint)5)
+#define JVMPI_FLOAT						((jint)6)
+#define JVMPI_DOUBLE					((jint)7)
+#define JVMPI_BYTE						((jint)8)
+#define JVMPI_SHORT						((jint)9)
+#define JVMPI_INT							((jint)10)
+#define JVMPI_LONG						((jint)11)    
+#define JVMPI_MONITOR_JAVA		0x01
+#define JVMPI_MONITOR_RAW		0x02
+#define JVMPI_GC_ROOT_UNKNOWN		0xff
+#define JVMPI_GC_ROOT_JNI_GLOBAL		0x01
+#define JVMPI_GC_ROOT_JNI_LOCAL		0x02
+#define JVMPI_GC_ROOT_JAVA_FRAME		0x03
+#define JVMPI_GC_ROOT_NATIVE_STACK		0x04
+#define JVMPI_GC_ROOT_STICKY_CLASS		0x05
+#define JVMPI_GC_ROOT_THREAD_BLOCK		0x06
+#define JVMPI_GC_ROOT_MONITOR_USED		0x07
+#define JVMPI_GC_ROOT_THREAD_OBJ		0x08
+#define JVMPI_GC_CLASS_DUMP		0x20
+#define JVMPI_GC_INSTANCE_DUMP		0x21 
+#define JVMPI_GC_OBJ_ARRAY_DUMP		0x22
+#define JVMPI_GC_PRIM_ARRAY_DUMP		0x23
+#define JVMPI_DUMP_LEVEL_0		((jint)0)
+#define JVMPI_DUMP_LEVEL_1		((jint)1)
+#define JVMPI_DUMP_LEVEL_2		((jint)2)
+/* JLM monitor dump */
+#define JVMPI_DUMP_LEVEL_3		((jint)3)
+/* generic_event.flags */
+#define JVMPI_GENERIC_FLAG_DISABLE_GC	((jint)1)
+#define JVMPI_GENERIC_FLAG_CHECK_EVENT	((jint)2)
+/* generic_compiled_method_load.ld_ind */
+#define JVMPI_LOAD			((jint)1)
+#define JVMPI_UNLOAD			((jint)2)
+/* generic_compiled_method_load.edesc */
+#define JVMPI_NAME_FORMAT		((jint)1)
+/* generic_transfer_event.transfer_type */
+#define JVMPI_TRANSFER_ITOJ		((jint)1)
+/* generic_transfer_event.transfer_status */
+#define JVMPI_TRANSFER_OK		((jint)1)
+#define JVMPI_TRANSFER_FAIL		((jint)2)
+/* generic_segment_event.seg_type */
+#define JVMPI_JITTED_SEGMENT		((jint)1)
+#define JVMPI_MMI_SEGMENT		((jint)2)
+/* generic_segment_event.alloc_ind */
+#define JVMPI_SEGMENT_ALLOCATE		((jint)1)
+#define JVMPI_SEGMENT_FREE		((jint)2)
+/* jobjectID */
+struct _jobjectID;
+typedef struct _jobjectID *jobjectID;
+/* JVMPI_RawMonitor */
+struct _JVMPI_RawMonitor;
+typedef struct _JVMPI_RawMonitor * JVMPI_RawMonitor;
+/* JVMPI_CallFrame */
+typedef struct {
+	jint lineno;
+	jmethodID method_id;
+} JVMPI_CallFrame;
+/* JVMPI_CallTrace */
+typedef struct {
+	JNIEnv *env_id;
+	jint num_frames;
+	JVMPI_CallFrame *frames;
+} JVMPI_CallTrace;
+/* JVMPI_Field */
+typedef struct {
+	char *field_name;
+	char *field_signature;
+} JVMPI_Field;
+/* JVMPI_HeapDumpArg */
+typedef struct {
+	jint heap_dump_level;
+} JVMPI_HeapDumpArg;
+/* JVMPI_Lineno */
+typedef struct {
+	jint offset;
+	jint lineno;
+} JVMPI_Lineno;
+/* JVMPI_Method */
+typedef struct {
+	char *method_name;
+	char *method_signature;
+	jint start_lineno;
+	jint end_lineno;
+	jmethodID method_id;
+} JVMPI_Method;
+/* JVMPI Event */
+typedef struct {
+	jint event_type;
+	JNIEnv *env_id;
+	union {
+		struct {
+			jint arena_id;
+		} delete_arena;
+		struct {
+			jint arena_id;
+			char *arena_name;
+		} new_arena;
+		
+		struct {
+			char *class_name;
+			char *source_name;
+			jint num_interfaces;
+			jint num_methods;
+			JVMPI_Method *methods;
+			jint num_static_fields;
+			JVMPI_Field *statics;
+			jint num_instance_fields;
+			JVMPI_Field *instances;
+			jobjectID class_id;
+		} class_load;
+		struct {
+			unsigned char *class_data;
+			jint class_data_len;
+			unsigned char *new_class_data;
+			jint new_class_data_len;
+			void * (*malloc_f)(unsigned int);
+		} class_load_hook;
+		struct {
+			jobjectID class_id;
+		} class_unload;
+		struct {
+			jmethodID method_id;
+			void *code_addr;
+			jint code_size;
+			jint lineno_table_size;
+			JVMPI_Lineno *lineno_table;
+		} compiled_method_load;
+		struct {
+			jmethodID method_id;
+		} compiled_method_unload;
+		struct {
+			jlong used_objects;
+			jlong used_object_space;
+			jlong total_object_space;
+		} gc_info;
+		struct {
+			int dump_level;
+			char *begin;
+			char *end;
+			jint num_traces;
+			JVMPI_CallTrace *traces;
+		} heap_dump;
+		struct {
+			jobjectID obj_id;
+			jobject ref_id;
+		} jni_globalref_alloc;
+		struct {
+			jobject ref_id;
+		} jni_globalref_free;
+		struct {
+			jmethodID method_id;
+		} method;
+		struct {
+			jmethodID method_id;
+			jobjectID obj_id;
+		} method_entry2;
+		struct {
+			jobjectID object;
+		} monitor;
+		struct {
+			char *begin;
+			char *end;
+			jint num_traces;
+			JVMPI_CallTrace *traces;
+			jint *threads_status;
+		} monitor_dump;
+		struct {
+			jobjectID object;
+			jlong timeout;
+		} monitor_wait;
+		struct {
+			jint arena_id;
+			jobjectID class_id;
+			jint is_array;
+			jint size;
+			jobjectID obj_id;
+		} obj_alloc;
+		struct {
+			jint data_len;
+			char *data;
+		} object_dump;
+		struct {
+			jobjectID obj_id;
+		} obj_free;
+		struct {
+			jint arena_id;
+			jobjectID obj_id;
+			jint new_arena_id;
+			jobjectID new_obj_id;
+		} obj_move;
+		struct {
+			char *name;
+			JVMPI_RawMonitor id;
+		} raw_monitor;
+		struct {
+			char *thread_name;
+			char *group_name;
+			char *parent_name;
+			jobjectID thread_id;
+			JNIEnv *thread_env_id;
+		} thread_start;
+		struct {
+			jmethodID method_id;
+			jobjectID obj_id;
+			jsize flags;
+			jint reserv1;
+			jint reserv2;
+			jint reserv3;
+			jint reserv4;
+			jint reserv5;
+			jint reserv6;
+			jint reserv7;
+			jint reserv8;
+		} generic_event; 
+		struct {
+			jmethodID method_id;
+			jobjectID obj_id;
+			jsize flags;
+			char *code_name;
+			jint edesc;
+			jint ld_ind;
+			void *code_addr;
+			jint code_size;
+			jint lineno_table_size;
+			JVMPI_Lineno *lineno_table;
+		} generic_compiled_method_load;
+		struct {
+			jmethodID method_id;
+			jobjectID obj_id;
+			jsize flags;
+			jint transfer_type;
+			jint transfer_status;
+			jint reserv3;
+			jint reserv4;
+			jint reserv5;
+			jint reserv6;
+			jint reserv7;
+			jint reserv8;
+		} generic_transfer_event;
+		struct {
+			jmethodID method_id;
+			jobjectID obj_id;
+			jsize flags;
+			char *seg_name;
+			void *seg_addr;
+			jsize seg_size;
+			jint seg_type;
+			jint alloc_ind;
+			void *old_seg_addr;
+			jint reserv7;
+			jint reserv8;
+		} generic_segment_event; 
+	} u;
+} JVMPI_Event;
+
+typedef struct {
+	jint version;
+	void (*NotifyEvent)(JVMPI_Event *event);
+	jint (*EnableEvent) (jint event_type, void *arg);
+	jint (*DisableEvent) (jint event_type, void *arg);
+	jint (*RequestEvent) (jint event_type, void *arg);
+	void (*GetCallTrace) (JVMPI_CallTrace *trace, jint depth);
+	void (*ProfilerExit) (jint);
+	JVMPI_RawMonitor (*RawMonitorCreate) (char *lock_name);
+	void (*RawMonitorEnter) (JVMPI_RawMonitor lock_id);
+	void (*RawMonitorExit) (JVMPI_RawMonitor lock_id);
+	void (*RawMonitorWait) (JVMPI_RawMonitor lock_id, jlong ms);
+	void (*RawMonitorNotifyAll) (JVMPI_RawMonitor lock_id);
+	void (*RawMonitorDestroy) (JVMPI_RawMonitor lock_id);
+	jlong (*GetCurrentThreadCpuTime) (void);
+	void (*SuspendThread) (JNIEnv *env);
+	void (*ResumeThread) (JNIEnv *env);
+	jint (*GetThreadStatus) (JNIEnv *env);
+	jboolean (*ThreadHasRun) (JNIEnv *env);
+	jint (*CreateSystemThread) (char *name, jint priority, void (*f)(void *));
+	void (*SetThreadLocalStorage) (JNIEnv *env_id, void *ptr);
+	void * (*GetThreadLocalStorage) (JNIEnv *env_id);
+	void (*DisableGC) (void);
+	void (*EnableGC) (void);
+	void (*RunGC) (void);
+	jobjectID (*GetThreadObject) (JNIEnv *env);
+	jobjectID (*GetMethodClass) (jmethodID mid);
+	/* JVMPI_VERSION_1_1 additions */
+	jobject   (*jobjectID2jobject)(jobjectID jid);
+	jobjectID (*jobject2jobjectID)(jobject j);
+	/* JVMPI_VERSION_1_2 additions */
+	void (*SuspendThreadList)(jint reqCount, JNIEnv **reqList, jint *results);
+	void (*ResumeThreadList)(jint reqCount, JNIEnv **reqList, jint *results);
+} JVMPI_Interface;
+
+#endif     /* jvmpi_h */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmri.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmri.h?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmri.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/include/jvmri.h Wed Nov 30 21:29:27 2005
@@ -0,0 +1,153 @@
+/* Copyright 1991, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(_JVMRAS_H_)
+#define _JVMRAS_H_
+/*
+ * ======================================================================
+ * Allow for inclusion in C++
+ * ======================================================================
+ */
+#if defined(__cplusplus)
+extern "C" {
+#endif
+#include "jni.h"
+#include "stdarg.h"
+/*
+ * ======================================================================
+ * Forward declarations
+ * ======================================================================
+ */
+typedef void (JNICALL *TraceListener)(JNIEnv *env, void **thrLocal, int traceId,
+						  const char * format, va_list varargs); 
+typedef void (*DgRasOutOfMemoryHook)(void); 
+/*
+ * ======================================================================
+ * RasInfo structures
+ * ======================================================================
+ */
+typedef struct RasInfo {
+	int  type;
+	union {
+		struct {
+			int    number;
+			char **names;
+		} query;
+		struct {
+			int    number;
+			char **names;
+		} trace_components;
+		struct {
+			char          *name;
+			int            first;
+			int            last;
+			unsigned char *bitMap;
+		} trace_component;
+	} info;
+} RasInfo;
+#define RASINFO_TYPES               				0
+#define RASINFO_TRACE_COMPONENTS    	1
+#define RASINFO_TRACE_COMPONENT     	2
+#define RASINFO_MAX_TYPES           			2
+/*
+ * ======================================================================
+ * External access facade
+ * ======================================================================
+ */
+#define JVMRAS_VERSION_1_1      0x7F000001
+#define JVMRAS_VERSION_1_3      0x7F000003
+typedef struct DgRasInterface {
+	char    eyecatcher[4];
+	int     length;
+	int     version;
+	int     modification;
+	/* Interface level 1_1 */
+	int     (JNICALL *TraceRegister)(JNIEnv *env, TraceListener func);
+	int     (JNICALL *TraceDeregister)(JNIEnv *env, TraceListener func);
+	int     (JNICALL *TraceSet)(JNIEnv *env, const char *);
+	void    (JNICALL *TraceSnap)(JNIEnv *env, char *);
+	void    (JNICALL *TraceSuspend)(JNIEnv *env);
+	void    (JNICALL *TraceResume)(JNIEnv *env);
+	int     (JNICALL *GetRasInfo)(JNIEnv * env, RasInfo * info_ptr);
+	int     (JNICALL *ReleaseRasInfo)(JNIEnv * env, RasInfo * info_ptr);
+	int     (JNICALL *DumpRegister)(JNIEnv *env,
+									int (JNICALL *func)(JNIEnv *env2,
+														void **threadLocal,
+														int reason));
+	int     (JNICALL *DumpDeregister)(JNIEnv *env,
+									  int (JNICALL *func)(JNIEnv *env2,
+														  void **threadLocal,
+														  int reason));
+	void    (JNICALL *NotifySignal)(JNIEnv *env, int signal);
+	int     (JNICALL *CreateThread)( JNIEnv *env, void (JNICALL *startFunc)(void*),
+										void *args, int GCSuspend );
+	int     (JNICALL *GenerateJavacore)( JNIEnv *env );
+	int     (JNICALL *RunDumpRoutine)( JNIEnv *env, int componentID, int level,
+									   void (*printrtn)(void *env, const char *tagName,
+														const char *fmt, ...) );
+	int     (JNICALL *InjectSigsegv)( JNIEnv *env );
+	int     (JNICALL *InjectOutOfMemory)( JNIEnv *env );
+	int     (JNICALL *SetOutOfMemoryHook)( JNIEnv *env, void (*OutOfMemoryFunc)(void) );
+	int     (JNICALL *GetComponentDataArea)( JNIEnv *env, char *componentName,
+											   void **dataArea, int *dataSize );
+	int     (JNICALL *InitiateSystemDump)( JNIEnv *env );
+	/* Interface level 1_3 follows */
+	void        (JNICALL *DynamicVerbosegc) (JNIEnv *env, int vgc_switch,
+											int vgccon, char* file_path,
+											int number_of_files,
+											int number_of_cycles);
+	void    (JNICALL *TraceSuspendThis)(JNIEnv *env);
+	void    (JNICALL *TraceResumeThis)(JNIEnv *env);
+	int     (JNICALL *GenerateHeapdump)( JNIEnv *env );
+} DgRasInterface;
+/*
+ * ======================================================================
+ *    Dump exit return codes
+ * ======================================================================
+ */
+#define RAS_DUMP_CONTINUE   	0		/* Continue with diagnostic collection */
+#define RAS_DUMP_ABORT      		1		/* No more diagnostics should be taken */
+/*
+ * ======================================================================
+ *    Thread Creation types
+ * ======================================================================
+ */
+#define NO_GC_THREAD_SUSPEND		0       /* Do not suspend thread during CG. */
+#define GC_THREAD_SUSPEND       		1       /* Suspend thread during CG. */
+#define RAS_THREAD_NAME_SIZE    	50     /* Size of Ras Thread Name. */
+/*
+ * ======================================================================
+ *    Dump Handler types
+ * ======================================================================
+ */
+enum dumpType {
+	 NODUMPS      = 0,
+	 JAVADUMP     = 0x01,
+	 SYSDUMP      = 0x02,
+	 CEEDUMP      = 0x04,
+	 HEAPDUMP     = 0x08,
+	 MAXDUMPTYPES = 6,
+	/* ensure 4-byte enum */
+	dumpTypeEnsureWideEnum = 0x1000000
+};
+#define ALLDUMPS (JAVADUMP | SYSDUMP | CEEDUMP | HEAPDUMP)
+#define OSDUMP     (ALLDUMPS + 1)
+#if defined(__cplusplus)
+} /* extern "C" */
+#endif
+#endif /* !_JVMRAS_H_ */
+
+
+



Mime
View raw message