Imported Upstream version 2.1.8.20120216upstream/2.1.8.20120216

6 files changed, 3950 insertions, 0 deletions

diff --git a/include/jni/jawt.h b/include/jni/jawt.h
new file mode 100644
index 0000000..b52cfcf
--- /dev/null
+++ b/include/jni/jawt.h
@@ -0,0 +1,278 @@
+/*
+ * @(#)jawt.h	1.9 03/01/23
+ *
+ * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JAWT_H_
+#define _JAVASOFT_JAWT_H_
+
+#include "jni.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * AWT native interface (new in JDK 1.3)
+ *
+ * The AWT native interface allows a native C or C++ application a means
+ * by which to access native structures in AWT.  This is to facilitate moving
+ * legacy C and C++ applications to Java and to target the needs of the
+ * community who, at present, wish to do their own native rendering to canvases
+ * for performance reasons.  Standard extensions such as Java3D also require a
+ * means to access the underlying native data structures of AWT.
+ *
+ * There may be future extensions to this API depending on demand.
+ *
+ * A VM does not have to implement this API in order to pass the JCK.
+ * It is recommended, however, that this API is implemented on VMs that support
+ * standard extensions, such as Java3D.
+ *
+ * Since this is a native API, any program which uses it cannot be considered
+ * 100% pure java.
+ */
+
+/*
+ * AWT Native Drawing Surface (JAWT_DrawingSurface).
+ *
+ * For each platform, there is a native drawing surface structure.  This
+ * platform-specific structure can be found in jawt_md.h.  It is recommended
+ * that additional platforms follow the same model.  It is also recommended
+ * that VMs on Win32 and Solaris support the existing structures in jawt_md.h.
+ *
+ *******************
+ * EXAMPLE OF USAGE:
+ *******************
+ *
+ * In Win32, a programmer wishes to access the HWND of a canvas to perform
+ * native rendering into it.  The programmer has declared the paint() method
+ * for their canvas subclass to be native:
+ *
+ *
+ * MyCanvas.java:
+ *
+ * import java.awt.*;
+ *
+ * public class MyCanvas extends Canvas {
+ *
+ *     static {
+ *         System.loadLibrary("mylib");
+ *     }
+ *
+ *     public native void paint(Graphics g);
+ * }
+ *
+ *
+ * myfile.c:
+ *
+ * #include "jawt_md.h"
+ * #include <assert.h>
+ *
+ * JNIEXPORT void JNICALL
+ * Java_MyCanvas_paint(JNIEnv* env, jobject canvas, jobject graphics)
+ * {
+ *     JAWT awt;
+ *     JAWT_DrawingSurface* ds;
+ *     JAWT_DrawingSurfaceInfo* dsi;
+ *     JAWT_Win32DrawingSurfaceInfo* dsi_win;
+ *     jboolean result;
+ *     jint lock;
+ *
+ *     // Get the AWT
+ *     awt.version = JAWT_VERSION_1_3;
+ *     result = JAWT_GetAWT(env, &awt);
+ *     assert(result != JNI_FALSE);
+ *
+ *     // Get the drawing surface
+ *     ds = awt.GetDrawingSurface(env, canvas);
+ *     assert(ds != NULL);
+ *
+ *     // Lock the drawing surface
+ *     lock = ds->Lock(ds);
+ *     assert((lock & JAWT_LOCK_ERROR) == 0);
+ *
+ *     // Get the drawing surface info
+ *     dsi = ds->GetDrawingSurfaceInfo(ds);
+ *
+ *     // Get the platform-specific drawing info
+ *     dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;
+ *
+ *     //////////////////////////////
+ *     // !!! DO PAINTING HERE !!! //
+ *     //////////////////////////////
+ *
+ *     // Free the drawing surface info
+ *     ds->FreeDrawingSurfaceInfo(dsi);
+ *
+ *     // Unlock the drawing surface
+ *     ds->Unlock(ds);
+ *
+ *     // Free the drawing surface
+ *     awt.FreeDrawingSurface(ds);
+ * }
+ *
+ */
+
+/*
+ * JAWT_Rectangle
+ * Structure for a native rectangle.
+ */
+typedef struct jawt_Rectangle {
+    jint x;
+    jint y;
+    jint width;
+    jint height;
+} JAWT_Rectangle;
+
+struct jawt_DrawingSurface;
+
+/*
+ * JAWT_DrawingSurfaceInfo
+ * Structure for containing the underlying drawing information of a component.
+ */
+typedef struct jawt_DrawingSurfaceInfo {
+    /*
+     * Pointer to the platform-specific information.  This can be safely
+     * cast to a JAWT_Win32DrawingSurfaceInfo on Windows or a
+     * JAWT_X11DrawingSurfaceInfo on Solaris.  See jawt_md.h for details.
+     */
+    void* platformInfo;
+    /* Cached pointer to the underlying drawing surface */
+    struct jawt_DrawingSurface* ds;
+    /* Bounding rectangle of the drawing surface */
+    JAWT_Rectangle bounds;
+    /* Number of rectangles in the clip */
+    jint clipSize;
+    /* Clip rectangle array */
+    JAWT_Rectangle* clip;
+} JAWT_DrawingSurfaceInfo;
+
+#define JAWT_LOCK_ERROR                 0x00000001
+#define JAWT_LOCK_CLIP_CHANGED          0x00000002
+#define JAWT_LOCK_BOUNDS_CHANGED        0x00000004
+#define JAWT_LOCK_SURFACE_CHANGED       0x00000008
+
+/*
+ * JAWT_DrawingSurface
+ * Structure for containing the underlying drawing information of a component.
+ * All operations on a JAWT_DrawingSurface MUST be performed from the same
+ * thread as the call to GetDrawingSurface.
+ */
+typedef struct jawt_DrawingSurface {
+    /*
+     * Cached reference to the Java environment of the calling thread.
+     * If Lock(), Unlock(), GetDrawingSurfaceInfo() or
+     * FreeDrawingSurfaceInfo() are called from a different thread,
+     * this data member should be set before calling those functions.
+     */
+    JNIEnv* env;
+    /* Cached reference to the target object */
+    jobject target;
+    /*
+     * Lock the surface of the target component for native rendering.
+     * When finished drawing, the surface must be unlocked with
+     * Unlock().  This function returns a bitmask with one or more of the
+     * following values:
+     *
+     * JAWT_LOCK_ERROR - When an error has occurred and the surface could not
+     * be locked.
+     *
+     * JAWT_LOCK_CLIP_CHANGED - When the clip region has changed.
+     *
+     * JAWT_LOCK_BOUNDS_CHANGED - When the bounds of the surface have changed.
+     *
+     * JAWT_LOCK_SURFACE_CHANGED - When the surface itself has changed
+     */
+    jint (JNICALL *Lock)
+        (struct jawt_DrawingSurface* ds);
+    /*
+     * Get the drawing surface info.
+     * The value returned may be cached, but the values may change if
+     * additional calls to Lock() or Unlock() are made.
+     * Lock() must be called before this can return a valid value.
+     * Returns NULL if an error has occurred.
+     * When finished with the returned value, FreeDrawingSurfaceInfo must be
+     * called.
+     */
+    JAWT_DrawingSurfaceInfo* (JNICALL *GetDrawingSurfaceInfo)
+        (struct jawt_DrawingSurface* ds);
+    /*
+     * Free the drawing surface info.
+     */
+    void (JNICALL *FreeDrawingSurfaceInfo)
+        (JAWT_DrawingSurfaceInfo* dsi);
+    /* 
+     * Unlock the drawing surface of the target component for native rendering.
+     */
+    void (JNICALL *Unlock)
+        (struct jawt_DrawingSurface* ds);
+} JAWT_DrawingSurface;
+
+/*
+ * JAWT
+ * Structure for containing native AWT functions.
+ */
+typedef struct jawt {
+    /*
+     * Version of this structure.  This must always be set before
+     * calling JAWT_GetAWT()
+     */
+    jint version;
+    /*
+     * Return a drawing surface from a target jobject.  This value
+     * may be cached.
+     * Returns NULL if an error has occurred.
+     * Target must be a java.awt.Component (should be a Canvas
+     * or Window for native rendering).
+     * FreeDrawingSurface() must be called when finished with the
+     * returned JAWT_DrawingSurface.
+     */
+    JAWT_DrawingSurface* (JNICALL *GetDrawingSurface)
+        (JNIEnv* env, jobject target);
+    /*
+     * Free the drawing surface allocated in GetDrawingSurface.
+     */
+    void (JNICALL *FreeDrawingSurface)
+        (JAWT_DrawingSurface* ds);
+    /*
+     * Since 1.4
+     * Locks the entire AWT for synchronization purposes
+     */
+    void (JNICALL *Lock)(JNIEnv* env);
+    /*
+     * Since 1.4
+     * Unlocks the entire AWT for synchronization purposes
+     */
+    void (JNICALL *Unlock)(JNIEnv* env);
+    /*
+     * Since 1.4
+     * Returns a reference to a java.awt.Component from a native
+     * platform handle.  On Windows, this corresponds to an HWND;
+     * on Solaris and Linux, this is a Drawable.  For other platforms,
+     * see the appropriate machine-dependent header file for a description.
+     * The reference returned by this function is a local
+     * reference that is only valid in this environment.
+     * This function returns a NULL reference if no component could be
+     * found with matching platform information.
+     */
+    jobject (JNICALL *GetComponent)(JNIEnv* env, void* platformInfo);
+
+} JAWT;
+
+/*
+ * Get the AWT native structure.  This function returns JNI_FALSE if
+ * an error occurs.
+ */
+_JNI_IMPORT_OR_EXPORT_
+jboolean JNICALL JAWT_GetAWT(JNIEnv* env, JAWT* awt);
+
+#define JAWT_VERSION_1_3 0x00010003
+#define JAWT_VERSION_1_4 0x00010004
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* !_JAVASOFT_JAWT_H_ */
diff --git a/include/jni/jni.h b/include/jni/jni.h
new file mode 100644
index 0000000..aaabe47
--- /dev/null
+++ b/include/jni/jni.h
@@ -0,0 +1,1951 @@
+/*
+ * @(#)jni.h	1.55 03/01/23
+ *
+ * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+/*
+ * We used part of Netscape's Java Runtime Interface (JRI) as the starting
+ * point of our design and implementation.
+ */
+
+/******************************************************************************
+ * Java Runtime Interface
+ * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
+ *****************************************************************************/
+
+#ifndef _JAVASOFT_JNI_H_
+#define _JAVASOFT_JNI_H_
+
+#include <stdio.h>
+#include <stdarg.h>
+
+/* jni_md.h contains the machine-dependent typedefs for jbyte, jint
+   and jlong */
+
+#include "jni_md.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * JNI Types
+ */
+
+#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
+
+typedef unsigned char	jboolean;
+typedef unsigned short	jchar;
+typedef short		jshort;
+typedef float		jfloat;
+typedef double		jdouble;
+
+typedef jint            jsize;
+
+#ifdef __cplusplus
+
+class _jobject {};
+class _jclass : public _jobject {};
+class _jthrowable : public _jobject {};
+class _jstring : public _jobject {};
+class _jarray : public _jobject {};
+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 {};
+class _jobjectArray : public _jarray {};
+
+typedef _jobject *jobject;
+typedef _jclass *jclass;
+typedef _jthrowable *jthrowable;
+typedef _jstring *jstring;
+typedef _jarray *jarray;
+typedef _jbooleanArray *jbooleanArray;
+typedef _jbyteArray *jbyteArray;
+typedef _jcharArray *jcharArray;
+typedef _jshortArray *jshortArray;
+typedef _jintArray *jintArray;
+typedef _jlongArray *jlongArray;
+typedef _jfloatArray *jfloatArray;
+typedef _jdoubleArray *jdoubleArray;
+typedef _jobjectArray *jobjectArray;
+
+#else
+
+struct _jobject;
+
+typedef struct _jobject *jobject;
+typedef jobject jclass;
+typedef jobject jthrowable;
+typedef jobject jstring;
+typedef jobject jarray;
+typedef jarray jbooleanArray;
+typedef jarray jbyteArray;
+typedef jarray jcharArray;
+typedef jarray jshortArray;
+typedef jarray jintArray;
+typedef jarray jlongArray;
+typedef jarray jfloatArray;
+typedef jarray jdoubleArray;
+typedef jarray jobjectArray;
+
+#endif
+
+typedef jobject jweak;
+
+typedef union jvalue {
+    jboolean z;
+    jbyte    b;
+    jchar    c;
+    jshort   s;
+    jint     i;
+    jlong    j;
+    jfloat   f;
+    jdouble  d;
+    jobject  l;
+} jvalue;
+
+struct _jfieldID;
+typedef struct _jfieldID *jfieldID;
+
+struct _jmethodID;
+typedef struct _jmethodID *jmethodID;
+
+#endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
+
+/*
+ * jboolean constants
+ */
+
+#define JNI_FALSE 0
+#define JNI_TRUE 1
+
+/*
+ * possible return values for JNI functions.
+ */
+
+#define JNI_OK           0                 /* success */
+#define JNI_ERR          (-1)              /* unknown error */
+#define JNI_EDETACHED    (-2)              /* thread detached from the VM */
+#define JNI_EVERSION     (-3)              /* JNI version error */
+#define JNI_ENOMEM       (-4)              /* not enough memory */
+#define JNI_EEXIST       (-5)              /* VM already created */
+#define JNI_EINVAL       (-6)              /* invalid arguments */
+
+/*
+ * used in ReleaseScalarArrayElements
+ */
+
+#define JNI_COMMIT 1
+#define JNI_ABORT 2
+
+/*
+ * used in RegisterNatives to describe native method name, signature,
+ * and function pointer.
+ */
+
+typedef struct {
+    char *name;
+    char *signature;
+    void *fnPtr;
+} JNINativeMethod;
+
+/*
+ * JNI Native Method Interface.
+ */
+
+struct JNINativeInterface_;
+
+struct JNIEnv_;
+
+#ifdef __cplusplus
+typedef JNIEnv_ JNIEnv;
+#else
+typedef const struct JNINativeInterface_ *JNIEnv;
+#endif
+
+/*
+ * JNI Invocation Interface.
+ */
+
+struct JNIInvokeInterface_;
+
+struct JavaVM_;
+
+#ifdef __cplusplus
+typedef JavaVM_ JavaVM;
+#else
+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 len);
+    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 sub);
+    jboolean (JNICALL *IsAssignableFrom)
+      (JNIEnv *env, jclass sub, jclass sup);
+
+    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 *msg);
+    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 lobj);
+    void (JNICALL *DeleteGlobalRef)
+      (JNIEnv *env, jobject gref);
+    void (JNICALL *DeleteLocalRef)
+      (JNIEnv *env, jobject obj);
+    jboolean (JNICALL *IsSameObject)
+      (JNIEnv *env, jobject obj1, jobject obj2);
+    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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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,
+       const 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,
+       const 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,
+       const 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,
+       const 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,
+       const 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,
+       const 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,
+       const 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,
+       const 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,
+       const 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,
+       const 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 val);
+    void (JNICALL *SetBooleanField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
+    void (JNICALL *SetByteField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
+    void (JNICALL *SetCharField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
+    void (JNICALL *SetShortField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
+    void (JNICALL *SetIntField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
+    void (JNICALL *SetLongField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
+    void (JNICALL *SetFloatField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
+    void (JNICALL *SetDoubleField)
+      (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
+
+    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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const jvalue *args);
+
+    void (JNICALL *CallStaticVoidMethod)
+      (JNIEnv *env, jclass cls, jmethodID methodID, ...);
+    void (JNICALL *CallStaticVoidMethodV)
+      (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
+    void (JNICALL *CallStaticVoidMethodA)
+      (JNIEnv *env, jclass cls, jmethodID methodID, const 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 *unicode, jsize len);
+    jsize (JNICALL *GetStringLength)
+      (JNIEnv *env, jstring str);
+    const jchar *(JNICALL *GetStringChars)
+      (JNIEnv *env, jstring str, jboolean *isCopy);
+    void (JNICALL *ReleaseStringChars)
+      (JNIEnv *env, jstring str, const jchar *chars);
+
+    jstring (JNICALL *NewStringUTF)
+      (JNIEnv *env, const char *utf);
+    jsize (JNICALL *GetStringUTFLength)
+      (JNIEnv *env, jstring str);
+    const char* (JNICALL *GetStringUTFChars)
+      (JNIEnv *env, jstring str, jboolean *isCopy);
+    void (JNICALL *ReleaseStringUTFChars)
+      (JNIEnv *env, jstring str, const char* chars);
+
+
+    jsize (JNICALL *GetArrayLength)
+      (JNIEnv *env, jarray array);
+
+    jobjectArray (JNICALL *NewObjectArray)
+      (JNIEnv *env, jsize len, jclass clazz, jobject init);
+    jobject (JNICALL *GetObjectArrayElement)
+      (JNIEnv *env, jobjectArray array, jsize index);
+    void (JNICALL *SetObjectArrayElement)
+      (JNIEnv *env, jobjectArray array, jsize index, jobject val);
+
+    jbooleanArray (JNICALL *NewBooleanArray)
+      (JNIEnv *env, jsize len);
+    jbyteArray (JNICALL *NewByteArray)
+      (JNIEnv *env, jsize len);
+    jcharArray (JNICALL *NewCharArray)
+      (JNIEnv *env, jsize len);
+    jshortArray (JNICALL *NewShortArray)
+      (JNIEnv *env, jsize len);
+    jintArray (JNICALL *NewIntArray)
+      (JNIEnv *env, jsize len);
+    jlongArray (JNICALL *NewLongArray)
+      (JNIEnv *env, jsize len);
+    jfloatArray (JNICALL *NewFloatArray)
+      (JNIEnv *env, jsize len);
+    jdoubleArray (JNICALL *NewDoubleArray)
+      (JNIEnv *env, jsize len);
+
+    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 l, 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 l, const jboolean *buf);
+    void (JNICALL *SetByteArrayRegion)
+      (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf);
+    void (JNICALL *SetCharArrayRegion)
+      (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf);
+    void (JNICALL *SetShortArrayRegion)
+      (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf);
+    void (JNICALL *SetIntArrayRegion)
+      (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf);
+    void (JNICALL *SetLongArrayRegion)
+      (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf);
+    void (JNICALL *SetFloatArrayRegion)
+      (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf);
+    void (JNICALL *SetDoubleArrayRegion)
+      (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const 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);
+
+    const jchar * (JNICALL *GetStringCritical)
+      (JNIEnv *env, jstring string, jboolean *isCopy);
+    void (JNICALL *ReleaseStringCritical)
+      (JNIEnv *env, jstring string, const jchar *cstring);
+
+    jweak (JNICALL *NewWeakGlobalRef)
+       (JNIEnv *env, jobject obj);
+    void (JNICALL *DeleteWeakGlobalRef)
+       (JNIEnv *env, jweak ref);
+
+    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);
+};
+
+/*
+ * We use inlined functions for C++ so that programmers can write:
+ *
+ *    env->FindClass("java/lang/String")
+ *
+ * in C++ rather than:
+ *
+ *    (*env)->FindClass(env, "java/lang/String")
+ *
+ * in C.
+ */
+
+struct JNIEnv_ {
+    const struct JNINativeInterface_ *functions;
+#ifdef __cplusplus
+
+    jint GetVersion() {
+        return functions->GetVersion(this);
+    }
+    jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
+		       jsize len) {
+        return functions->DefineClass(this, name, loader, buf, len);
+    }
+    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 sub) {
+        return functions->GetSuperclass(this, sub);
+    }
+    jboolean IsAssignableFrom(jclass sub, jclass sup) {
+        return functions->IsAssignableFrom(this, sub, sup);
+    }
+
+    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 *msg) {
+        return functions->ThrowNew(this, clazz, msg);
+    }
+    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 lobj) {
+        return functions->NewGlobalRef(this,lobj);
+    }
+    void DeleteGlobalRef(jobject gref) {
+        functions->DeleteGlobalRef(this,gref);
+    }
+    void DeleteLocalRef(jobject obj) {
+        functions->DeleteLocalRef(this, obj);
+    }
+
+    jboolean IsSameObject(jobject obj1, jobject obj2) {
+        return functions->IsSameObject(this,obj1,obj2);
+    }
+
+    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, ...) {
+        va_list args;
+	jobject result;
+	va_start(args, methodID);
+        result = functions->NewObjectV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jobject NewObjectV(jclass clazz, jmethodID methodID,
+		       va_list args) {
+        return functions->NewObjectV(this,clazz,methodID,args);
+    }
+    jobject NewObjectA(jclass clazz, jmethodID methodID,
+		       const 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, ...) {
+        va_list args;
+	jobject result;
+	va_start(args,methodID);
+	result = functions->CallObjectMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jobject CallObjectMethodV(jobject obj, jmethodID methodID,
+			va_list args) {
+        return functions->CallObjectMethodV(this,obj,methodID,args);
+    }
+    jobject CallObjectMethodA(jobject obj, jmethodID methodID,
+			const jvalue * args) {
+        return functions->CallObjectMethodA(this,obj,methodID,args);
+    }
+
+    jboolean CallBooleanMethod(jobject obj,
+			       jmethodID methodID, ...) {
+        va_list args;
+	jboolean result;
+	va_start(args,methodID);
+	result = functions->CallBooleanMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
+				va_list args) {
+        return functions->CallBooleanMethodV(this,obj,methodID,args);
+    }
+    jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
+				const jvalue * args) {
+        return functions->CallBooleanMethodA(this,obj,methodID, args);
+    }
+
+    jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	jbyte result;
+	va_start(args,methodID);
+	result = functions->CallByteMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jbyte CallByteMethodV(jobject obj, jmethodID methodID,
+			  va_list args) {
+        return functions->CallByteMethodV(this,obj,methodID,args);
+    }
+    jbyte CallByteMethodA(jobject obj, jmethodID methodID,
+			  const jvalue * args) {
+        return functions->CallByteMethodA(this,obj,methodID,args);
+    }
+
+    jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	jchar result;
+	va_start(args,methodID);
+	result = functions->CallCharMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jchar CallCharMethodV(jobject obj, jmethodID methodID,
+			  va_list args) {
+        return functions->CallCharMethodV(this,obj,methodID,args);
+    }
+    jchar CallCharMethodA(jobject obj, jmethodID methodID,
+			  const jvalue * args) {
+        return functions->CallCharMethodA(this,obj,methodID,args);
+    }
+
+    jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	jshort result;
+	va_start(args,methodID);
+	result = functions->CallShortMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jshort CallShortMethodV(jobject obj, jmethodID methodID,
+			    va_list args) {
+        return functions->CallShortMethodV(this,obj,methodID,args);
+    }
+    jshort CallShortMethodA(jobject obj, jmethodID methodID,
+			    const jvalue * args) {
+        return functions->CallShortMethodA(this,obj,methodID,args);
+    }
+
+    jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	jint result;
+	va_start(args,methodID);
+	result = functions->CallIntMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jint CallIntMethodV(jobject obj, jmethodID methodID,
+			va_list args) {
+        return functions->CallIntMethodV(this,obj,methodID,args);
+    }
+    jint CallIntMethodA(jobject obj, jmethodID methodID,
+			const jvalue * args) {
+        return functions->CallIntMethodA(this,obj,methodID,args);
+    }
+
+    jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	jlong result;
+	va_start(args,methodID);
+	result = functions->CallLongMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jlong CallLongMethodV(jobject obj, jmethodID methodID,
+			  va_list args) {
+        return functions->CallLongMethodV(this,obj,methodID,args);
+    }
+    jlong CallLongMethodA(jobject obj, jmethodID methodID,
+			  const jvalue * args) {
+        return functions->CallLongMethodA(this,obj,methodID,args);
+    }
+
+    jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	jfloat result;
+	va_start(args,methodID);
+	result = functions->CallFloatMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
+			    va_list args) {
+        return functions->CallFloatMethodV(this,obj,methodID,args);
+    }
+    jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
+			    const jvalue * args) {
+        return functions->CallFloatMethodA(this,obj,methodID,args);
+    }
+
+    jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	jdouble result;
+	va_start(args,methodID);
+	result = functions->CallDoubleMethodV(this,obj,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
+			va_list args) {
+        return functions->CallDoubleMethodV(this,obj,methodID,args);
+    }
+    jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
+			const jvalue * args) {
+        return functions->CallDoubleMethodA(this,obj,methodID,args);
+    }
+
+    void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
+        va_list args;
+	va_start(args,methodID);
+	functions->CallVoidMethodV(this,obj,methodID,args);
+	va_end(args);
+    }
+    void CallVoidMethodV(jobject obj, jmethodID methodID,
+			 va_list args) {
+        functions->CallVoidMethodV(this,obj,methodID,args);
+    }
+    void CallVoidMethodA(jobject obj, jmethodID methodID,
+			 const jvalue * args) {
+        functions->CallVoidMethodA(this,obj,methodID,args);
+    }
+
+    jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
+				       jmethodID methodID, ...) {
+        va_list args;
+	jobject result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
+							methodID,args);
+	va_end(args);
+	return result;
+    }
+    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, const jvalue * args) {
+        return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
+						      methodID,args);
+    }
+
+    jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
+					 jmethodID methodID, ...) {
+        va_list args;
+	jboolean result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
+							 methodID,args);
+	va_end(args);
+	return result;
+    }
+    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, const jvalue * args) {
+        return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
+						       methodID, args);
+    }
+
+    jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
+				   jmethodID methodID, ...) {
+        va_list args;
+	jbyte result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
+						      methodID,args);
+	va_end(args);
+	return result;
+    }
+    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, const jvalue * args) {
+        return functions->CallNonvirtualByteMethodA(this,obj,clazz,
+						    methodID,args);
+    }
+
+    jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
+				   jmethodID methodID, ...) {
+        va_list args;
+	jchar result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
+						      methodID,args);
+	va_end(args);
+	return result;
+    }
+    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, const jvalue * args) {
+        return functions->CallNonvirtualCharMethodA(this,obj,clazz,
+						    methodID,args);
+    }
+
+    jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
+				     jmethodID methodID, ...) {
+        va_list args;
+	jshort result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
+						       methodID,args);
+	va_end(args);
+	return result;
+    }
+    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, const jvalue * args) {
+        return functions->CallNonvirtualShortMethodA(this,obj,clazz,
+						     methodID,args);
+    }
+
+    jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
+				 jmethodID methodID, ...) {
+        va_list args;
+	jint result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
+						     methodID,args);
+	va_end(args);
+	return result;
+    }
+    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, const jvalue * args) {
+        return functions->CallNonvirtualIntMethodA(this,obj,clazz,
+						   methodID,args);
+    }
+
+    jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
+				   jmethodID methodID, ...) {
+        va_list args;
+	jlong result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
+						      methodID,args);
+	va_end(args);
+	return result;
+    }
+    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, const jvalue * args) {
+        return functions->CallNonvirtualLongMethodA(this,obj,clazz,
+						    methodID,args);
+    }
+
+    jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
+				     jmethodID methodID, ...) {
+        va_list args;
+	jfloat result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
+						       methodID,args);
+	va_end(args);
+	return result;
+    }
+    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,
+				      const jvalue * args) {
+        return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
+						     methodID,args);
+    }
+
+    jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
+				       jmethodID methodID, ...) {
+        va_list args;
+	jdouble result;
+	va_start(args,methodID);
+	result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
+							methodID,args);
+	va_end(args);
+	return result;
+    }
+    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,
+					const jvalue * args) {
+        return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
+						      methodID,args);
+    }
+
+    void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
+				  jmethodID methodID, ...) {
+        va_list args;
+	va_start(args,methodID);
+	functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
+	va_end(args);
+    }
+    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,
+				   const 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 val) {
+        functions->SetObjectField(this,obj,fieldID,val);
+    }
+    void SetBooleanField(jobject obj, jfieldID fieldID,
+			 jboolean val) {
+        functions->SetBooleanField(this,obj,fieldID,val);
+    }
+    void SetByteField(jobject obj, jfieldID fieldID,
+		      jbyte val) {
+        functions->SetByteField(this,obj,fieldID,val);
+    }
+    void SetCharField(jobject obj, jfieldID fieldID,
+		      jchar val) {
+        functions->SetCharField(this,obj,fieldID,val);
+    }
+    void SetShortField(jobject obj, jfieldID fieldID,
+		       jshort val) {
+        functions->SetShortField(this,obj,fieldID,val);
+    }
+    void SetIntField(jobject obj, jfieldID fieldID,
+		     jint val) {
+        functions->SetIntField(this,obj,fieldID,val);
+    }
+    void SetLongField(jobject obj, jfieldID fieldID,
+		      jlong val) {
+        functions->SetLongField(this,obj,fieldID,val);
+    }
+    void SetFloatField(jobject obj, jfieldID fieldID,
+		       jfloat val) {
+        functions->SetFloatField(this,obj,fieldID,val);
+    }
+    void SetDoubleField(jobject obj, jfieldID fieldID,
+			jdouble val) {
+        functions->SetDoubleField(this,obj,fieldID,val);
+    }
+
+    jmethodID GetStaticMethodID(jclass clazz, const char *name,
+				const char *sig) {
+        return functions->GetStaticMethodID(this,clazz,name,sig);
+    }
+
+    jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
+			     ...) {
+        va_list args;
+	jobject result;
+	va_start(args,methodID);
+	result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
+			      va_list args) {
+        return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
+    }
+    jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
+			      const jvalue *args) {
+        return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
+    }
+
+    jboolean CallStaticBooleanMethod(jclass clazz,
+				     jmethodID methodID, ...) {
+        va_list args;
+	jboolean result;
+	va_start(args,methodID);
+	result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jboolean CallStaticBooleanMethodV(jclass clazz,
+				      jmethodID methodID, va_list args) {
+        return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
+    }
+    jboolean CallStaticBooleanMethodA(jclass clazz,
+				      jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
+    }
+
+    jbyte CallStaticByteMethod(jclass clazz,
+			       jmethodID methodID, ...) {
+        va_list args;
+	jbyte result;
+	va_start(args,methodID);
+	result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jbyte CallStaticByteMethodV(jclass clazz,
+				jmethodID methodID, va_list args) {
+        return functions->CallStaticByteMethodV(this,clazz,methodID,args);
+    }
+    jbyte CallStaticByteMethodA(jclass clazz,
+				jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticByteMethodA(this,clazz,methodID,args);
+    }
+
+    jchar CallStaticCharMethod(jclass clazz,
+			       jmethodID methodID, ...) {
+        va_list args;
+	jchar result;
+	va_start(args,methodID);
+	result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jchar CallStaticCharMethodV(jclass clazz,
+				jmethodID methodID, va_list args) {
+        return functions->CallStaticCharMethodV(this,clazz,methodID,args);
+    }
+    jchar CallStaticCharMethodA(jclass clazz,
+				jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticCharMethodA(this,clazz,methodID,args);
+    }
+
+    jshort CallStaticShortMethod(jclass clazz,
+				 jmethodID methodID, ...) {
+        va_list args;
+	jshort result;
+	va_start(args,methodID);
+	result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jshort CallStaticShortMethodV(jclass clazz,
+				  jmethodID methodID, va_list args) {
+        return functions->CallStaticShortMethodV(this,clazz,methodID,args);
+    }
+    jshort CallStaticShortMethodA(jclass clazz,
+				  jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticShortMethodA(this,clazz,methodID,args);
+    }
+
+    jint CallStaticIntMethod(jclass clazz,
+			     jmethodID methodID, ...) {
+        va_list args;
+	jint result;
+	va_start(args,methodID);
+	result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jint CallStaticIntMethodV(jclass clazz,
+			      jmethodID methodID, va_list args) {
+        return functions->CallStaticIntMethodV(this,clazz,methodID,args);
+    }
+    jint CallStaticIntMethodA(jclass clazz,
+			      jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticIntMethodA(this,clazz,methodID,args);
+    }
+
+    jlong CallStaticLongMethod(jclass clazz,
+			       jmethodID methodID, ...) {
+        va_list args;
+	jlong result;
+	va_start(args,methodID);
+	result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jlong CallStaticLongMethodV(jclass clazz,
+				jmethodID methodID, va_list args) {
+        return functions->CallStaticLongMethodV(this,clazz,methodID,args);
+    }
+    jlong CallStaticLongMethodA(jclass clazz,
+				jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticLongMethodA(this,clazz,methodID,args);
+    }
+
+    jfloat CallStaticFloatMethod(jclass clazz,
+				 jmethodID methodID, ...) {
+        va_list args;
+	jfloat result;
+	va_start(args,methodID);
+	result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jfloat CallStaticFloatMethodV(jclass clazz,
+				  jmethodID methodID, va_list args) {
+        return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
+    }
+    jfloat CallStaticFloatMethodA(jclass clazz,
+				  jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
+    }
+
+    jdouble CallStaticDoubleMethod(jclass clazz,
+				   jmethodID methodID, ...) {
+        va_list args;
+	jdouble result;
+	va_start(args,methodID);
+	result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
+	va_end(args);
+	return result;
+    }
+    jdouble CallStaticDoubleMethodV(jclass clazz,
+				    jmethodID methodID, va_list args) {
+        return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
+    }
+    jdouble CallStaticDoubleMethodA(jclass clazz,
+				    jmethodID methodID, const jvalue *args) {
+        return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
+    }
+
+    void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
+        va_list args;
+	va_start(args,methodID);
+	functions->CallStaticVoidMethodV(this,cls,methodID,args);
+	va_end(args);
+    }
+    void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
+			       va_list args) {
+        functions->CallStaticVoidMethodV(this,cls,methodID,args);
+    }
+    void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
+			       const jvalue * args) {
+        functions->CallStaticVoidMethodA(this,cls,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 *unicode, jsize len) {
+        return functions->NewString(this,unicode,len);
+    }
+    jsize GetStringLength(jstring str) {
+        return functions->GetStringLength(this,str);
+    }
+    const jchar *GetStringChars(jstring str, jboolean *isCopy) {
+        return functions->GetStringChars(this,str,isCopy);
+    }
+    void ReleaseStringChars(jstring str, const jchar *chars) {
+        functions->ReleaseStringChars(this,str,chars);
+    }
+
+    jstring NewStringUTF(const char *utf) {
+        return functions->NewStringUTF(this,utf);
+    }
+    jsize GetStringUTFLength(jstring str) {
+        return functions->GetStringUTFLength(this,str);
+    }
+    const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
+        return functions->GetStringUTFChars(this,str,isCopy);
+    }
+    void ReleaseStringUTFChars(jstring str, const char* chars) {
+        functions->ReleaseStringUTFChars(this,str,chars);
+    }
+
+    jsize GetArrayLength(jarray array) {
+        return functions->GetArrayLength(this,array);
+    }
+
+    jobjectArray NewObjectArray(jsize len, jclass clazz,
+				jobject init) {
+        return functions->NewObjectArray(this,len,clazz,init);
+    }
+    jobject GetObjectArrayElement(jobjectArray array, jsize index) {
+        return functions->GetObjectArrayElement(this,array,index);
+    }
+    void SetObjectArrayElement(jobjectArray array, jsize index,
+			       jobject val) {
+        functions->SetObjectArrayElement(this,array,index,val);
+    }
+
+    jbooleanArray NewBooleanArray(jsize len) {
+        return functions->NewBooleanArray(this,len);
+    }
+    jbyteArray NewByteArray(jsize len) {
+        return functions->NewByteArray(this,len);
+    }
+    jcharArray NewCharArray(jsize len) {
+        return functions->NewCharArray(this,len);
+    }
+    jshortArray NewShortArray(jsize len) {
+        return functions->NewShortArray(this,len);
+    }
+    jintArray NewIntArray(jsize len) {
+        return functions->NewIntArray(this,len);
+    }
+    jlongArray NewLongArray(jsize len) {
+        return functions->NewLongArray(this,len);
+    }
+    jfloatArray NewFloatArray(jsize len) {
+        return functions->NewFloatArray(this,len);
+    }
+    jdoubleArray NewDoubleArray(jsize len) {
+        return functions->NewDoubleArray(this,len);
+    }
+
+    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,
+			       const jboolean *buf) {
+        functions->SetBooleanArrayRegion(this,array,start,len,buf);
+    }
+    void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
+			    const jbyte *buf) {
+        functions->SetByteArrayRegion(this,array,start,len,buf);
+    }
+    void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
+			    const jchar *buf) {
+        functions->SetCharArrayRegion(this,array,start,len,buf);
+    }
+    void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
+			     const jshort *buf) {
+        functions->SetShortArrayRegion(this,array,start,len,buf);
+    }
+    void SetIntArrayRegion(jintArray array, jsize start, jsize len,
+			   const jint *buf) {
+        functions->SetIntArrayRegion(this,array,start,len,buf);
+    }
+    void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
+			    const jlong *buf) {
+        functions->SetLongArrayRegion(this,array,start,len,buf);
+    }
+    void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
+			     const jfloat *buf) {
+        functions->SetFloatArrayRegion(this,array,start,len,buf);
+    }
+    void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
+			      const 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);
+    }
+
+    const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
+        return functions->GetStringCritical(this,string,isCopy);
+    }
+    void ReleaseStringCritical(jstring string, const jchar *cstring) {
+        functions->ReleaseStringCritical(this,string,cstring);
+    }
+
+    jweak NewWeakGlobalRef(jobject obj) {
+        return functions->NewWeakGlobalRef(this,obj);
+    }
+    void DeleteWeakGlobalRef(jweak ref) {
+        functions->DeleteWeakGlobalRef(this,ref);
+    }
+
+    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 /* __cplusplus */
+};
+
+typedef struct JavaVMOption {
+    char *optionString;
+    void *extraInfo;
+} JavaVMOption;
+
+typedef struct JavaVMInitArgs {
+    jint version;
+
+    jint nOptions;
+    JavaVMOption *options;
+    jboolean ignoreUnrecognized;
+} JavaVMInitArgs;
+
+typedef struct JavaVMAttachArgs {
+    jint version;
+
+    char *name;
+    jobject group;
+} JavaVMAttachArgs;
+
+/* These structures will be VM-specific. */
+
+typedef struct JDK1_1InitArgs {
+    jint version;
+
+    char **properties;
+    jint checkSource;
+    jint nativeStackSize;
+    jint javaStackSize;
+    jint minHeapSize;
+    jint maxHeapSize;
+    jint verifyMode;
+    char *classpath;
+
+    jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
+    void (JNICALL *exit)(jint code);
+    void (JNICALL *abort)(void);
+
+    jint enableClassGC;
+    jint enableVerboseGC;
+    jint disableAsyncGC;
+    jint verbose;
+    jboolean debugging;
+    jint debugPort;
+} JDK1_1InitArgs;
+
+typedef struct JDK1_1AttachArgs {
+    void * __padding; /* C compilers don't allow empty structures. */
+} JDK1_1AttachArgs;
+
+#define JDK1_2
+#define JDK1_4
+
+/* End VM-specific. */
+
+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;
+#ifdef __cplusplus
+
+    jint DestroyJavaVM() {
+        return functions->DestroyJavaVM(this);
+    }
+    jint AttachCurrentThread(void **penv, void *args) {
+        return functions->AttachCurrentThread(this, penv, args);
+    }
+    jint DetachCurrentThread() {
+        return functions->DetachCurrentThread(this);
+    }
+
+    jint GetEnv(void **penv, jint version) {
+        return functions->GetEnv(this, penv, version);
+    }
+    jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
+        return functions->AttachCurrentThreadAsDaemon(this, penv, args);
+    }
+#endif
+};
+
+#ifdef _JNI_IMPLEMENTATION_
+#define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
+#else
+#define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
+#endif
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_GetDefaultJavaVMInitArgs(void *args);
+
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
+
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
+
+/* Defined by native libraries. */
+JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM *vm, void *reserved);
+
+JNIEXPORT void JNICALL
+JNI_OnUnload(JavaVM *vm, void *reserved);
+
+#define JNI_VERSION_1_1 0x00010001
+#define JNI_VERSION_1_2 0x00010002
+#define JNI_VERSION_1_4 0x00010004
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* !_JAVASOFT_JNI_H_ */
diff --git a/include/jni/jvmdi.h b/include/jni/jvmdi.h
new file mode 100644
index 0000000..7ad82b1
--- /dev/null
+++ b/include/jni/jvmdi.h
@@ -0,0 +1,1012 @@
+/*
+ * @(#)jvmdi.h	1.47 03/01/23
+ *
+ * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+/*
+ *   Java Virtual Machine Debug Interface
+ *
+ *   Defines debugging functionality that a VM should provide.  
+ *
+ *   Should not overlap functionality in jni.h
+ */
+
+#ifndef _JAVASOFT_JVMDI_H_
+#define _JAVASOFT_JVMDI_H_
+
+#include "jni.h"
+
+#define JVMDI_VERSION_1    0x20010000
+#define JVMDI_VERSION_1_1  0x20010001
+#define JVMDI_VERSION_1_2  0x20010002
+#define JVMDI_VERSION_1_3  0x20010003
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef jobject jthread;
+
+typedef jobject jthreadGroup;
+
+struct _jframeID;
+typedef struct _jframeID *jframeID;
+
+  /* specifies program location "pc" - often byte code index */
+typedef jlong jlocation;
+
+  /* The jmethodID for methods that have been replaced */
+  /* via RedefineClasses - used when the implementation */
+  /* does not wish to retain replaced jmethodIDs */
+#define OBSOLETE_METHOD_ID ((jmethodID)(NULL))
+
+  /*
+   *  Errors
+   */
+
+typedef jint jvmdiError;
+
+  /* no error */
+#define JVMDI_ERROR_NONE                 ((jvmdiError)0)
+
+  /*
+   * Errors on thread operations
+   */
+
+  /* invalid thread */
+#define JVMDI_ERROR_INVALID_THREAD       ((jvmdiError)10)
+  /* invalid thread group */
+#define JVMDI_ERROR_INVALID_THREAD_GROUP ((jvmdiError)11)
+  /* invalid thread priority */
+#define JVMDI_ERROR_INVALID_PRIORITY     ((jvmdiError)12)
+  /* thread not suspended */
+#define JVMDI_ERROR_THREAD_NOT_SUSPENDED ((jvmdiError)13)
+  /* thread already suspended */
+#define JVMDI_ERROR_THREAD_SUSPENDED     ((jvmdiError)14)
+
+  /* 
+   * Errors on object and class operations
+   */
+
+  /* invalid object (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_OBJECT       ((jvmdiError)20)
+  /* invalid class (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_CLASS        ((jvmdiError)21)
+  /* class not prepared */
+#define JVMDI_ERROR_CLASS_NOT_PREPARED   ((jvmdiError)22)
+  /* invalid methodID (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_METHODID     ((jvmdiError)23)
+  /* invalid location */
+#define JVMDI_ERROR_INVALID_LOCATION     ((jvmdiError)24)
+  /* invalid fieldID (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_FIELDID      ((jvmdiError)25)
+
+  /*
+   * Errors on frame operations
+   */
+
+  /* invalid frameID (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_FRAMEID      ((jvmdiError)30)
+  /* there are no more frames on the stack */
+#define JVMDI_ERROR_NO_MORE_FRAMES       ((jvmdiError)31)
+  /* operation cannot be performed on this frame */
+#define JVMDI_ERROR_OPAQUE_FRAME         ((jvmdiError)32)
+  /* operation can only be performed on current frame */
+#define JVMDI_ERROR_NOT_CURRENT_FRAME    ((jvmdiError)33)
+  /* type mismatch (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_TYPE_MISMATCH        ((jvmdiError)34)
+  /* invalid slot */
+#define JVMDI_ERROR_INVALID_SLOT         ((jvmdiError)35)
+
+  /*
+   * Errors on set/clear/find operations
+   */
+
+  /* item already present */
+#define JVMDI_ERROR_DUPLICATE            ((jvmdiError)40)
+  /* item not found */
+#define JVMDI_ERROR_NOT_FOUND            ((jvmdiError)41)
+
+  /*
+   * Errors on monitor operations
+   */
+
+  /* invalid monitor */
+#define JVMDI_ERROR_INVALID_MONITOR      ((jvmdiError)50)
+  /* wait, notify, notify all tried without entering monitor  */
+#define JVMDI_ERROR_NOT_MONITOR_OWNER    ((jvmdiError)51)
+  /* waiting thread interrupted */
+#define JVMDI_ERROR_INTERRUPT            ((jvmdiError)52)
+  
+  /*
+   * Class redefinition / operand stack errors
+   */
+
+  /* The equivalent of ClassFormatError */
+#define JVMDI_ERROR_INVALID_CLASS_FORMAT          ((jvmdiError)60)
+  /* The equivalent of ClassCircularityError */
+#define JVMDI_ERROR_CIRCULAR_CLASS_DEFINITION     ((jvmdiError)61)
+  /* The class bytes fail verification */
+#define JVMDI_ERROR_FAILS_VERIFICATION            ((jvmdiError)62)
+  /* The new class version adds new methods */
+  /* and can_add_method is false */
+#define JVMDI_ERROR_ADD_METHOD_NOT_IMPLEMENTED    ((jvmdiError)63)
+  /* The new class version changes fields */ 
+  /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_SCHEMA_CHANGE_NOT_IMPLEMENTED ((jvmdiError)64)
+  /* bci/operand stack/local var combination is not verifiably */
+  /* type safe */
+#define JVMDI_ERROR_INVALID_TYPESTATE             ((jvmdiError)65)
+  /* A direct superclass is different for the new class */
+  /* version, or the set of directly implemented */
+  /* interfaces is different */
+  /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_HIERARCHY_CHANGE_NOT_IMPLEMENTED ((jvmdiError)66)
+  /* The new class version does not declare a method */
+  /* declared in the old class version */
+  /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_DELETE_METHOD_NOT_IMPLEMENTED ((jvmdiError)67)
+  /* A class file has a version number not supported */
+  /* by this VM. */
+#define JVMDI_ERROR_UNSUPPORTED_VERSION           ((jvmdiError)68)
+  /* The class name defined in the new class file is */
+  /* different from the name in the old class object */
+#define JVMDI_ERROR_NAMES_DONT_MATCH              ((jvmdiError)69)
+  /* The new class version has different modifiers and */
+  /* can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED   ((jvmdiError)70)
+  /* A method in the new class version has different modifiers */
+  /* than its counterpart in the old class version */
+  /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED  ((jvmdiError)71)
+
+  /*
+   * Miscellaneous errors
+   */
+
+  /* Not yet implemented */
+#define JVMDI_ERROR_NOT_IMPLEMENTED      ((jvmdiError)99)
+  /* null pointer */
+#define JVMDI_ERROR_NULL_POINTER         ((jvmdiError)100)
+  /* information is absent */
+#define JVMDI_ERROR_ABSENT_INFORMATION   ((jvmdiError)101)
+  /* invalid event type  */
+#define JVMDI_ERROR_INVALID_EVENT_TYPE   ((jvmdiError)102)
+  /* invalid argument  */
+#define JVMDI_ERROR_ILLEGAL_ARGUMENT     ((jvmdiError)103)
+
+  /*
+   * Universal errors. These errors may be returned by
+   * any JVMDI function, not just the ones for which they are listed
+   * below.
+   */
+
+  /* no more memory available for allocation */
+#define JVMDI_ERROR_OUT_OF_MEMORY        ((jvmdiError)110)
+  /* debugging has not been enabled in this VM */
+#define JVMDI_ERROR_ACCESS_DENIED        ((jvmdiError)111)
+  /* VM is dead (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_VM_DEAD              ((jvmdiError)112)
+  /* internal error  */
+#define JVMDI_ERROR_INTERNAL             ((jvmdiError)113)
+  /* Thread calling JVMDI function not attached to VM */
+#define JVMDI_ERROR_UNATTACHED_THREAD    ((jvmdiError)115)
+
+
+  /*
+   *  Threads
+   */
+
+  /* Thread status is unknown */
+#define JVMDI_THREAD_STATUS_UNKNOWN      ((jint)-1)
+  /* Thread is waiting to die */
+#define JVMDI_THREAD_STATUS_ZOMBIE       ((jint)0)
+  /* Thread is runnable */
+#define JVMDI_THREAD_STATUS_RUNNING      ((jint)1)
+  /* Thread is sleeping - Thread.sleep() or JVM_Sleep() was called */
+#define JVMDI_THREAD_STATUS_SLEEPING     ((jint)2)
+  /* Thread is waiting on a java monitor */
+#define JVMDI_THREAD_STATUS_MONITOR      ((jint)3)
+  /* Thread is waiting - Thread.wait() or JVM_MonitorWait() was called */
+#define JVMDI_THREAD_STATUS_WAIT         ((jint)4)
+
+  /* Thread is suspended - Thread.suspend(), JVM_Suspend() or
+   * JVMDI_Suspend was called */
+#define JVMDI_SUSPEND_STATUS_SUSPENDED   ((jint)0x1)
+  /* Thread is at a breakpoint */
+#define JVMDI_SUSPEND_STATUS_BREAK       ((jint)0x2)
+
+
+  /* Thread priority constants */
+#define JVMDI_THREAD_MIN_PRIORITY   ((jint)1)
+#define JVMDI_THREAD_NORM_PRIORITY  ((jint)5)
+#define JVMDI_THREAD_MAX_PRIORITY   ((jint)10)
+
+typedef struct {
+    char *name;
+    jint  priority;
+    jboolean is_daemon;
+    jthreadGroup thread_group;
+    jobject context_class_loader;
+} JVMDI_thread_info;
+
+typedef struct {
+    jthreadGroup parent;
+    char *name;
+    jint  max_priority;
+    jboolean is_daemon;
+} JVMDI_thread_group_info;
+
+#define JVMDI_DISABLE ((jint) 0)
+#define JVMDI_ENABLE  ((jint) 1)
+
+/*
+ * Initial function for debug threads created through JVMDI
+ */
+typedef void (*JVMDI_StartFunction)(void *);
+
+/*
+ * Type for debug monitors created through JVMDI
+ */
+typedef void *JVMDI_RawMonitor;
+
+#define JVMDI_MONITOR_WAIT_FOREVER ((jlong)(-1))
+
+/*
+ * Monitor information
+ */
+typedef struct {
+    jthread owner;
+    jint entry_count;
+    jint waiter_count;
+    jthread *waiters;
+} JVMDI_monitor_info;
+
+typedef struct {
+    jint owned_monitor_count;
+    jobject *owned_monitors;
+} JVMDI_owned_monitor_info;
+
+  /*
+   *  Events
+   */
+
+    /* kind = JVMDI_EVENT_SINGLE_STEP */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+        jmethodID method;
+        jlocation location;
+    } JVMDI_single_step_event_data;
+			
+    /* kind = JVMDI_EVENT_BREAKPOINT */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+        jmethodID method;
+        jlocation location;
+    } JVMDI_breakpoint_event_data;
+    
+    /* kind = JVMDI_EVENT_FIELD_ACCESS */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+        jmethodID method;
+        jlocation location;
+        jclass field_clazz;
+        jobject object;
+        jfieldID field;
+    } JVMDI_field_access_event_data;
+    
+    /* kind = JVMDI_EVENT_FIELD_MODIFICATION */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+        jmethodID method;
+        jlocation location;
+        jclass field_clazz;
+        jobject object;
+        jfieldID field;
+        char signature_type;
+        jvalue new_value;
+    } JVMDI_field_modification_event_data;
+    
+    /* kind = JVMDI_EVENT_FRAME_POP */
+    /* kind = JVMDI_EVENT_METHOD_ENTRY */
+    /* kind = JVMDI_EVENT_METHOD_EXIT */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+        jmethodID method;
+        jframeID frame;
+    } JVMDI_frame_event_data;
+    
+    /* kind = JVMDI_EVENT_EXCEPTION */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+        jmethodID method;
+        jlocation location;
+        jobject exception;
+        jclass catch_clazz;
+        jmethodID catch_method;
+        jlocation catch_location;
+    } JVMDI_exception_event_data;
+    
+    /* kind = JVMDI_EVENT_EXCEPTION_CATCH */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+        jmethodID method;
+        jlocation location;
+        jobject exception;
+    } JVMDI_exception_catch_event_data;
+    
+    /* kind = JVMDI_EVENT_USER_DEFINED */
+    typedef struct { 
+        jobject object;
+        jint key;
+    } JVMDI_user_event_data;
+    
+    /* kind = JVMDI_EVENT_THREAD_END or */
+    /* JVMDI_EVENT_THREAD_START */
+    typedef struct { 
+        jthread thread;
+    } JVMDI_thread_change_event_data;
+    
+    /* kind = JVMDI_EVENT_CLASS_LOAD, */
+    /* JVMDI_EVENT_CLASS_UNLOAD, or */
+    /* JVMDI_EVENT_CLASS_PREPARE */
+    typedef struct { 
+        jthread thread;
+        jclass clazz;
+    } JVMDI_class_event_data;
+    
+/* This stucture passes information about the event.
+ * location is the index of the last instruction executed. 
+ */
+typedef struct {
+    jint kind;		/* the discriminant */
+
+    union {
+	/* kind = JVMDI_EVENT_SINGLE_STEP */
+        JVMDI_single_step_event_data single_step;
+			
+        /* kind = JVMDI_EVENT_BREAKPOINT */
+        JVMDI_breakpoint_event_data breakpoint;
+
+        /* kind = JVMDI_EVENT_FRAME_POP */
+        /* kind = JVMDI_EVENT_METHOD_ENTRY */
+        /* kind = JVMDI_EVENT_METHOD_EXIT */
+        JVMDI_frame_event_data frame;
+
+        /* kind = JVMDI_EVENT_FIELD_ACCESS */
+        JVMDI_field_access_event_data field_access;
+
+        /* kind = JVMDI_EVENT_FIELD_MODIFICATION */
+        JVMDI_field_modification_event_data field_modification;
+
+        /* kind = JVMDI_EVENT_EXCEPTION */
+        JVMDI_exception_event_data exception;
+
+        /* kind = JVMDI_EVENT_EXCEPTION_CATCH */
+        JVMDI_exception_catch_event_data exception_catch;
+
+        /* kind = JVMDI_EVENT_USER_DEFINED */
+        JVMDI_user_event_data user;
+			
+        /* kind = JVMDI_EVENT_THREAD_END or */
+        /* JVMDI_EVENT_THREAD_START */
+        JVMDI_thread_change_event_data thread_change;
+			
+        /* kind = JVMDI_EVENT_CLASS_LOAD, */
+        /* JVMDI_EVENT_CLASS_UNLOAD, or */
+        /* JVMDI_EVENT_CLASS_PREPARE */
+        JVMDI_class_event_data class_event;
+			
+        /* kind = JVMDI_EVENT_VM_DEATH, JVMDI_EVENT_VM_INIT */
+        /* no additional fields */		
+    } u;
+} JVMDI_Event;
+
+	/*** event kinds ***/
+#define JVMDI_EVENT_SINGLE_STEP   ((jint)1)
+#define JVMDI_EVENT_BREAKPOINT    ((jint)2)
+#define JVMDI_EVENT_FRAME_POP     ((jint)3)
+#define JVMDI_EVENT_EXCEPTION     ((jint)4)
+#define JVMDI_EVENT_USER_DEFINED  ((jint)5)
+#define JVMDI_EVENT_THREAD_START  ((jint)6)
+#define JVMDI_EVENT_THREAD_END    ((jint)7)
+#define JVMDI_EVENT_CLASS_PREPARE ((jint)8)
+#define JVMDI_EVENT_CLASS_UNLOAD  ((jint)9)
+#define JVMDI_EVENT_CLASS_LOAD    ((jint)10)
+#define JVMDI_EVENT_FIELD_ACCESS       ((jint)20)
+#define JVMDI_EVENT_FIELD_MODIFICATION ((jint)21)
+#define JVMDI_EVENT_EXCEPTION_CATCH    ((jint)30)
+#define JVMDI_EVENT_METHOD_ENTRY       ((jint)40)
+#define JVMDI_EVENT_METHOD_EXIT        ((jint)41)
+#define JVMDI_EVENT_VM_INIT            ((jint)90)
+#define JVMDI_EVENT_VM_DEATH           ((jint)99)
+
+#define JVMDI_MAX_EVENT_TYPE_VAL       ((jint)99)
+
+
+
+/* event handler hook */
+typedef void (*JVMDI_EventHook)(JNIEnv *env, JVMDI_Event *event);
+
+typedef jvmdiError (*JVMDI_AllocHook) (jlong size, jbyte** memPtr);
+typedef jvmdiError (*JVMDI_DeallocHook) (jbyte* buffer);
+
+/*
+ * Class states used in JVMDI_GetClassStatus
+ */
+#define JVMDI_CLASS_STATUS_VERIFIED          ((jint)0x01)
+#define JVMDI_CLASS_STATUS_PREPARED          ((jint)0x02)
+#define JVMDI_CLASS_STATUS_INITIALIZED       ((jint)0x04)
+ /* Error prevents initialization */
+#define JVMDI_CLASS_STATUS_ERROR             ((jint)0x08) 
+
+/* structure for returning line number information 
+ */
+typedef struct {
+    jlocation start_location;
+    jint line_number;
+} JVMDI_line_number_entry;
+
+
+/* structure for returning local variable information 
+ */
+typedef struct {
+    jlocation start_location;   /* variable valid start_location */
+    jint length;                /* upto start_location+length */ 
+    char *name;                 /* name in UTF8 */
+    char *signature;            /* type signature in UTF8 */
+    jint slot;                  /* variable slot, see JVMDI_GetLocal*()  */
+} JVMDI_local_variable_entry;
+
+/* structure for returning exception handler information 
+ */
+typedef struct {
+    jlocation start_location;
+    jlocation end_location;
+    jlocation handler_location;
+    jclass exception;           /* if null, all exceptions */
+} JVMDI_exception_handler_entry;
+
+#define JVMDI_OPERAND_TYPE_REFERENCE      ((jint)1)
+#define JVMDI_OPERAND_TYPE_INT            ((jint)2)
+#define JVMDI_OPERAND_TYPE_FLOAT          ((jint)3)
+#define JVMDI_OPERAND_TYPE_LONG0          ((jint)4) /* least sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_LONG1          ((jint)5) /* most sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_DOUBLE0        ((jint)6) /* least sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_DOUBLE1        ((jint)7) /* most sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_RETURN_ADDRESS ((jint)8)
+
+typedef struct {
+    jint word;                 /* 32 bit operand stack quantities */
+    jint type;                 /* type encoding of the operand word */
+                               /* one of JVMDI_OPERAND_TYPE_* */
+} JVMDI_operand_stack_element;
+
+typedef struct { 
+    jint instance_field_count; /* number of instance fields referencing obj */
+    struct JVMDI_instance_field {
+        jobject instance;      /* instance referencing obj */
+        jfieldID field;        /* field holding reference */
+    } *instance_fields;        /* instanceField_count of them */
+     
+    jint static_field_count;   /* number of static fields referencing obj */
+    struct JVMDI_static_field {
+        jclass clazz;          /* class referencing obj */
+        jfieldID static_field; /* field holding reference */
+    } *static_fields;          /* static_field_count of them */
+    
+    jint array_element_count;  /* number of array elements referencing obj */
+    struct JVMDI_array_element {
+        jobjectArray array;    /* array referencing obj */
+        jint index;            /* index holding reference */
+    } *array_elements;         /* array_element_count of them */
+    
+    jint frame_slot_count;     /* number of frame slots referencing obj */
+    struct JVMDI_frame_slot {
+        jthread thread;        /* thread of the frame */
+        jframeID frame;        /* frame referencing obj */
+        jint slot;             /* slot holding reference */
+    } *frame_slots;            /* frame_slot_count of them */
+} JVMDI_object_reference_info;
+
+/* structure for defining a class
+*/
+typedef struct {
+    jclass clazz;              /* Class object for this class */
+    jint class_byte_count;     /* number of bytes defining class (below) */
+    jbyte *class_bytes;        /* bytes defining class (in JVM spec */
+                               /* Class File Format) */
+} JVMDI_class_definition;
+
+  /* For backwards compatibility */
+#define can_change_schema can_unrestrictedly_redefine_classes
+
+typedef struct {
+    unsigned int can_watch_field_modification      : 1;
+    unsigned int can_watch_field_access            : 1;
+    unsigned int can_get_bytecodes                 : 1;
+    unsigned int can_get_synthetic_attribute       : 1;
+    unsigned int can_get_owned_monitor_info        : 1;
+    unsigned int can_get_current_contended_monitor : 1;
+    unsigned int can_get_monitor_info              : 1;
+    unsigned int can_get_heap_info                 : 1;
+    unsigned int can_get_operand_stack             : 1;
+    unsigned int can_set_operand_stack             : 1;
+    unsigned int can_pop_frame                     : 1;
+    unsigned int can_get_class_definition          : 1;
+    unsigned int can_redefine_classes              : 1; 
+    unsigned int can_add_method                    : 1;
+    unsigned int can_unrestrictedly_redefine_classes : 1;
+    unsigned int can_suspend_resume_thread_lists   : 1;
+} JVMDI_capabilities;
+
+typedef struct JVMDI_Interface_1_ {
+    jvmdiError (JNICALL *SetEventHook)
+      (JVMDI_EventHook hook);
+    jvmdiError (JNICALL *SetEventNotificationMode)
+      (jint mode, jint eventType, jthread thread, ...);
+
+    jvmdiError (JNICALL *GetThreadStatus)
+      (jthread thread,
+       jint *threadStatusPtr, jint *suspendStatusPtr);
+    jvmdiError (JNICALL *GetAllThreads)
+      (jint *threadsCountPtr, jthread **threadsPtr);
+    jvmdiError (JNICALL *SuspendThread)
+      (jthread thread); 
+    jvmdiError (JNICALL *ResumeThread)
+      (jthread thread);
+    jvmdiError (JNICALL *StopThread)
+      (jthread thread, jobject exception);
+    jvmdiError (JNICALL *InterruptThread)
+      (jthread thread);
+    jvmdiError (JNICALL *GetThreadInfo)
+      (jthread thread, JVMDI_thread_info *infoPtr);
+    jvmdiError (JNICALL *GetOwnedMonitorInfo)
+      (jthread thread, JVMDI_owned_monitor_info *infoPtr);
+    jvmdiError (JNICALL *GetCurrentContendedMonitor)
+      (jthread thread, jobject *monitor);
+    jvmdiError (JNICALL *RunDebugThread)
+      (jthread thread, JVMDI_StartFunction proc, void *arg,
+       int priority);
+
+    jvmdiError (JNICALL *GetTopThreadGroups)
+      (jint *groupCountPtr, jthreadGroup **groupsPtr);
+    jvmdiError (JNICALL *GetThreadGroupInfo)
+      (jthreadGroup group, JVMDI_thread_group_info *infoPtr);
+    jvmdiError (JNICALL *GetThreadGroupChildren)
+      (jthreadGroup group, 
+       jint *threadCountPtr, jthread **threadsPtr,
+       jint *groupCountPtr, jthreadGroup **groupsPtr);
+
+    jvmdiError (JNICALL *GetFrameCount)
+      (jthread thread, jint *countPtr);
+    jvmdiError (JNICALL *GetCurrentFrame)
+      (jthread thread, jframeID *framePtr);
+    jvmdiError (JNICALL *GetCallerFrame)
+      (jframeID called, jframeID *framePtr);
+    jvmdiError (JNICALL *GetFrameLocation)
+      (jframeID frame, jclass *classPtr, jmethodID *methodPtr,
+       jlocation *locationPtr);
+    jvmdiError (JNICALL *NotifyFramePop)
+      (jframeID frame); 
+    jvmdiError (JNICALL *GetLocalObject)
+      (jframeID frame, jint slot, jobject *valuePtr);
+    jvmdiError (JNICALL *GetLocalInt)
+      (jframeID frame, jint slot, jint *valuePtr);
+    jvmdiError (JNICALL *GetLocalLong)
+      (jframeID frame, jint slot, jlong *valuePtr);
+    jvmdiError (JNICALL *GetLocalFloat)
+      (jframeID frame, jint slot, jfloat *valuePtr);
+    jvmdiError (JNICALL *GetLocalDouble)
+      (jframeID frame, jint slot, jdouble *valuePtr);
+    jvmdiError (JNICALL *SetLocalObject)
+      (jframeID frame, jint slot, jobject value);
+    jvmdiError (JNICALL *SetLocalInt)
+      (jframeID frame, jint slot, jint value);
+    jvmdiError (JNICALL *SetLocalLong)
+      (jframeID frame, jint slot, jlong value);
+    jvmdiError (JNICALL *SetLocalFloat)
+      (jframeID frame, jint slot, jfloat value);
+    jvmdiError (JNICALL *SetLocalDouble)
+      (jframeID frame, jint slot, jdouble value);
+
+    jvmdiError (JNICALL *CreateRawMonitor)
+      (char *name, JVMDI_RawMonitor *monitorPtr);
+    jvmdiError (JNICALL *DestroyRawMonitor)
+      (JVMDI_RawMonitor monitor);
+    jvmdiError (JNICALL *RawMonitorEnter)
+      (JVMDI_RawMonitor monitor);
+    jvmdiError (JNICALL *RawMonitorExit)
+      (JVMDI_RawMonitor monitor);
+    jvmdiError (JNICALL *RawMonitorWait)
+      (JVMDI_RawMonitor monitor, jlong millis);
+    jvmdiError (JNICALL *RawMonitorNotify)
+      (JVMDI_RawMonitor monitor);
+    jvmdiError (JNICALL *RawMonitorNotifyAll)
+      (JVMDI_RawMonitor monitor);
+
+    jvmdiError (JNICALL *SetBreakpoint)
+      (jclass clazz, jmethodID method, jlocation location);
+    jvmdiError (JNICALL *ClearBreakpoint)
+      (jclass clazz, jmethodID method, jlocation location);
+    jvmdiError (JNICALL *ClearAllBreakpoints)
+      ();
+
+    jvmdiError (JNICALL *SetFieldAccessWatch)
+      (jclass clazz, jfieldID field);
+    jvmdiError (JNICALL *ClearFieldAccessWatch)
+      (jclass clazz, jfieldID field);
+    jvmdiError (JNICALL *SetFieldModificationWatch)
+      (jclass clazz, jfieldID field);
+    jvmdiError (JNICALL *ClearFieldModificationWatch)
+      (jclass clazz, jfieldID field);
+
+    jvmdiError (JNICALL *SetAllocationHooks)
+      (JVMDI_AllocHook ahook, JVMDI_DeallocHook dhook);
+    jvmdiError (JNICALL *Allocate)
+      (jlong size, jbyte** memPtr);
+    jvmdiError (JNICALL *Deallocate)
+      (jbyte* mem);
+
+    jvmdiError (JNICALL *GetClassSignature)
+      (jclass clazz, char **sigPtr);
+    jvmdiError (JNICALL *GetClassStatus)
+      (jclass clazz, jint *statusPtr);
+    jvmdiError (JNICALL *GetSourceFileName)
+      (jclass clazz, char **sourceNamePtr);
+    jvmdiError (JNICALL *GetClassModifiers)
+      (jclass clazz, jint *modifiersPtr);
+    jvmdiError (JNICALL *GetClassMethods)
+      (jclass clazz, jint *methodCountPtr, jmethodID **methodsPtr);
+    jvmdiError (JNICALL *GetClassFields)
+       (jclass clazz, jint *fieldCountPtr, jfieldID **fieldsPtr);
+    jvmdiError (JNICALL *GetImplementedInterfaces)
+      (jclass clazz, jint *interfaceCountPtr, jclass **interfacesPtr);
+    jvmdiError (JNICALL *IsInterface)
+      (jclass clazz, jboolean *isInterfacePtr);
+    jvmdiError (JNICALL *IsArrayClass)
+      (jclass clazz, jboolean *isArrayClassPtr);
+    jvmdiError (JNICALL *GetClassLoader)
+      (jclass clazz, jobject *classloaderPtr);
+
+    jvmdiError (JNICALL *GetObjectHashCode)
+      (jobject object, jint *hashCodePtr);
+    jvmdiError (JNICALL *GetMonitorInfo)
+      (jobject object, JVMDI_monitor_info *infoPtr);
+
+    jvmdiError (JNICALL *GetFieldName)
+      (jclass clazz, jfieldID field, char **namePtr, char **signaturePtr);
+    jvmdiError (JNICALL *GetFieldDeclaringClass)
+      (jclass clazz, jfieldID field, jclass *declaringClassPtr);
+    jvmdiError (JNICALL *GetFieldModifiers)
+      (jclass clazz, jfieldID field, jint *modifiersPtr);
+    jvmdiError (JNICALL *IsFieldSynthetic)
+      (jclass clazz, jfieldID field, jboolean *isSyntheticPtr);
+
+    jvmdiError (JNICALL *GetMethodName)
+      (jclass clazz, jmethodID method, 
+       char **namePtr, char **signaturePtr);
+    jvmdiError (JNICALL *GetMethodDeclaringClass)
+      (jclass clazz, jmethodID method, jclass *declaringClassPtr);
+    jvmdiError (JNICALL *GetMethodModifiers)
+      (jclass clazz, jmethodID method, jint *modifiersPtr);
+    jvmdiError (JNICALL *GetMaxStack)
+      (jclass clazz, jmethodID method, jint *maxPtr);
+    jvmdiError (JNICALL *GetMaxLocals)
+      (jclass clazz, jmethodID method, jint *maxPtr);
+    jvmdiError (JNICALL *GetArgumentsSize)
+      (jclass clazz, jmethodID method, jint *sizePtr);
+    jvmdiError (JNICALL *GetLineNumberTable)
+      (jclass clazz, jmethodID method,
+       jint *entryCountPtr, JVMDI_line_number_entry **tablePtr);
+    jvmdiError (JNICALL *GetMethodLocation)
+      (jclass clazz, jmethodID method,
+       jlocation *startLocationPtr, jlocation *endLocationPtr);
+    jvmdiError (JNICALL *GetLocalVariableTable)
+      (jclass clazz, jmethodID method,
+       jint *entryCountPtr, JVMDI_local_variable_entry **tablePtr);
+    jvmdiError (JNICALL *GetExceptionHandlerTable)
+      (jclass clazz, jmethodID method,
+       jint *entryCountPtr, JVMDI_exception_handler_entry **tablePtr);
+    jvmdiError (JNICALL *GetThrownExceptions)
+      (jclass clazz, jmethodID method,
+       jint *exceptionCountPtr, jclass **exceptionsPtr);
+    jvmdiError (JNICALL *GetBytecodes)
+      (jclass clazz, jmethodID method,
+       jint *bytecodeCountPtr, jbyte **bytecodesPtr);
+    jvmdiError (JNICALL *IsMethodNative)
+      (jclass clazz, jmethodID method, jboolean *isNativePtr);
+    jvmdiError (JNICALL *IsMethodSynthetic)
+      (jclass clazz, jmethodID method, jboolean *isSyntheticPtr);
+
+    jvmdiError (JNICALL *GetLoadedClasses)
+      (jint *classCountPtr, jclass **classesPtr);
+    jvmdiError (JNICALL *GetClassLoaderClasses)
+      (jobject initiatingLoader, jint *classesCountPtr, 
+       jclass **classesPtr);
+
+    jvmdiError (JNICALL *PopFrame)
+      (jthread thread);
+    jvmdiError (JNICALL *SetFrameLocation)
+      (jframeID frame, jlocation location);
+    jvmdiError (JNICALL *GetOperandStack)
+      (jframeID frame, jint *operandStackSizePtr, 
+       JVMDI_operand_stack_element **operandStackPtr);
+    jvmdiError (JNICALL *SetOperandStack)
+      (jframeID frame, jint operandStackSize, 
+       JVMDI_operand_stack_element *operandStack);
+    jvmdiError (JNICALL *AllInstances)
+      (jclass clazz, jint *instanceCountPtr, jobject **instancesPtr);
+    jvmdiError (JNICALL *References)
+      (jobject obj, JVMDI_object_reference_info *refs);
+    jvmdiError (JNICALL *GetClassDefinition)
+      (jclass clazz, JVMDI_class_definition *classDefPtr);
+    jvmdiError (JNICALL *RedefineClasses)
+      (jint classCount, JVMDI_class_definition *classDefs);
+
+    jvmdiError (JNICALL *GetVersionNumber)
+      (jint *versionPtr);
+    jvmdiError (JNICALL *GetCapabilities)
+      (JVMDI_capabilities *capabilitiesPtr);
+
+    jvmdiError (JNICALL *GetSourceDebugExtension)
+      (jclass clazz, char **sourceDebugExtension);
+    jvmdiError (JNICALL *IsMethodObsolete)
+      (jclass clazz, jmethodID method, jboolean *isObsoletePtr);
+
+    jvmdiError (JNICALL *SuspendThreadList)
+      (jint reqCount, jthread *reqList, jvmdiError *results); 
+    jvmdiError (JNICALL *ResumeThreadList)
+      (jint reqCount, jthread *reqList, jvmdiError *results); 
+} JVMDI_Interface_1;
+  
+#ifndef NO_JVMDI_MACROS
+
+#define JVMDI_ERROR_DUPLICATE_BREAKPOINT JVMDI_ERROR_DUPLICATE
+#define JVMDI_ERROR_NO_SUCH_BREAKPOINT   JVMDI_ERROR_NOT_FOUND
+#define JVMDI_ERROR_DUPLICATE_FRAME_POP  JVMDI_ERROR_DUPLICATE
+
+
+static JVMDI_Interface_1 *jvmdi_interface = NULL;
+static JavaVM *j_vm;
+
+#ifdef __cplusplus
+#define SetJVMDIfromJNIEnv(a_env) ( (jvmdi_interface == NULL)?  \
+              ((a_env)->GetJavaVM(&j_vm),  \
+               (j_vm)->GetEnv((void **)&jvmdi_interface,  \
+                               JVMDI_VERSION_1)):0)
+#else
+#define SetJVMDIfromJNIEnv(a_env) ( (jvmdi_interface == NULL)?  \
+              ((*a_env)->GetJavaVM(a_env, &j_vm), \
+               (*j_vm)->GetEnv(j_vm, (void **)&jvmdi_interface, \
+                               JVMDI_VERSION_1)):0)
+#endif
+
+#define JVMDI_SetEventHook(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetEventHook(a1) )
+#define JVMDI_GetThreadStatus(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetThreadStatus(a1, a2, a3) )
+#define JVMDI_GetAllThreads(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetAllThreads(a1, a2) )
+#define JVMDI_SuspendThread(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SuspendThread(a1) )
+#define JVMDI_ResumeThread(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->ResumeThread(a1) )
+#define JVMDI_StopThread(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->StopThread(a1, a2) )
+#define JVMDI_InterruptThread(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->InterruptThread(a1) )
+#define JVMDI_SetSingleStep(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetEventNotificationMode( \
+                                       (a2) ? JVMDI_ENABLE : JVMDI_DISABLE, \
+                                        JVMDI_EVENT_SINGLE_STEP, a1) )
+#define JVMDI_GetThreadInfo(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetThreadInfo(a1, a2) )
+#define JVMDI_RunDebugThread(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->RunDebugThread(a1, a2, a3, a4) )
+#define JVMDI_GetTopThreadGroups(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetTopThreadGroups(a1, a2) )
+#define JVMDI_GetThreadGroupInfo(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetThreadGroupInfo(a1, a2) )
+#define JVMDI_GetThreadGroupChildren(a_env, a1, a2, a3, a4, a5) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetThreadGroupChildren(a1, a2, a3, a4, a5) )
+#define JVMDI_GetCurrentFrame(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetCurrentFrame(a1, a2) )
+#define JVMDI_GetCallerFrame(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetCallerFrame(a1, a2) )
+#define JVMDI_GetFrameLocation(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetFrameLocation(a1, a2, a3, a4) )
+#define JVMDI_NotifyFramePop(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->NotifyFramePop(a1) )
+#define JVMDI_GetLocalObject(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLocalObject(a1, a2, a3) )
+#define JVMDI_GetLocalInt(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLocalInt(a1, a2, a3) )
+#define JVMDI_GetLocalLong(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLocalLong(a1, a2, a3) )
+#define JVMDI_GetLocalFloat(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLocalFloat(a1, a2, a3) )
+#define JVMDI_GetLocalDouble(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLocalDouble(a1, a2, a3) )
+#define JVMDI_SetLocalObject(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetLocalObject(a1, a2, a3) )
+#define JVMDI_SetLocalInt(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetLocalInt(a1, a2, a3) )
+#define JVMDI_SetLocalLong(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetLocalLong(a1, a2, a3) )
+#define JVMDI_SetLocalFloat(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetLocalFloat(a1, a2, a3) )
+#define JVMDI_SetLocalDouble(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetLocalDouble(a1, a2, a3) )
+#define JVMDI_CreateRawMonitor(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->CreateRawMonitor(a1, a2) )
+#define JVMDI_DestroyRawMonitor(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->DestroyRawMonitor(a1) )
+#define JVMDI_RawMonitorEnter(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->RawMonitorEnter(a1) )
+#define JVMDI_RawMonitorExit(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->RawMonitorExit(a1) )
+#define JVMDI_RawMonitorWait(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->RawMonitorWait(a1, a2) )
+#define JVMDI_RawMonitorNotify(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->RawMonitorNotify(a1) )
+#define JVMDI_RawMonitorNotifyAll(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->RawMonitorNotifyAll(a1) )
+#define JVMDI_SetBreakpoint(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetBreakpoint(a1, a2, a3) )
+#define JVMDI_ClearBreakpoint(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->ClearBreakpoint(a1, a2, a3) )
+#define JVMDI_ClearAllBreakpoints(a_env) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->ClearAllBreakpoints() )
+#define JVMDI_SetAllocationHooks(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->SetAllocationHooks(a1, a2) )
+#define JVMDI_Allocate(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->Allocate(a1, a2) )
+#define JVMDI_Deallocate(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->Deallocate(a1) )
+#define JVMDI_GetClassSignature(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetClassSignature(a1, a2) )
+#define JVMDI_GetClassStatus(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetClassStatus(a1, a2) )
+#define JVMDI_GetSourceFileName(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetSourceFileName(a1, a2) )
+#define JVMDI_GetClassModifiers(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetClassModifiers(a1, a2) )
+#define JVMDI_GetClassMethods(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetClassMethods(a1, a2, a3) )
+#define JVMDI_GetClassFields(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetClassFields(a1, a2, a3) )
+#define JVMDI_GetImplementedInterfaces(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetImplementedInterfaces(a1, a2, a3) )
+#define JVMDI_IsInterface(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->IsInterface(a1, a2) )
+#define JVMDI_IsArrayClass(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->IsArrayClass(a1, a2) )
+#define JVMDI_ClassLoader(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetClassLoader(a1, a2) )
+#define JVMDI_GetFieldName(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetFieldName(a1, a2, a3, a4) )
+#define JVMDI_GetFieldDeclaringClass(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetFieldDeclaringClass(a1, a2, a3) )
+#define JVMDI_GetFieldModifiers(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetFieldModifiers(a1, a2, a3) )
+#define JVMDI_GetMethodName(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetMethodName(a1, a2, a3, a4) )
+#define JVMDI_GetMethodDeclaringClass(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetMethodDeclaringClass(a1, a2, a3) )
+#define JVMDI_GetMethodModifiers(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetMethodModifiers(a1, a2, a3) )
+#define JVMDI_GetMaxStack(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetMaxStack(a1, a2, a3) )
+#define JVMDI_GetMaxLocals(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetMaxLocals(a1, a2, a3) )
+#define JVMDI_GetArgumentsSize(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetArgumentsSize(a1, a2, a3) )
+#define JVMDI_GetLineNumberTable(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLineNumberTable(a1, a2, a3, a4) )
+#define JVMDI_GetMethodLocation(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetMethodLocation(a1, a2, a3, a4) )
+#define JVMDI_GetLocalVariableTable(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLocalVariableTable(a1, a2, a3, a4) )
+#define JVMDI_GetExceptionHandlerTable(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetExceptionHandlerTable(a1, a2, a3, a4) )
+#define JVMDI_GetThrownExceptions(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetThrownExceptions(a1, a2, a3, a4) )
+#define JVMDI_GetBytecodes(a_env, a1, a2, a3, a4) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetBytecodes(a1, a2, a3, a4) )
+#define JVMDI_IsMethodNative(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->IsMethodNative(a1, a2, a3) )
+#define JVMDI_GetLoadedClasses(a_env, a1, a2) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetLoadedClasses(a1, a2) )
+#define JVMDI_GetClassLoaderClasses(a_env, a1, a2, a3) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetClassLoaderClasses(a1, a2, a3) )
+#define JVMDI_GetVersionNumber(a_env, a1) ( \
+              SetJVMDIfromJNIEnv(a_env), \
+              jvmdi_interface->GetVersionNumber(a1) )
+
+#endif /* !NO_JVMDI_MACROS */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* !_JAVASOFT_JVMDI_H_ */
+
+
diff --git a/include/jni/jvmpi.h b/include/jni/jvmpi.h
new file mode 100644
index 0000000..57accd3
--- /dev/null
+++ b/include/jni/jvmpi.h
@@ -0,0 +1,642 @@
+/*
+ * @(#)jvmpi.h	1.27 03/01/23
+ *
+ * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JVMPI_H_
+#define _JAVASOFT_JVMPI_H_
+
+#include "jni.h"
+
+#define JVMPI_VERSION_1   ((jint)0x10000001)  /* implied 0 for minor version */
+#define JVMPI_VERSION_1_1 ((jint)0x10000002)
+#define JVMPI_VERSION_1_2 ((jint)0x10000003)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  typedef void (*jvmpi_void_function_of_void)(void *);
+#ifdef __cplusplus
+}
+#endif
+
+/****************************************************************
+ * Profiler interface data structures.
+ ****************************************************************/
+/* identifier types. */
+struct _jobjectID;
+typedef struct _jobjectID * jobjectID;       /* type of object ids */ 
+
+/* raw monitors */
+struct _JVMPI_RawMonitor;
+typedef struct _JVMPI_RawMonitor * JVMPI_RawMonitor;
+
+/* call frame */
+typedef struct {
+    jint lineno;                      /* line number in the source file */
+    jmethodID method_id;              /* method executed in this frame */
+} JVMPI_CallFrame;
+
+/* call trace */
+typedef struct {
+    JNIEnv *env_id;                   /* Env where trace was recorded */
+    jint num_frames;                  /* number of frames in this trace */
+    JVMPI_CallFrame *frames;          /* frames */
+} JVMPI_CallTrace;
+
+/* method */
+typedef struct {
+    char *method_name;                /* name of method */
+    char *method_signature;           /* signature of method */
+    jint start_lineno;                /* -1 if native, abstract .. */
+    jint end_lineno;                  /* -1 if native, abstract .. */
+    jmethodID method_id;              /* id assigned to this method */
+} JVMPI_Method;
+
+/* Field */
+typedef struct {
+    char *field_name;                 /* name of field */
+    char *field_signature;            /* signature of field */
+} JVMPI_Field;
+
+/* line number info for a compiled method */
+typedef struct {
+    jint offset;                      /* offset from beginning of method */
+    jint lineno;                      /* lineno from beginning of src file */
+} JVMPI_Lineno;
+
+/* event */
+typedef struct {
+    jint event_type;                  /* event_type */
+    JNIEnv *env_id;                   /* env where this event occured */
+  
+    union {
+        struct {
+	    const char *class_name;   /* class name */
+	    char *source_name;        /* name of source file */
+	    jint num_interfaces;      /* number of interfaces implemented */
+  	    jint num_methods;         /* number of methods in the class */
+	    JVMPI_Method *methods;    /* methods */
+	    jint num_static_fields;   /* number of static fields */
+	    JVMPI_Field *statics;     /* static fields */
+	    jint num_instance_fields; /* number of instance fields */
+	    JVMPI_Field *instances;   /* instance fields */
+	    jobjectID class_id;       /* id of the class object */
+	} class_load;
+
+        struct {
+	    jobjectID class_id;       /* id of the class object */
+	} class_unload;
+
+        struct {
+	    unsigned char *class_data;        /* content of class file */
+	    jint class_data_len;              /* class file length */
+	    unsigned char *new_class_data;    /* instrumented class file */
+	    jint new_class_data_len;          /* new class file length */
+	    void * (*malloc_f)(unsigned int); /* memory allocation function */
+	} class_load_hook;
+
+        struct {
+            jint arena_id;
+	    jobjectID class_id;       /* id of object class */
+	    jint is_array;            /* JVMPI_NORMAL_OBJECT, ... */
+	    jint size;                /* size in number of bytes */
+	    jobjectID obj_id;         /* id assigned to this object */
+        } obj_alloc;
+
+        struct {
+	    jobjectID obj_id;         /* id of the object */
+	} obj_free;
+
+        struct {
+	    jint arena_id;            /* cur arena id */
+	    jobjectID obj_id;         /* cur object id */
+	    jint new_arena_id;        /* new arena id */
+	    jobjectID new_obj_id;     /* new object id */	  
+	} obj_move;
+
+        struct {
+	    jint arena_id;            /* id of arena */
+	    const char *arena_name;   /* name of arena */
+	} new_arena;
+
+        struct {
+	    jint arena_id;            /* id of arena */
+	} delete_arena;
+
+        struct {
+	    char *thread_name;        /* name of thread */
+	    char *group_name;         /* name of group */
+	    char *parent_name;        /* name of parent */
+	    jobjectID thread_id;      /* id of the thread object */
+	    JNIEnv *thread_env_id;
+        } thread_start;
+
+        struct {
+	    int dump_level;           /* level of the heap dump info */
+	    char *begin;              /* where all the root records begin,
+					 please see the heap dump buffer 
+				         format described below */
+	    char *end;                /* where the object records end. */
+	    jint num_traces;          /* number of thread traces, 
+				         0 if dump level = JVMPI_DUMP_LEVEL_0 */
+	    JVMPI_CallTrace *traces;  /* thread traces collected during 
+					 heap dump */ 
+	} heap_dump;
+
+        struct {
+	    jobjectID obj_id;         /* object id */
+	    jobject ref_id;           /* id assigned to the globalref */
+	} jni_globalref_alloc;
+      
+        struct {
+	    jobject ref_id;           /* id of the global ref */
+	} jni_globalref_free;
+
+        struct {
+	    jmethodID method_id;      /* method */
+	} method;
+
+        struct {
+	    jmethodID method_id;      /* id of method */
+	    jobjectID obj_id;         /* id of target object */
+	} method_entry2;
+
+        struct {
+	    jmethodID method_id;        /* id of compiled method */
+	    void *code_addr;            /* code start addr. in memory */
+	    jint code_size;             /* code size */
+	    jint lineno_table_size;     /* size of lineno table */
+	    JVMPI_Lineno *lineno_table; /* lineno info */
+	} compiled_method_load;
+        
+        struct {
+	    jmethodID method_id;        /* id of unloaded compiled method */
+	} compiled_method_unload;
+
+	struct {
+	    jmethodID method_id; /* id of the method the instruction belongs to */
+	    jint offset;         /* instruction offset in the method's bytecode */
+	    union {
+		struct {
+		    jboolean is_true; /* whether true or false branch is taken  */
+		} if_info;
+		struct {
+		    jint key; /* top stack value used as an index */
+		    jint low; /* min value of the index           */
+		    jint hi;  /* max value of the index           */
+		} tableswitch_info;
+		struct {
+		    jint chosen_pair_index; /* actually chosen pair index (0-based)
+                                             * if chosen_pair_index == pairs_total then
+                                             * the 'default' branch is taken
+                                             */
+		    jint pairs_total;       /* total number of lookupswitch pairs */
+		} lookupswitch_info;
+	    } u;
+	} instruction;
+	
+        struct {
+	    char *begin;                /* beginning of dump buffer, 
+					   see below for format */
+	    char *end;                  /* end of dump buffer */
+	    jint num_traces;            /* number of traces */
+	    JVMPI_CallTrace *traces;    /* traces of all threads */
+	    jint *threads_status;       /* status of all threads */
+	} monitor_dump;
+
+        struct {
+	    const char *name;           /* name of raw monitor */
+	    JVMPI_RawMonitor id;        /* id */
+	} raw_monitor;
+
+        struct {
+	    jobjectID object;           /* Java object */
+	} monitor;
+
+        struct {
+	    jobjectID object;           /* Java object */
+	    jlong timeout;              /* timeout period */
+	} monitor_wait;
+
+        struct {
+	    jlong used_objects;
+	    jlong used_object_space;
+	    jlong total_object_space;
+	} gc_info;
+
+        struct {
+	    jint data_len;
+	    char *data;
+	} object_dump;
+    } u;
+} JVMPI_Event;
+
+/* interface functions */
+typedef struct {
+    jint version;   /* JVMPI version */
+    
+    /* ------interface implemented by the profiler------ */
+
+    /**
+     * Function called by the JVM to notify an event. 
+     */
+    void (*NotifyEvent)(JVMPI_Event *event);
+  
+    /* ------interface implemented by the JVM------ */
+    
+    /**
+     * Function called by the profiler to enable/disable/send notification 
+     * for a particular event type.  
+     * 
+     * event_type - event_type
+     * arg - event specific arg
+     *
+     * return JVMPI_NOT_AVAILABLE, JVMPI_SUCCESS or JVMPI_FAIL
+     */
+    jint (*EnableEvent)(jint event_type, void *arg);
+    jint (*DisableEvent)(jint event_type, void *arg);
+    jint (*RequestEvent)(jint event_type, void *arg);
+  
+    /**
+     * Function called by the profiler to get a stack
+     * trace from the JVM.
+     *
+     * trace - trace data structure to be filled
+     * depth - maximum depth of the trace.
+     */
+    void (*GetCallTrace)(JVMPI_CallTrace *trace, jint depth);
+
+    /**
+     * Function called by profiler when it wants to exit/stop.
+     */
+    void (*ProfilerExit)(jint);
+
+    /**
+     * Utility functions provided by the JVM.
+     */
+    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);
+
+    /**
+     * Function called by the profiler to get the current thread's CPU time.
+     *
+     * return time in nanoseconds;
+     */
+    jlong (*GetCurrentThreadCpuTime)(void);
+
+    void (*SuspendThread)(JNIEnv *env);
+    void (*ResumeThread)(JNIEnv *env);
+    jint (*GetThreadStatus)(JNIEnv *env);
+    jboolean (*ThreadHasRun)(JNIEnv *env);
+
+    /* This function can be called safely only after JVMPI_EVENT_VM_INIT_DONE
+       notification by the JVM. */
+    jint (*CreateSystemThread)(char *name, jint priority, void (*f)(void *));
+
+    /* thread local storage access functions to avoid locking in time 
+       critical functions */
+    void (*SetThreadLocalStorage)(JNIEnv *env_id, void *ptr);
+    void * (*GetThreadLocalStorage)(JNIEnv *env_id);
+
+    /* control GC */
+    void (*DisableGC)(void);
+    void (*EnableGC)(void);
+    void (*RunGC)(void);
+
+    jobjectID (*GetThreadObject)(JNIEnv *env);
+    jobjectID (*GetMethodClass)(jmethodID mid);
+
+    /* JNI <-> jobject conversions */
+    jobject   (*jobjectID2jobject)(jobjectID jid);
+    jobjectID (*jobject2jobjectID)(jobject jobj);
+
+    void (*SuspendThreadList)
+      (jint reqCount, JNIEnv **reqList, jint *results);
+    void (*ResumeThreadList)
+      (jint reqCount, JNIEnv **reqList, jint *results);
+} JVMPI_Interface;
+
+/* type of argument passed to RequestEvent for heap dumps */
+typedef struct {
+    jint heap_dump_level;
+} JVMPI_HeapDumpArg;
+
+/**********************************************************************
+ * Constants and formats used in JVM Profiler Interface.
+ **********************************************************************/
+/*
+ * Event type constants.
+ */
+#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) 
+
+#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_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)
+
+/* old definitions, to be removed */
+#define JVMPI_EVENT_LOAD_COMPILED_METHOD          ((jint)7) 
+#define JVMPI_EVENT_UNLOAD_COMPILED_METHOD        ((jint)8) 
+#define JVMPI_EVENT_NEW_ARENA                     ((jint)48)
+#define JVMPI_EVENT_DELETE_ARENA                  ((jint)49)
+#define JVMPI_EVENT_DUMP_DATA_REQUEST             ((jint)44) 
+#define JVMPI_EVENT_RESET_DATA_REQUEST            ((jint)45) 
+#define JVMPI_EVENT_OBJ_ALLOC                     ((jint)4) 
+#define JVMPI_EVENT_OBJ_FREE                      ((jint)5) 
+#define JVMPI_EVENT_OBJ_MOVE                      ((jint)6) 
+
+#define JVMPI_REQUESTED_EVENT                     ((jint)0x10000000)
+
+
+ 
+/* 
+ * enabling/disabling event notification.
+ */
+/* results */
+#define JVMPI_SUCCESS                    ((jint)0)
+#define JVMPI_NOT_AVAILABLE              ((jint)1)
+#define JVMPI_FAIL                       ((jint)-1)
+
+/*
+ * Thread status
+ */
+enum {
+    JVMPI_THREAD_RUNNABLE = 1,
+    JVMPI_THREAD_MONITOR_WAIT,
+    JVMPI_THREAD_CONDVAR_WAIT
+};
+
+#define JVMPI_THREAD_SUSPENDED        0x8000
+#define JVMPI_THREAD_INTERRUPTED      0x4000
+
+/*
+ * Thread priority
+ */
+#define JVMPI_MINIMUM_PRIORITY	    1
+#define JVMPI_MAXIMUM_PRIORITY	    10
+#define JVMPI_NORMAL_PRIORITY	    5
+
+/*
+ * Object type constants.
+ */
+#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)    
+
+/*
+ * Monitor dump constants.
+ */
+
+#define JVMPI_MONITOR_JAVA          0x01
+#define JVMPI_MONITOR_RAW           0x02
+
+/*
+ * Heap dump constants.
+ */
+#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
+
+/*
+ * Dump levels
+ */
+#define JVMPI_DUMP_LEVEL_0    ((jint)0)
+#define JVMPI_DUMP_LEVEL_1    ((jint)1)
+#define JVMPI_DUMP_LEVEL_2    ((jint)2)
+
+/* Types used in dumps -
+ *
+ * u1: 1 byte
+ * u2: 2 bytes
+ * u4: 4 bytes
+ * u8: 8 bytes
+ *
+ * ty: u1 where:
+ *     JVMPI_CLASS:   object
+ *     JVMPI_BOOLEAN: boolean
+ *     JVMPI_CHAR:    char
+ *     JVMPI_FLOAT:   float
+ *     JVMPI_DOUBLE:  double
+ *     JVMPI_BYTE:    byte
+ *     JVMPI_SHORT:   short
+ *     JVMPI_INT:     int
+ *     JVMPI_LONG:    long
+ *
+ * vl: values, exact type depends on the type of the value:
+ *     JVMPI_BOOLEAN & JVMPI_BYTE:   u1
+ *     JVMPI_SHORT & JVMPI_CHAR:     u2
+ *     JVMPI_INT & JVMPI_FLOAT:      u4
+ *     JVMPI_LONG & JVMPI_DOUBLE:    u8
+ *     JVMPI_CLASS:                  jobjectID
+ */
+
+/* Format of the monitor dump buffer:
+ *
+ *               u1                          monitor type
+ *
+ *               JVMPI_MONITOR_JAVA          Java monitor
+ *
+ *                          jobjectID        object
+ *                          JNIEnv *         owner thread
+ *                          u4               entry count
+ *                          u4               # of threads waiting to enter
+ *                          [JNIEnv *]*      threads waiting to enter
+ *                          u4               # of threads waiting to be notified
+ *                          [JNIEnv *]*      threads waiting to be notified
+ *
+ *               JVMPI_MONITOR_RAW           raw monitor
+ *
+ *                          char *           name
+ *                          JVMPI_RawMonitor raw monitor
+ *                          JNIEnv *         owner thread
+ *                          u4               entry count
+ *                          u4               # of threads waiting to enter
+ *                          [JNIEnv *]*      threads waiting to enter
+ *                          u4               # of threads waiting to be notified
+ *                          [JNIEnv *]*      threads waiting to be notified
+ */
+
+/* Format of the heap dump buffer depends on the dump level 
+ * specified in the JVMPI_HeapDumpArg passed to RequestEvent as arg. 
+ * The default is JVMPI_DUMP_LEVEL_2.
+ *
+ * JVMPI_DUMP_LEVEL_0:
+ * 
+ *               u1                          object type (JVMPI_CLASS ...)
+ *               jobjectID                   object
+ *
+ * JVMPI_DUMP_LEVEL_1 and JVMPI_DUMP_LEVEL_2 use the following format:  
+ * In the case of JVMPI_DUMP_LEVEL_1 the values of primitive fields in object 
+ * instance dumps , the values of primitive statics in class dumps and the 
+ * values of primitive arrays are excluded.  JVMPI_DUMP_LEVEL_2 includes the
+ * primitive values.
+ *
+ *               u1                          record type
+ *
+ *               JVMPI_GC_ROOT_UNKNOWN       unknown root
+ *
+ *                          jobjectID        object
+ *
+ *               JVMPI_GC_ROOT_JNI_GLOBAL    JNI global ref root
+ *
+ *                          jobjectID        object
+ *                          jobject          JNI global reference
+ *
+ *               JVMPI_GC_ROOT_JNI_LOCAL     JNI local ref
+ *
+ *                          jobjectID        object
+ *                          JNIEnv *         thread
+ *                          u4               frame # in stack trace (-1 for empty)
+ *
+ *               JVMPI_GC_ROOT_JAVA_FRAME    Java stack frame
+ *
+ *                          jobjectID        object
+ *                          JNIEnv *         thread
+ *                          u4               frame # in stack trace (-1 for empty)
+ *
+ *               JVMPI_GC_ROOT_NATIVE_STACK  Native stack
+ *
+ *                          jobjectID        object
+ *                          JNIEnv *         thread
+ *
+ *               JVMPI_GC_ROOT_STICKY_CLASS  System class
+ *
+ *                          jobjectID        class object
+ *
+ *               JVMPI_GC_ROOT_THREAD_BLOCK  Reference from thread block
+ *
+ *                          jobjectID        thread object
+ *                          JNIEnv *         thread
+ *
+ *               JVMPI_GC_ROOT_MONITOR_USED  Busy monitor
+ *
+ *                          jobjectID        object
+ *
+ *               JVMPI_GC_CLASS_DUMP         dump of a class object
+ *
+ *                          jobjectID        class
+ *                          jobjectID        super
+ *                          jobjectID        class loader
+ *                          jobjectID        signers
+ *                          jobjectID        protection domain
+ *                          jobjectID        class name
+ *                          void *           reserved
+ *
+ *                          u4               instance size (in bytes)
+ *
+ *                          [jobjectID]*     interfaces
+ *
+ *                          u2               size of constant pool
+ *                          [u2,             constant pool index,
+ *                           ty,             type, 
+ *                           vl]*            value
+ *
+ *                          [vl]*            static field values
+ *
+ *               JVMPI_GC_INSTANCE_DUMP      dump of a normal object
+ *
+ *                          jobjectID        object
+ *                          jobjectID        class
+ *                          u4               number of bytes that follow
+ *                          [vl]*            instance field values (class, followed
+ *                                           by super, super's super ...)
+ *
+ *               JVMPI_GC_OBJ_ARRAY_DUMP     dump of an object array
+ *
+ *                          jobjectID        array object
+ *                          u4               number of elements
+ *                          jobjectID        element class
+ *                          [jobjectID]*     elements
+ *
+ *               JVMPI_GC_PRIM_ARRAY_DUMP    dump of a primitive array
+ *
+ *                          jobjectID        array object
+ *                          u4               number of elements
+ *                          ty               element type
+ *                          [vl]*            elements
+ *
+ */
+
+/* Format of the dump received in JVMPI_EVENT_OBJECT_DUMP:
+ * All the records have JVMPI_DUMP_LEVEL_2 information.
+ *
+ *               u1                          record type
+ *
+ *                     followed by a:
+ *
+ *                          JVMPI_GC_CLASS_DUMP,
+ *                          JVMPI_GC_INSTANCE_DUMP,
+ *                          JVMPI_GC_OBJ_ARRAY_DUMP, or
+ *                          JVMPI_GC_PRIM_ARRAY_DUMP record.
+ */
+
+#endif /* !_JAVASOFT_JVMPI_H_ */
diff --git a/include/jni/linux/jawt_md.h b/include/jni/linux/jawt_md.h
new file mode 100644
index 0000000..dbb13e2
--- /dev/null
+++ b/include/jni/linux/jawt_md.h
@@ -0,0 +1,43 @@
+/*
+ * @(#)jawt_md.h	1.10 03/01/23
+ *
+ * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JAWT_MD_H_
+#define _JAVASOFT_JAWT_MD_H_
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Intrinsic.h>
+#include "jawt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * X11-specific declarations for AWT native interface.
+ * See notes in jawt.h for an example of use.
+ */
+typedef struct jawt_X11DrawingSurfaceInfo {
+    Drawable drawable;
+    Display* display;
+    VisualID visualID;
+    Colormap colormapID;
+    int depth;
+    /*
+     * Since 1.4
+     * Returns a pixel value from a set of RGB values.
+     * This is useful for paletted color (256 color) modes.
+     */
+    int (JNICALL *GetAWTColor)(JAWT_DrawingSurface* ds,
+        int r, int g, int b);
+} JAWT_X11DrawingSurfaceInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_JAVASOFT_JAWT_MD_H_ */
diff --git a/include/jni/linux/jni_md.h b/include/jni/linux/jni_md.h
new file mode 100644
index 0000000..9868531
--- /dev/null
+++ b/include/jni/linux/jni_md.h
@@ -0,0 +1,24 @@
+/*
+ * @(#)jni_md.h	1.17 03/01/23
+ *
+ * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JNI_MD_H_
+#define _JAVASOFT_JNI_MD_H_
+
+#define JNIEXPORT 
+#define JNIIMPORT
+#define JNICALL
+
+typedef int jint;
+#ifdef _LP64 /* 64-bit Solaris */
+typedef long jlong;
+#else
+typedef long long jlong;
+#endif
+
+typedef signed char jbyte;
+
+#endif /* !_JAVASOFT_JNI_MD_H_ */