You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by ge...@apache.org on 2005/12/01 07:04:00 UTC
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....
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_ */
+
+
+