From ea6d8f5aaf9f48bcf2cf8c37a7b72f804c68889f Mon Sep 17 00:00:00 2001 From: Francois-Olivier Devaux Date: Fri, 11 Jan 2008 09:33:45 +0000 Subject: [PATCH] Added missing files to JavaOpenJPEG project (files from Patrick Piscaglia) --- ChangeLog | 3 + JavaOpenJPEG/JavaOpenJPEG.vcproj | 2 +- JavaOpenJPEG/java-jni/include/jawt.h | 278 +++ JavaOpenJPEG/java-jni/include/jdwpTransport.h | 237 ++ JavaOpenJPEG/java-jni/include/jni.h | 1951 +++++++++++++++ JavaOpenJPEG/java-jni/include/jvmdi.h | 1012 ++++++++ JavaOpenJPEG/java-jni/include/jvmpi.h | 642 +++++ JavaOpenJPEG/java-jni/include/jvmti.h | 2181 +++++++++++++++++ JavaOpenJPEG/java-jni/include/win32/jawt_md.h | 41 + JavaOpenJPEG/java-jni/include/win32/jni_md.h | 19 + JavaOpenJPEG/java-jni/lib/jvm.lib | Bin 0 -> 273276 bytes 11 files changed, 6365 insertions(+), 1 deletion(-) create mode 100644 JavaOpenJPEG/java-jni/include/jawt.h create mode 100644 JavaOpenJPEG/java-jni/include/jdwpTransport.h create mode 100644 JavaOpenJPEG/java-jni/include/jni.h create mode 100644 JavaOpenJPEG/java-jni/include/jvmdi.h create mode 100644 JavaOpenJPEG/java-jni/include/jvmpi.h create mode 100644 JavaOpenJPEG/java-jni/include/jvmti.h create mode 100644 JavaOpenJPEG/java-jni/include/win32/jawt_md.h create mode 100644 JavaOpenJPEG/java-jni/include/win32/jni_md.h create mode 100644 JavaOpenJPEG/java-jni/lib/jvm.lib diff --git a/ChangeLog b/ChangeLog index 22846dbe..38a552ca 100644 --- a/ChangeLog +++ b/ChangeLog @@ -5,6 +5,9 @@ What's New for OpenJPEG ! : changed + : added +January 11, 2008 ++ [FOD] Added missing files to JavaOpenJPEG project (files from Patrick Piscaglia) + January 4, 2008 * [Parvatha] Patch by Callum Lerwick. Fixed bug during encoding using tile option in tcd.c diff --git a/JavaOpenJPEG/JavaOpenJPEG.vcproj b/JavaOpenJPEG/JavaOpenJPEG.vcproj index 6d3c5974..06b507de 100644 --- a/JavaOpenJPEG/JavaOpenJPEG.vcproj +++ b/JavaOpenJPEG/JavaOpenJPEG.vcproj @@ -27,7 +27,7 @@ EnableIntrinsicFunctions="TRUE" FavorSizeOrSpeed="1" OptimizeForWindowsApplication="TRUE" - AdditionalIncludeDirectories="C:\users\pp\telemis\working\projects\codecs\OpenJPEG2000\codec;../libopenjpeg;"../../../../3rdparty/windows/java-jni/include";"../../../../3rdparty/windows/java-jni/include/win32"" + AdditionalIncludeDirectories="../codec;../codec/compat;../libopenjpeg;".\java-jni\include";".\java-jni\include\win32"" PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;OPJ_STATIC;CHECK_THRESHOLDS" StringPooling="TRUE" RuntimeLibrary="0" diff --git a/JavaOpenJPEG/java-jni/include/jawt.h b/JavaOpenJPEG/java-jni/include/jawt.h new file mode 100644 index 00000000..30a49adf --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/jawt.h @@ -0,0 +1,278 @@ +/* + * @(#)jawt.h 1.10 03/12/19 + * + * Copyright 2004 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 + * + * 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/JavaOpenJPEG/java-jni/include/jdwpTransport.h b/JavaOpenJPEG/java-jni/include/jdwpTransport.h new file mode 100644 index 00000000..1d780092 --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/jdwpTransport.h @@ -0,0 +1,237 @@ +/* + * @(#)jdwpTransport.h 1.7 03/12/19 + * + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ + +/* + * Java Debug Wire Protocol Transport Service Provider Interface. + */ + +#ifndef JDWPTRANSPORT_H +#define JDWPTRANSPORT_H + +#include "jni.h" + +enum { + JDWPTRANSPORT_VERSION_1_0 = 0x00010000 +}; + +#ifdef __cplusplus +extern "C" { +#endif + +struct jdwpTransportNativeInterface_; + +struct _jdwpTransportEnv; + +#ifdef __cplusplus +typedef _jdwpTransportEnv jdwpTransportEnv; +#else +typedef const struct jdwpTransportNativeInterface_ *jdwpTransportEnv; +#endif /* __cplusplus */ + +/* + * Errors. Universal errors with JVMTI/JVMDI equivalents keep the + * values the same. + */ +typedef enum { + JDWPTRANSPORT_ERROR_NONE = 0, + JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT = 103, + JDWPTRANSPORT_ERROR_OUT_OF_MEMORY = 110, + JDWPTRANSPORT_ERROR_INTERNAL = 113, + JDWPTRANSPORT_ERROR_ILLEGAL_STATE = 201, + JDWPTRANSPORT_ERROR_IO_ERROR = 202, + JDWPTRANSPORT_ERROR_TIMEOUT = 203, + JDWPTRANSPORT_ERROR_MSG_NOT_AVAILABLE = 204 +} jdwpTransportError; + + +/* + * Structure to define capabilities + */ +typedef struct { + unsigned int can_timeout_attach :1; + unsigned int can_timeout_accept :1; + unsigned int can_timeout_handshake :1; + unsigned int reserved3 :1; + unsigned int reserved4 :1; + unsigned int reserved5 :1; + unsigned int reserved6 :1; + unsigned int reserved7 :1; + unsigned int reserved8 :1; + unsigned int reserved9 :1; + unsigned int reserved10 :1; + unsigned int reserved11 :1; + unsigned int reserved12 :1; + unsigned int reserved13 :1; + unsigned int reserved14 :1; + unsigned int reserved15 :1; +} JDWPTransportCapabilities; + + +/* + * Structures to define packet layout. + * + * See: http://java.sun.com/j2se/1.5/docs/guide/jpda/jdwp-spec.html + */ + +enum { + JDWPTRANSPORT_FLAGS_NONE = 0x0, + JDWPTRANSPORT_FLAGS_REPLY = 0x80 +}; + +typedef struct { + jint len; + jint id; + jbyte flags; + jbyte cmdSet; + jbyte cmd; + jbyte *data; +} jdwpCmdPacket; + +typedef struct { + jint len; + jint id; + jbyte flags; + jshort errorCode; + jbyte *data; +} jdwpReplyPacket; + +typedef struct { + union { + jdwpCmdPacket cmd; + jdwpReplyPacket reply; + } type; +} jdwpPacket; + +/* + * JDWP functions called by the transport. + */ +typedef struct jdwpTransportCallback { + void *(*alloc)(jint numBytes); /* Call this for all allocations */ + void (*free)(void *buffer); /* Call this for all deallocations */ +} jdwpTransportCallback; + +typedef jint (JNICALL *jdwpTransport_OnLoad_t)(JavaVM *jvm, + jdwpTransportCallback *callback, + jint version, + jdwpTransportEnv** env); + + + +/* Function Interface */ + +struct jdwpTransportNativeInterface_ { + /* 1 : RESERVED */ + void *reserved1; + + /* 2 : Get Capabilities */ + jdwpTransportError (JNICALL *GetCapabilities)(jdwpTransportEnv* env, + JDWPTransportCapabilities *capabilities_ptr); + + /* 3 : Attach */ + jdwpTransportError (JNICALL *Attach)(jdwpTransportEnv* env, + const char* address, + jlong attach_timeout, + jlong handshake_timeout); + + /* 4: StartListening */ + jdwpTransportError (JNICALL *StartListening)(jdwpTransportEnv* env, + const char* address, + char** actual_address); + + /* 5: StopListening */ + jdwpTransportError (JNICALL *StopListening)(jdwpTransportEnv* env); + + /* 6: Accept */ + jdwpTransportError (JNICALL *Accept)(jdwpTransportEnv* env, + jlong accept_timeout, + jlong handshake_timeout); + + /* 7: IsOpen */ + jboolean (JNICALL *IsOpen)(jdwpTransportEnv* env); + + /* 8: Close */ + jdwpTransportError (JNICALL *Close)(jdwpTransportEnv* env); + + /* 9: ReadPacket */ + jdwpTransportError (JNICALL *ReadPacket)(jdwpTransportEnv* env, + jdwpPacket *pkt); + + /* 10: Write Packet */ + jdwpTransportError (JNICALL *WritePacket)(jdwpTransportEnv* env, + const jdwpPacket* pkt); + + /* 11: GetLastError */ + jdwpTransportError (JNICALL *GetLastError)(jdwpTransportEnv* env, + char** error); + +}; + + +/* + * Use inlined functions so that C++ code can use syntax such as + * env->Attach("mymachine:5000", 10*1000, 0); + * + * rather than using C's :- + * + * (*env)->Attach(env, "mymachine:5000", 10*1000, 0); + */ +struct _jdwpTransportEnv { + const struct jdwpTransportNativeInterface_ *functions; +#ifdef __cplusplus + + jdwpTransportError GetCapabilities(JDWPTransportCapabilities *capabilities_ptr) { + return functions->GetCapabilities(this, capabilities_ptr); + } + + jdwpTransportError Attach(const char* address, jlong attach_timeout, + jlong handshake_timeout) { + return functions->Attach(this, address, attach_timeout, handshake_timeout); + } + + jdwpTransportError StartListening(const char* address, + char** actual_address) { + return functions->StartListening(this, address, actual_address); + } + + jdwpTransportError StopListening(void) { + return functions->StopListening(this); + } + + jdwpTransportError Accept(jlong accept_timeout, jlong handshake_timeout) { + return functions->Accept(this, accept_timeout, handshake_timeout); + } + + jboolean IsOpen(void) { + return functions->IsOpen(this); + } + + jdwpTransportError Close(void) { + return functions->Close(this); + } + + jdwpTransportError ReadPacket(jdwpPacket *pkt) { + return functions->ReadPacket(this, pkt); + } + + jdwpTransportError WritePacket(const jdwpPacket* pkt) { + return functions->WritePacket(this, pkt); + } + + jdwpTransportError GetLastError(char** error) { + return functions->GetLastError(this, error); + } + + +#endif /* __cplusplus */ +}; + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* JDWPTRANSPORT_H */ + diff --git a/JavaOpenJPEG/java-jni/include/jni.h b/JavaOpenJPEG/java-jni/include/jni.h new file mode 100644 index 00000000..cb3baef5 --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/jni.h @@ -0,0 +1,1951 @@ +/* + * @(#)jni.h 1.56 03/12/19 + * + * Copyright 2004 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 +#include + +/* 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/JavaOpenJPEG/java-jni/include/jvmdi.h b/JavaOpenJPEG/java-jni/include/jvmdi.h new file mode 100644 index 00000000..d39c4a95 --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/jvmdi.h @@ -0,0 +1,1012 @@ +/* + * @(#)jvmdi.h 1.48 03/12/19 + * + * Copyright 2004 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/JavaOpenJPEG/java-jni/include/jvmpi.h b/JavaOpenJPEG/java-jni/include/jvmpi.h new file mode 100644 index 00000000..557b231b --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/jvmpi.h @@ -0,0 +1,642 @@ +/* + * @(#)jvmpi.h 1.28 03/12/19 + * + * Copyright 2004 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/JavaOpenJPEG/java-jni/include/jvmti.h b/JavaOpenJPEG/java-jni/include/jvmti.h new file mode 100644 index 00000000..de24e3e9 --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/jvmti.h @@ -0,0 +1,2181 @@ +#ifdef USE_PRAGMA_IDENT_HDR +#pragma ident "@(#)jvmtiLib.xsl 1.32 04/06/01 20:19:53 JVM" +#endif +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + */ + + /* AUTOMATICALLY GENERATED FILE - DO NOT EDIT */ + + + /* Include file for the Java(tm) Virtual Machine Tool Interface */ + +#ifndef _JAVA_JVMTI_H_ +#define _JAVA_JVMTI_H_ + +#include "jni.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + JVMTI_VERSION_1 = 0x30010000, + JVMTI_VERSION_1_0 = 0x30010000, + + JVMTI_VERSION = 0x30000000 + (1 * 0x10000) + (0 * 0x100) + 33 /* version: 1.0.33 */ +}; + +JNIEXPORT jint JNICALL +Agent_OnLoad(JavaVM *vm, char *options, void *reserved); + +JNIEXPORT void JNICALL +Agent_OnUnload(JavaVM *vm); + + /* Forward declaration of the environment */ + +struct _jvmtiEnv; + +struct jvmtiInterface_1_; + +#ifdef __cplusplus +typedef _jvmtiEnv jvmtiEnv; +#else +typedef const struct jvmtiInterface_1_ *jvmtiEnv; +#endif /* __cplusplus */ + +/* Derived Base Types */ + +typedef jobject jthread; +typedef jobject jthreadGroup; +typedef jlong jlocation; +struct _jrawMonitorID; +typedef struct _jrawMonitorID *jrawMonitorID; +typedef struct JNINativeInterface_ jniNativeInterface; + + /* Constants */ + + + /* Thread State Flags */ + +enum { + JVMTI_THREAD_STATE_ALIVE = 0x0001, + JVMTI_THREAD_STATE_TERMINATED = 0x0002, + JVMTI_THREAD_STATE_RUNNABLE = 0x0004, + JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400, + JVMTI_THREAD_STATE_WAITING = 0x0080, + JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010, + JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020, + JVMTI_THREAD_STATE_SLEEPING = 0x0040, + JVMTI_THREAD_STATE_IN_OBJECT_WAIT = 0x0100, + JVMTI_THREAD_STATE_PARKED = 0x0200, + JVMTI_THREAD_STATE_SUSPENDED = 0x100000, + JVMTI_THREAD_STATE_INTERRUPTED = 0x200000, + JVMTI_THREAD_STATE_IN_NATIVE = 0x400000, + JVMTI_THREAD_STATE_VENDOR_1 = 0x10000000, + JVMTI_THREAD_STATE_VENDOR_2 = 0x20000000, + JVMTI_THREAD_STATE_VENDOR_3 = 0x40000000 +}; + + /* java.lang.Thread.State Conversion Masks */ + +enum { + JVMTI_JAVA_LANG_THREAD_STATE_MASK = JVMTI_THREAD_STATE_TERMINATED | JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_RUNNABLE | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_INDEFINITELY | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT, + JVMTI_JAVA_LANG_THREAD_STATE_NEW = 0, + JVMTI_JAVA_LANG_THREAD_STATE_TERMINATED = JVMTI_THREAD_STATE_TERMINATED, + JVMTI_JAVA_LANG_THREAD_STATE_RUNNABLE = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_RUNNABLE, + JVMTI_JAVA_LANG_THREAD_STATE_BLOCKED = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER, + JVMTI_JAVA_LANG_THREAD_STATE_WAITING = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_INDEFINITELY, + JVMTI_JAVA_LANG_THREAD_STATE_TIMED_WAITING = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +}; + + /* Thread Priority Constants */ + +enum { + JVMTI_THREAD_MIN_PRIORITY = 1, + JVMTI_THREAD_NORM_PRIORITY = 5, + JVMTI_THREAD_MAX_PRIORITY = 10 +}; + + /* Heap Object Filter Enumeration */ + +typedef enum { + JVMTI_HEAP_OBJECT_TAGGED = 1, + JVMTI_HEAP_OBJECT_UNTAGGED = 2, + JVMTI_HEAP_OBJECT_EITHER = 3 +} jvmtiHeapObjectFilter; + + /* Heap Root Kind Enumeration */ + +typedef enum { + JVMTI_HEAP_ROOT_JNI_GLOBAL = 1, + JVMTI_HEAP_ROOT_SYSTEM_CLASS = 2, + JVMTI_HEAP_ROOT_MONITOR = 3, + JVMTI_HEAP_ROOT_STACK_LOCAL = 4, + JVMTI_HEAP_ROOT_JNI_LOCAL = 5, + JVMTI_HEAP_ROOT_THREAD = 6, + JVMTI_HEAP_ROOT_OTHER = 7 +} jvmtiHeapRootKind; + + /* Object Reference Enumeration */ + +typedef enum { + JVMTI_REFERENCE_CLASS = 1, + JVMTI_REFERENCE_FIELD = 2, + JVMTI_REFERENCE_ARRAY_ELEMENT = 3, + JVMTI_REFERENCE_CLASS_LOADER = 4, + JVMTI_REFERENCE_SIGNERS = 5, + JVMTI_REFERENCE_PROTECTION_DOMAIN = 6, + JVMTI_REFERENCE_INTERFACE = 7, + JVMTI_REFERENCE_STATIC_FIELD = 8, + JVMTI_REFERENCE_CONSTANT_POOL = 9 +} jvmtiObjectReferenceKind; + + /* Iteration Control Enumeration */ + +typedef enum { + JVMTI_ITERATION_CONTINUE = 1, + JVMTI_ITERATION_IGNORE = 2, + JVMTI_ITERATION_ABORT = 0 +} jvmtiIterationControl; + + /* Class Status Flags */ + +enum { + JVMTI_CLASS_STATUS_VERIFIED = 1, + JVMTI_CLASS_STATUS_PREPARED = 2, + JVMTI_CLASS_STATUS_INITIALIZED = 4, + JVMTI_CLASS_STATUS_ERROR = 8, + JVMTI_CLASS_STATUS_ARRAY = 16, + JVMTI_CLASS_STATUS_PRIMITIVE = 32 +}; + + /* Event Enable/Disable */ + +typedef enum { + JVMTI_ENABLE = 1, + JVMTI_DISABLE = 0 +} jvmtiEventMode; + + /* Extension Function/Event Parameter Types */ + +typedef enum { + JVMTI_TYPE_JBYTE = 101, + JVMTI_TYPE_JCHAR = 102, + JVMTI_TYPE_JSHORT = 103, + JVMTI_TYPE_JINT = 104, + JVMTI_TYPE_JLONG = 105, + JVMTI_TYPE_JFLOAT = 106, + JVMTI_TYPE_JDOUBLE = 107, + JVMTI_TYPE_JBOOLEAN = 108, + JVMTI_TYPE_JOBJECT = 109, + JVMTI_TYPE_JTHREAD = 110, + JVMTI_TYPE_JCLASS = 111, + JVMTI_TYPE_JVALUE = 112, + JVMTI_TYPE_JFIELDID = 113, + JVMTI_TYPE_JMETHODID = 114, + JVMTI_TYPE_CCHAR = 115, + JVMTI_TYPE_CVOID = 116, + JVMTI_TYPE_JNIENV = 117 +} jvmtiParamTypes; + + /* Extension Function/Event Parameter Kinds */ + +typedef enum { + JVMTI_KIND_IN = 91, + JVMTI_KIND_IN_PTR = 92, + JVMTI_KIND_IN_BUF = 93, + JVMTI_KIND_ALLOC_BUF = 94, + JVMTI_KIND_ALLOC_ALLOC_BUF = 95, + JVMTI_KIND_OUT = 96, + JVMTI_KIND_OUT_BUF = 97 +} jvmtiParamKind; + + /* Timer Kinds */ + +typedef enum { + JVMTI_TIMER_USER_CPU = 30, + JVMTI_TIMER_TOTAL_CPU = 31, + JVMTI_TIMER_ELAPSED = 32 +} jvmtiTimerKind; + + /* Phases of execution */ + +typedef enum { + JVMTI_PHASE_ONLOAD = 1, + JVMTI_PHASE_PRIMORDIAL = 2, + JVMTI_PHASE_START = 6, + JVMTI_PHASE_LIVE = 4, + JVMTI_PHASE_DEAD = 8 +} jvmtiPhase; + + /* Version Interface Types */ + +enum { + JVMTI_VERSION_INTERFACE_JNI = 0x00000000, + JVMTI_VERSION_INTERFACE_JVMTI = 0x30000000 +}; + + /* Version Masks */ + +enum { + JVMTI_VERSION_MASK_INTERFACE_TYPE = 0x70000000, + JVMTI_VERSION_MASK_MAJOR = 0x0FFF0000, + JVMTI_VERSION_MASK_MINOR = 0x0000FF00, + JVMTI_VERSION_MASK_MICRO = 0x000000FF +}; + + /* Version Shifts */ + +enum { + JVMTI_VERSION_SHIFT_MAJOR = 16, + JVMTI_VERSION_SHIFT_MINOR = 8, + JVMTI_VERSION_SHIFT_MICRO = 0 +}; + + /* Verbose Flag Enumeration */ + +typedef enum { + JVMTI_VERBOSE_OTHER = 0, + JVMTI_VERBOSE_GC = 1, + JVMTI_VERBOSE_CLASS = 2, + JVMTI_VERBOSE_JNI = 4 +} jvmtiVerboseFlag; + + /* JLocation Format Enumeration */ + +typedef enum { + JVMTI_JLOCATION_JVMBCI = 1, + JVMTI_JLOCATION_MACHINEPC = 2, + JVMTI_JLOCATION_OTHER = 0 +} jvmtiJlocationFormat; + + /* Errors */ + +typedef enum { + JVMTI_ERROR_NONE = 0, + JVMTI_ERROR_INVALID_THREAD = 10, + JVMTI_ERROR_INVALID_THREAD_GROUP = 11, + JVMTI_ERROR_INVALID_PRIORITY = 12, + JVMTI_ERROR_THREAD_NOT_SUSPENDED = 13, + JVMTI_ERROR_THREAD_SUSPENDED = 14, + JVMTI_ERROR_THREAD_NOT_ALIVE = 15, + JVMTI_ERROR_INVALID_OBJECT = 20, + JVMTI_ERROR_INVALID_CLASS = 21, + JVMTI_ERROR_CLASS_NOT_PREPARED = 22, + JVMTI_ERROR_INVALID_METHODID = 23, + JVMTI_ERROR_INVALID_LOCATION = 24, + JVMTI_ERROR_INVALID_FIELDID = 25, + JVMTI_ERROR_NO_MORE_FRAMES = 31, + JVMTI_ERROR_OPAQUE_FRAME = 32, + JVMTI_ERROR_TYPE_MISMATCH = 34, + JVMTI_ERROR_INVALID_SLOT = 35, + JVMTI_ERROR_DUPLICATE = 40, + JVMTI_ERROR_NOT_FOUND = 41, + JVMTI_ERROR_INVALID_MONITOR = 50, + JVMTI_ERROR_NOT_MONITOR_OWNER = 51, + JVMTI_ERROR_INTERRUPT = 52, + JVMTI_ERROR_INVALID_CLASS_FORMAT = 60, + JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION = 61, + JVMTI_ERROR_FAILS_VERIFICATION = 62, + JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED = 63, + JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED = 64, + JVMTI_ERROR_INVALID_TYPESTATE = 65, + JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED = 66, + JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED = 67, + JVMTI_ERROR_UNSUPPORTED_VERSION = 68, + JVMTI_ERROR_NAMES_DONT_MATCH = 69, + JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED = 70, + JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED = 71, + JVMTI_ERROR_UNMODIFIABLE_CLASS = 79, + JVMTI_ERROR_NOT_AVAILABLE = 98, + JVMTI_ERROR_MUST_POSSESS_CAPABILITY = 99, + JVMTI_ERROR_NULL_POINTER = 100, + JVMTI_ERROR_ABSENT_INFORMATION = 101, + JVMTI_ERROR_INVALID_EVENT_TYPE = 102, + JVMTI_ERROR_ILLEGAL_ARGUMENT = 103, + JVMTI_ERROR_NATIVE_METHOD = 104, + JVMTI_ERROR_OUT_OF_MEMORY = 110, + JVMTI_ERROR_ACCESS_DENIED = 111, + JVMTI_ERROR_WRONG_PHASE = 112, + JVMTI_ERROR_INTERNAL = 113, + JVMTI_ERROR_UNATTACHED_THREAD = 115, + JVMTI_ERROR_INVALID_ENVIRONMENT = 116, + JVMTI_ERROR_MAX = 116 +} jvmtiError; + + /* Event IDs */ + +typedef enum { + JVMTI_MIN_EVENT_TYPE_VAL = 50, + JVMTI_EVENT_VM_INIT = 50, + JVMTI_EVENT_VM_DEATH = 51, + JVMTI_EVENT_THREAD_START = 52, + JVMTI_EVENT_THREAD_END = 53, + JVMTI_EVENT_CLASS_FILE_LOAD_HOOK = 54, + JVMTI_EVENT_CLASS_LOAD = 55, + JVMTI_EVENT_CLASS_PREPARE = 56, + JVMTI_EVENT_VM_START = 57, + JVMTI_EVENT_EXCEPTION = 58, + JVMTI_EVENT_EXCEPTION_CATCH = 59, + JVMTI_EVENT_SINGLE_STEP = 60, + JVMTI_EVENT_FRAME_POP = 61, + JVMTI_EVENT_BREAKPOINT = 62, + JVMTI_EVENT_FIELD_ACCESS = 63, + JVMTI_EVENT_FIELD_MODIFICATION = 64, + JVMTI_EVENT_METHOD_ENTRY = 65, + JVMTI_EVENT_METHOD_EXIT = 66, + JVMTI_EVENT_NATIVE_METHOD_BIND = 67, + JVMTI_EVENT_COMPILED_METHOD_LOAD = 68, + JVMTI_EVENT_COMPILED_METHOD_UNLOAD = 69, + JVMTI_EVENT_DYNAMIC_CODE_GENERATED = 70, + JVMTI_EVENT_DATA_DUMP_REQUEST = 71, + JVMTI_EVENT_MONITOR_WAIT = 73, + JVMTI_EVENT_MONITOR_WAITED = 74, + JVMTI_EVENT_MONITOR_CONTENDED_ENTER = 75, + JVMTI_EVENT_MONITOR_CONTENDED_ENTERED = 76, + JVMTI_EVENT_GARBAGE_COLLECTION_START = 81, + JVMTI_EVENT_GARBAGE_COLLECTION_FINISH = 82, + JVMTI_EVENT_OBJECT_FREE = 83, + JVMTI_EVENT_VM_OBJECT_ALLOC = 84, + JVMTI_MAX_EVENT_TYPE_VAL = 84 +} jvmtiEvent; + + + /* Function Types */ + +typedef void (JNICALL *jvmtiStartFunction) + (jvmtiEnv* jvmti_env, JNIEnv* jni_env, void* arg); + +typedef jvmtiIterationControl (JNICALL *jvmtiHeapObjectCallback) + (jlong class_tag, jlong size, jlong* tag_ptr, void* user_data); + +typedef jvmtiIterationControl (JNICALL *jvmtiHeapRootCallback) + (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong* tag_ptr, void* user_data); + +typedef jvmtiIterationControl (JNICALL *jvmtiStackReferenceCallback) + (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong* tag_ptr, jlong thread_tag, jint depth, jmethodID method, jint slot, void* user_data); + +typedef jvmtiIterationControl (JNICALL *jvmtiObjectReferenceCallback) + (jvmtiObjectReferenceKind reference_kind, jlong class_tag, jlong size, jlong* tag_ptr, jlong referrer_tag, jint referrer_index, void* user_data); + +typedef jvmtiError (JNICALL *jvmtiExtensionFunction) + (jvmtiEnv* jvmti_env, ...); + +typedef void (JNICALL *jvmtiExtensionEvent) + (jvmtiEnv* jvmti_env, ...); + + + /* Structure Types */ + +typedef struct { + char* name; + jint priority; + jboolean is_daemon; + jthreadGroup thread_group; + jobject context_class_loader; +} jvmtiThreadInfo; + +typedef struct { + jthreadGroup parent; + char* name; + jint max_priority; + jboolean is_daemon; +} jvmtiThreadGroupInfo; + +typedef struct { + jmethodID method; + jlocation location; +} jvmtiFrameInfo; + +typedef struct { + jthread thread; + jint state; + jvmtiFrameInfo* frame_buffer; + jint frame_count; +} jvmtiStackInfo; + +typedef struct { + jclass klass; + jint class_byte_count; + const unsigned char* class_bytes; +} jvmtiClassDefinition; + +typedef struct { + jthread owner; + jint entry_count; + jint waiter_count; + jthread* waiters; + jint notify_waiter_count; + jthread* notify_waiters; +} jvmtiMonitorUsage; + +typedef struct { + jlocation start_location; + jint line_number; +} jvmtiLineNumberEntry; + +typedef struct { + jlocation start_location; + jint length; + char* name; + char* signature; + char* generic_signature; + jint slot; +} jvmtiLocalVariableEntry; + +typedef struct { + char* name; + jvmtiParamKind kind; + jvmtiParamTypes base_type; + jboolean null_ok; +} jvmtiParamInfo; + +typedef struct { + jvmtiExtensionFunction func; + char* id; + char* short_description; + jint param_count; + jvmtiParamInfo* params; + jint error_count; + jvmtiError* errors; +} jvmtiExtensionFunctionInfo; + +typedef struct { + jint extension_event_index; + char* id; + char* short_description; + jint param_count; + jvmtiParamInfo* params; +} jvmtiExtensionEventInfo; + +typedef struct { + jlong max_value; + jboolean may_skip_forward; + jboolean may_skip_backward; + jvmtiTimerKind kind; + jlong reserved1; + jlong reserved2; +} jvmtiTimerInfo; + +typedef struct { + const void* start_address; + jlocation location; +} jvmtiAddrLocationMap; + +typedef struct { + unsigned int can_tag_objects : 1; + unsigned int can_generate_field_modification_events : 1; + unsigned int can_generate_field_access_events : 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_pop_frame : 1; + unsigned int can_redefine_classes : 1; + unsigned int can_signal_thread : 1; + unsigned int can_get_source_file_name : 1; + unsigned int can_get_line_numbers : 1; + unsigned int can_get_source_debug_extension : 1; + unsigned int can_access_local_variables : 1; + unsigned int can_maintain_original_method_order : 1; + unsigned int can_generate_single_step_events : 1; + unsigned int can_generate_exception_events : 1; + unsigned int can_generate_frame_pop_events : 1; + unsigned int can_generate_breakpoint_events : 1; + unsigned int can_suspend : 1; + unsigned int can_redefine_any_class : 1; + unsigned int can_get_current_thread_cpu_time : 1; + unsigned int can_get_thread_cpu_time : 1; + unsigned int can_generate_method_entry_events : 1; + unsigned int can_generate_method_exit_events : 1; + unsigned int can_generate_all_class_hook_events : 1; + unsigned int can_generate_compiled_method_load_events : 1; + unsigned int can_generate_monitor_events : 1; + unsigned int can_generate_vm_object_alloc_events : 1; + unsigned int can_generate_native_method_bind_events : 1; + unsigned int can_generate_garbage_collection_events : 1; + unsigned int can_generate_object_free_events : 1; + unsigned int : 15; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; +} jvmtiCapabilities; + + + /* Event Definitions */ + +typedef void (JNICALL *jvmtiEventReserved)(void); + + +typedef void (JNICALL *jvmtiEventBreakpoint) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jlocation location); + +typedef void (JNICALL *jvmtiEventClassFileLoadHook) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jclass class_being_redefined, + jobject loader, + const char* name, + jobject protection_domain, + jint class_data_len, + const unsigned char* class_data, + jint* new_class_data_len, + unsigned char** new_class_data); + +typedef void (JNICALL *jvmtiEventClassLoad) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jclass klass); + +typedef void (JNICALL *jvmtiEventClassPrepare) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jclass klass); + +typedef void (JNICALL *jvmtiEventCompiledMethodLoad) + (jvmtiEnv *jvmti_env, + jmethodID method, + jint code_size, + const void* code_addr, + jint map_length, + const jvmtiAddrLocationMap* map, + const void* compile_info); + +typedef void (JNICALL *jvmtiEventCompiledMethodUnload) + (jvmtiEnv *jvmti_env, + jmethodID method, + const void* code_addr); + +typedef void (JNICALL *jvmtiEventDataDumpRequest) + (jvmtiEnv *jvmti_env); + +typedef void (JNICALL *jvmtiEventDynamicCodeGenerated) + (jvmtiEnv *jvmti_env, + const char* name, + const void* address, + jint length); + +typedef void (JNICALL *jvmtiEventException) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jlocation location, + jobject exception, + jmethodID catch_method, + jlocation catch_location); + +typedef void (JNICALL *jvmtiEventExceptionCatch) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jlocation location, + jobject exception); + +typedef void (JNICALL *jvmtiEventFieldAccess) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jlocation location, + jclass field_klass, + jobject object, + jfieldID field); + +typedef void (JNICALL *jvmtiEventFieldModification) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jlocation location, + jclass field_klass, + jobject object, + jfieldID field, + char signature_type, + jvalue new_value); + +typedef void (JNICALL *jvmtiEventFramePop) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jboolean was_popped_by_exception); + +typedef void (JNICALL *jvmtiEventGarbageCollectionFinish) + (jvmtiEnv *jvmti_env); + +typedef void (JNICALL *jvmtiEventGarbageCollectionStart) + (jvmtiEnv *jvmti_env); + +typedef void (JNICALL *jvmtiEventMethodEntry) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method); + +typedef void (JNICALL *jvmtiEventMethodExit) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jboolean was_popped_by_exception, + jvalue return_value); + +typedef void (JNICALL *jvmtiEventMonitorContendedEnter) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jobject object); + +typedef void (JNICALL *jvmtiEventMonitorContendedEntered) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jobject object); + +typedef void (JNICALL *jvmtiEventMonitorWait) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jobject object, + jlong timeout); + +typedef void (JNICALL *jvmtiEventMonitorWaited) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jobject object, + jboolean timed_out); + +typedef void (JNICALL *jvmtiEventNativeMethodBind) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + void* address, + void** new_address_ptr); + +typedef void (JNICALL *jvmtiEventObjectFree) + (jvmtiEnv *jvmti_env, + jlong tag); + +typedef void (JNICALL *jvmtiEventSingleStep) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jmethodID method, + jlocation location); + +typedef void (JNICALL *jvmtiEventThreadEnd) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread); + +typedef void (JNICALL *jvmtiEventThreadStart) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread); + +typedef void (JNICALL *jvmtiEventVMDeath) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env); + +typedef void (JNICALL *jvmtiEventVMInit) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread); + +typedef void (JNICALL *jvmtiEventVMObjectAlloc) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env, + jthread thread, + jobject object, + jclass object_klass, + jlong size); + +typedef void (JNICALL *jvmtiEventVMStart) + (jvmtiEnv *jvmti_env, + JNIEnv* jni_env); + + /* Event Callback Structure */ + +typedef struct { + /* 50 : VM Initialization Event */ + jvmtiEventVMInit VMInit; + /* 51 : VM Death Event */ + jvmtiEventVMDeath VMDeath; + /* 52 : Thread Start */ + jvmtiEventThreadStart ThreadStart; + /* 53 : Thread End */ + jvmtiEventThreadEnd ThreadEnd; + /* 54 : Class File Load Hook */ + jvmtiEventClassFileLoadHook ClassFileLoadHook; + /* 55 : Class Load */ + jvmtiEventClassLoad ClassLoad; + /* 56 : Class Prepare */ + jvmtiEventClassPrepare ClassPrepare; + /* 57 : VM Start Event */ + jvmtiEventVMStart VMStart; + /* 58 : Exception */ + jvmtiEventException Exception; + /* 59 : Exception Catch */ + jvmtiEventExceptionCatch ExceptionCatch; + /* 60 : Single Step */ + jvmtiEventSingleStep SingleStep; + /* 61 : Frame Pop */ + jvmtiEventFramePop FramePop; + /* 62 : Breakpoint */ + jvmtiEventBreakpoint Breakpoint; + /* 63 : Field Access */ + jvmtiEventFieldAccess FieldAccess; + /* 64 : Field Modification */ + jvmtiEventFieldModification FieldModification; + /* 65 : Method Entry */ + jvmtiEventMethodEntry MethodEntry; + /* 66 : Method Exit */ + jvmtiEventMethodExit MethodExit; + /* 67 : Native Method Bind */ + jvmtiEventNativeMethodBind NativeMethodBind; + /* 68 : Compiled Method Load */ + jvmtiEventCompiledMethodLoad CompiledMethodLoad; + /* 69 : Compiled Method Unload */ + jvmtiEventCompiledMethodUnload CompiledMethodUnload; + /* 70 : Dynamic Code Generated */ + jvmtiEventDynamicCodeGenerated DynamicCodeGenerated; + /* 71 : Data Dump Request */ + jvmtiEventDataDumpRequest DataDumpRequest; + /* 72 */ + jvmtiEventReserved reserved72; + /* 73 : Monitor Wait */ + jvmtiEventMonitorWait MonitorWait; + /* 74 : Monitor Waited */ + jvmtiEventMonitorWaited MonitorWaited; + /* 75 : Monitor Contended Enter */ + jvmtiEventMonitorContendedEnter MonitorContendedEnter; + /* 76 : Monitor Contended Entered */ + jvmtiEventMonitorContendedEntered MonitorContendedEntered; + /* 77 */ + jvmtiEventReserved reserved77; + /* 78 */ + jvmtiEventReserved reserved78; + /* 79 */ + jvmtiEventReserved reserved79; + /* 80 */ + jvmtiEventReserved reserved80; + /* 81 : Garbage Collection Start */ + jvmtiEventGarbageCollectionStart GarbageCollectionStart; + /* 82 : Garbage Collection Finish */ + jvmtiEventGarbageCollectionFinish GarbageCollectionFinish; + /* 83 : Object Free */ + jvmtiEventObjectFree ObjectFree; + /* 84 : VM Object Allocation */ + jvmtiEventVMObjectAlloc VMObjectAlloc; +} jvmtiEventCallbacks; + + + /* Function Interface */ + +typedef struct jvmtiInterface_1_ { + + /* 1 : RESERVED */ + void *reserved1; + + /* 2 : Set Event Notification Mode */ + jvmtiError (JNICALL *SetEventNotificationMode) (jvmtiEnv* env, + jvmtiEventMode mode, + jvmtiEvent event_type, + jthread event_thread, + ...); + + /* 3 : RESERVED */ + void *reserved3; + + /* 4 : Get All Threads */ + jvmtiError (JNICALL *GetAllThreads) (jvmtiEnv* env, + jint* threads_count_ptr, + jthread** threads_ptr); + + /* 5 : Suspend Thread */ + jvmtiError (JNICALL *SuspendThread) (jvmtiEnv* env, + jthread thread); + + /* 6 : Resume Thread */ + jvmtiError (JNICALL *ResumeThread) (jvmtiEnv* env, + jthread thread); + + /* 7 : Stop Thread */ + jvmtiError (JNICALL *StopThread) (jvmtiEnv* env, + jthread thread, + jobject exception); + + /* 8 : Interrupt Thread */ + jvmtiError (JNICALL *InterruptThread) (jvmtiEnv* env, + jthread thread); + + /* 9 : Get Thread Info */ + jvmtiError (JNICALL *GetThreadInfo) (jvmtiEnv* env, + jthread thread, + jvmtiThreadInfo* info_ptr); + + /* 10 : Get Owned Monitor Info */ + jvmtiError (JNICALL *GetOwnedMonitorInfo) (jvmtiEnv* env, + jthread thread, + jint* owned_monitor_count_ptr, + jobject** owned_monitors_ptr); + + /* 11 : Get Current Contended Monitor */ + jvmtiError (JNICALL *GetCurrentContendedMonitor) (jvmtiEnv* env, + jthread thread, + jobject* monitor_ptr); + + /* 12 : Run Agent Thread */ + jvmtiError (JNICALL *RunAgentThread) (jvmtiEnv* env, + jthread thread, + jvmtiStartFunction proc, + const void* arg, + jint priority); + + /* 13 : Get Top Thread Groups */ + jvmtiError (JNICALL *GetTopThreadGroups) (jvmtiEnv* env, + jint* group_count_ptr, + jthreadGroup** groups_ptr); + + /* 14 : Get Thread Group Info */ + jvmtiError (JNICALL *GetThreadGroupInfo) (jvmtiEnv* env, + jthreadGroup group, + jvmtiThreadGroupInfo* info_ptr); + + /* 15 : Get Thread Group Children */ + jvmtiError (JNICALL *GetThreadGroupChildren) (jvmtiEnv* env, + jthreadGroup group, + jint* thread_count_ptr, + jthread** threads_ptr, + jint* group_count_ptr, + jthreadGroup** groups_ptr); + + /* 16 : Get Frame Count */ + jvmtiError (JNICALL *GetFrameCount) (jvmtiEnv* env, + jthread thread, + jint* count_ptr); + + /* 17 : Get Thread State */ + jvmtiError (JNICALL *GetThreadState) (jvmtiEnv* env, + jthread thread, + jint* thread_state_ptr); + + /* 18 : RESERVED */ + void *reserved18; + + /* 19 : Get Frame Location */ + jvmtiError (JNICALL *GetFrameLocation) (jvmtiEnv* env, + jthread thread, + jint depth, + jmethodID* method_ptr, + jlocation* location_ptr); + + /* 20 : Notify Frame Pop */ + jvmtiError (JNICALL *NotifyFramePop) (jvmtiEnv* env, + jthread thread, + jint depth); + + /* 21 : Get Local Variable - Object */ + jvmtiError (JNICALL *GetLocalObject) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jobject* value_ptr); + + /* 22 : Get Local Variable - Int */ + jvmtiError (JNICALL *GetLocalInt) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jint* value_ptr); + + /* 23 : Get Local Variable - Long */ + jvmtiError (JNICALL *GetLocalLong) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jlong* value_ptr); + + /* 24 : Get Local Variable - Float */ + jvmtiError (JNICALL *GetLocalFloat) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jfloat* value_ptr); + + /* 25 : Get Local Variable - Double */ + jvmtiError (JNICALL *GetLocalDouble) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jdouble* value_ptr); + + /* 26 : Set Local Variable - Object */ + jvmtiError (JNICALL *SetLocalObject) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jobject value); + + /* 27 : Set Local Variable - Int */ + jvmtiError (JNICALL *SetLocalInt) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jint value); + + /* 28 : Set Local Variable - Long */ + jvmtiError (JNICALL *SetLocalLong) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jlong value); + + /* 29 : Set Local Variable - Float */ + jvmtiError (JNICALL *SetLocalFloat) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jfloat value); + + /* 30 : Set Local Variable - Double */ + jvmtiError (JNICALL *SetLocalDouble) (jvmtiEnv* env, + jthread thread, + jint depth, + jint slot, + jdouble value); + + /* 31 : Create Raw Monitor */ + jvmtiError (JNICALL *CreateRawMonitor) (jvmtiEnv* env, + const char* name, + jrawMonitorID* monitor_ptr); + + /* 32 : Destroy Raw Monitor */ + jvmtiError (JNICALL *DestroyRawMonitor) (jvmtiEnv* env, + jrawMonitorID monitor); + + /* 33 : Raw Monitor Enter */ + jvmtiError (JNICALL *RawMonitorEnter) (jvmtiEnv* env, + jrawMonitorID monitor); + + /* 34 : Raw Monitor Exit */ + jvmtiError (JNICALL *RawMonitorExit) (jvmtiEnv* env, + jrawMonitorID monitor); + + /* 35 : Raw Monitor Wait */ + jvmtiError (JNICALL *RawMonitorWait) (jvmtiEnv* env, + jrawMonitorID monitor, + jlong millis); + + /* 36 : Raw Monitor Notify */ + jvmtiError (JNICALL *RawMonitorNotify) (jvmtiEnv* env, + jrawMonitorID monitor); + + /* 37 : Raw Monitor Notify All */ + jvmtiError (JNICALL *RawMonitorNotifyAll) (jvmtiEnv* env, + jrawMonitorID monitor); + + /* 38 : Set Breakpoint */ + jvmtiError (JNICALL *SetBreakpoint) (jvmtiEnv* env, + jmethodID method, + jlocation location); + + /* 39 : Clear Breakpoint */ + jvmtiError (JNICALL *ClearBreakpoint) (jvmtiEnv* env, + jmethodID method, + jlocation location); + + /* 40 : RESERVED */ + void *reserved40; + + /* 41 : Set Field Access Watch */ + jvmtiError (JNICALL *SetFieldAccessWatch) (jvmtiEnv* env, + jclass klass, + jfieldID field); + + /* 42 : Clear Field Access Watch */ + jvmtiError (JNICALL *ClearFieldAccessWatch) (jvmtiEnv* env, + jclass klass, + jfieldID field); + + /* 43 : Set Field Modification Watch */ + jvmtiError (JNICALL *SetFieldModificationWatch) (jvmtiEnv* env, + jclass klass, + jfieldID field); + + /* 44 : Clear Field Modification Watch */ + jvmtiError (JNICALL *ClearFieldModificationWatch) (jvmtiEnv* env, + jclass klass, + jfieldID field); + + /* 45 : RESERVED */ + void *reserved45; + + /* 46 : Allocate */ + jvmtiError (JNICALL *Allocate) (jvmtiEnv* env, + jlong size, + unsigned char** mem_ptr); + + /* 47 : Deallocate */ + jvmtiError (JNICALL *Deallocate) (jvmtiEnv* env, + unsigned char* mem); + + /* 48 : Get Class Signature */ + jvmtiError (JNICALL *GetClassSignature) (jvmtiEnv* env, + jclass klass, + char** signature_ptr, + char** generic_ptr); + + /* 49 : Get Class Status */ + jvmtiError (JNICALL *GetClassStatus) (jvmtiEnv* env, + jclass klass, + jint* status_ptr); + + /* 50 : Get Source File Name */ + jvmtiError (JNICALL *GetSourceFileName) (jvmtiEnv* env, + jclass klass, + char** source_name_ptr); + + /* 51 : Get Class Modifiers */ + jvmtiError (JNICALL *GetClassModifiers) (jvmtiEnv* env, + jclass klass, + jint* modifiers_ptr); + + /* 52 : Get Class Methods */ + jvmtiError (JNICALL *GetClassMethods) (jvmtiEnv* env, + jclass klass, + jint* method_count_ptr, + jmethodID** methods_ptr); + + /* 53 : Get Class Fields */ + jvmtiError (JNICALL *GetClassFields) (jvmtiEnv* env, + jclass klass, + jint* field_count_ptr, + jfieldID** fields_ptr); + + /* 54 : Get Implemented Interfaces */ + jvmtiError (JNICALL *GetImplementedInterfaces) (jvmtiEnv* env, + jclass klass, + jint* interface_count_ptr, + jclass** interfaces_ptr); + + /* 55 : Is Interface */ + jvmtiError (JNICALL *IsInterface) (jvmtiEnv* env, + jclass klass, + jboolean* is_interface_ptr); + + /* 56 : Is Array Class */ + jvmtiError (JNICALL *IsArrayClass) (jvmtiEnv* env, + jclass klass, + jboolean* is_array_class_ptr); + + /* 57 : Get Class Loader */ + jvmtiError (JNICALL *GetClassLoader) (jvmtiEnv* env, + jclass klass, + jobject* classloader_ptr); + + /* 58 : Get Object Hash Code */ + jvmtiError (JNICALL *GetObjectHashCode) (jvmtiEnv* env, + jobject object, + jint* hash_code_ptr); + + /* 59 : Get Object Monitor Usage */ + jvmtiError (JNICALL *GetObjectMonitorUsage) (jvmtiEnv* env, + jobject object, + jvmtiMonitorUsage* info_ptr); + + /* 60 : Get Field Name (and Signature) */ + jvmtiError (JNICALL *GetFieldName) (jvmtiEnv* env, + jclass klass, + jfieldID field, + char** name_ptr, + char** signature_ptr, + char** generic_ptr); + + /* 61 : Get Field Declaring Class */ + jvmtiError (JNICALL *GetFieldDeclaringClass) (jvmtiEnv* env, + jclass klass, + jfieldID field, + jclass* declaring_class_ptr); + + /* 62 : Get Field Modifiers */ + jvmtiError (JNICALL *GetFieldModifiers) (jvmtiEnv* env, + jclass klass, + jfieldID field, + jint* modifiers_ptr); + + /* 63 : Is Field Synthetic */ + jvmtiError (JNICALL *IsFieldSynthetic) (jvmtiEnv* env, + jclass klass, + jfieldID field, + jboolean* is_synthetic_ptr); + + /* 64 : Get Method Name (and Signature) */ + jvmtiError (JNICALL *GetMethodName) (jvmtiEnv* env, + jmethodID method, + char** name_ptr, + char** signature_ptr, + char** generic_ptr); + + /* 65 : Get Method Declaring Class */ + jvmtiError (JNICALL *GetMethodDeclaringClass) (jvmtiEnv* env, + jmethodID method, + jclass* declaring_class_ptr); + + /* 66 : Get Method Modifiers */ + jvmtiError (JNICALL *GetMethodModifiers) (jvmtiEnv* env, + jmethodID method, + jint* modifiers_ptr); + + /* 67 : RESERVED */ + void *reserved67; + + /* 68 : Get Max Locals */ + jvmtiError (JNICALL *GetMaxLocals) (jvmtiEnv* env, + jmethodID method, + jint* max_ptr); + + /* 69 : Get Arguments Size */ + jvmtiError (JNICALL *GetArgumentsSize) (jvmtiEnv* env, + jmethodID method, + jint* size_ptr); + + /* 70 : Get Line Number Table */ + jvmtiError (JNICALL *GetLineNumberTable) (jvmtiEnv* env, + jmethodID method, + jint* entry_count_ptr, + jvmtiLineNumberEntry** table_ptr); + + /* 71 : Get Method Location */ + jvmtiError (JNICALL *GetMethodLocation) (jvmtiEnv* env, + jmethodID method, + jlocation* start_location_ptr, + jlocation* end_location_ptr); + + /* 72 : Get Local Variable Table */ + jvmtiError (JNICALL *GetLocalVariableTable) (jvmtiEnv* env, + jmethodID method, + jint* entry_count_ptr, + jvmtiLocalVariableEntry** table_ptr); + + /* 73 : RESERVED */ + void *reserved73; + + /* 74 : RESERVED */ + void *reserved74; + + /* 75 : Get Bytecodes */ + jvmtiError (JNICALL *GetBytecodes) (jvmtiEnv* env, + jmethodID method, + jint* bytecode_count_ptr, + unsigned char** bytecodes_ptr); + + /* 76 : Is Method Native */ + jvmtiError (JNICALL *IsMethodNative) (jvmtiEnv* env, + jmethodID method, + jboolean* is_native_ptr); + + /* 77 : Is Method Synthetic */ + jvmtiError (JNICALL *IsMethodSynthetic) (jvmtiEnv* env, + jmethodID method, + jboolean* is_synthetic_ptr); + + /* 78 : Get Loaded Classes */ + jvmtiError (JNICALL *GetLoadedClasses) (jvmtiEnv* env, + jint* class_count_ptr, + jclass** classes_ptr); + + /* 79 : Get Classloader Classes */ + jvmtiError (JNICALL *GetClassLoaderClasses) (jvmtiEnv* env, + jobject initiating_loader, + jint* class_count_ptr, + jclass** classes_ptr); + + /* 80 : Pop Frame */ + jvmtiError (JNICALL *PopFrame) (jvmtiEnv* env, + jthread thread); + + /* 81 : RESERVED */ + void *reserved81; + + /* 82 : RESERVED */ + void *reserved82; + + /* 83 : RESERVED */ + void *reserved83; + + /* 84 : RESERVED */ + void *reserved84; + + /* 85 : RESERVED */ + void *reserved85; + + /* 86 : RESERVED */ + void *reserved86; + + /* 87 : Redefine Classes */ + jvmtiError (JNICALL *RedefineClasses) (jvmtiEnv* env, + jint class_count, + const jvmtiClassDefinition* class_definitions); + + /* 88 : Get Version Number */ + jvmtiError (JNICALL *GetVersionNumber) (jvmtiEnv* env, + jint* version_ptr); + + /* 89 : Get Capabilities */ + jvmtiError (JNICALL *GetCapabilities) (jvmtiEnv* env, + jvmtiCapabilities* capabilities_ptr); + + /* 90 : Get Source Debug Extension */ + jvmtiError (JNICALL *GetSourceDebugExtension) (jvmtiEnv* env, + jclass klass, + char** source_debug_extension_ptr); + + /* 91 : Is Method Obsolete */ + jvmtiError (JNICALL *IsMethodObsolete) (jvmtiEnv* env, + jmethodID method, + jboolean* is_obsolete_ptr); + + /* 92 : Suspend Thread List */ + jvmtiError (JNICALL *SuspendThreadList) (jvmtiEnv* env, + jint request_count, + const jthread* request_list, + jvmtiError* results); + + /* 93 : Resume Thread List */ + jvmtiError (JNICALL *ResumeThreadList) (jvmtiEnv* env, + jint request_count, + const jthread* request_list, + jvmtiError* results); + + /* 94 : RESERVED */ + void *reserved94; + + /* 95 : RESERVED */ + void *reserved95; + + /* 96 : RESERVED */ + void *reserved96; + + /* 97 : RESERVED */ + void *reserved97; + + /* 98 : RESERVED */ + void *reserved98; + + /* 99 : RESERVED */ + void *reserved99; + + /* 100 : Get All Stack Traces */ + jvmtiError (JNICALL *GetAllStackTraces) (jvmtiEnv* env, + jint max_frame_count, + jvmtiStackInfo** stack_info_ptr, + jint* thread_count_ptr); + + /* 101 : Get Thread List Stack Traces */ + jvmtiError (JNICALL *GetThreadListStackTraces) (jvmtiEnv* env, + jint thread_count, + const jthread* thread_list, + jint max_frame_count, + jvmtiStackInfo** stack_info_ptr); + + /* 102 : Get Thread Local Storage */ + jvmtiError (JNICALL *GetThreadLocalStorage) (jvmtiEnv* env, + jthread thread, + void** data_ptr); + + /* 103 : Set Thread Local Storage */ + jvmtiError (JNICALL *SetThreadLocalStorage) (jvmtiEnv* env, + jthread thread, + const void* data); + + /* 104 : Get Stack Trace */ + jvmtiError (JNICALL *GetStackTrace) (jvmtiEnv* env, + jthread thread, + jint start_depth, + jint max_frame_count, + jvmtiFrameInfo* frame_buffer, + jint* count_ptr); + + /* 105 : RESERVED */ + void *reserved105; + + /* 106 : Get Tag */ + jvmtiError (JNICALL *GetTag) (jvmtiEnv* env, + jobject object, + jlong* tag_ptr); + + /* 107 : Set Tag */ + jvmtiError (JNICALL *SetTag) (jvmtiEnv* env, + jobject object, + jlong tag); + + /* 108 : Force Garbage Collection */ + jvmtiError (JNICALL *ForceGarbageCollection) (jvmtiEnv* env); + + /* 109 : Iterate Over Objects Reachable From Object */ + jvmtiError (JNICALL *IterateOverObjectsReachableFromObject) (jvmtiEnv* env, + jobject object, + jvmtiObjectReferenceCallback object_reference_callback, + void* user_data); + + /* 110 : Iterate Over Reachable Objects */ + jvmtiError (JNICALL *IterateOverReachableObjects) (jvmtiEnv* env, + jvmtiHeapRootCallback heap_root_callback, + jvmtiStackReferenceCallback stack_ref_callback, + jvmtiObjectReferenceCallback object_ref_callback, + void* user_data); + + /* 111 : Iterate Over Heap */ + jvmtiError (JNICALL *IterateOverHeap) (jvmtiEnv* env, + jvmtiHeapObjectFilter object_filter, + jvmtiHeapObjectCallback heap_object_callback, + void* user_data); + + /* 112 : Iterate Over Instances Of Class */ + jvmtiError (JNICALL *IterateOverInstancesOfClass) (jvmtiEnv* env, + jclass klass, + jvmtiHeapObjectFilter object_filter, + jvmtiHeapObjectCallback heap_object_callback, + void* user_data); + + /* 113 : RESERVED */ + void *reserved113; + + /* 114 : Get Objects With Tags */ + jvmtiError (JNICALL *GetObjectsWithTags) (jvmtiEnv* env, + jint tag_count, + const jlong* tags, + jint* count_ptr, + jobject** object_result_ptr, + jlong** tag_result_ptr); + + /* 115 : RESERVED */ + void *reserved115; + + /* 116 : RESERVED */ + void *reserved116; + + /* 117 : RESERVED */ + void *reserved117; + + /* 118 : RESERVED */ + void *reserved118; + + /* 119 : RESERVED */ + void *reserved119; + + /* 120 : Set JNI Function Table */ + jvmtiError (JNICALL *SetJNIFunctionTable) (jvmtiEnv* env, + const jniNativeInterface* function_table); + + /* 121 : Get JNI Function Table */ + jvmtiError (JNICALL *GetJNIFunctionTable) (jvmtiEnv* env, + jniNativeInterface** function_table); + + /* 122 : Set Event Callbacks */ + jvmtiError (JNICALL *SetEventCallbacks) (jvmtiEnv* env, + const jvmtiEventCallbacks* callbacks, + jint size_of_callbacks); + + /* 123 : Generate Events */ + jvmtiError (JNICALL *GenerateEvents) (jvmtiEnv* env, + jvmtiEvent event_type); + + /* 124 : Get Extension Functions */ + jvmtiError (JNICALL *GetExtensionFunctions) (jvmtiEnv* env, + jint* extension_count_ptr, + jvmtiExtensionFunctionInfo** extensions); + + /* 125 : Get Extension Events */ + jvmtiError (JNICALL *GetExtensionEvents) (jvmtiEnv* env, + jint* extension_count_ptr, + jvmtiExtensionEventInfo** extensions); + + /* 126 : Set Extension Event Callback */ + jvmtiError (JNICALL *SetExtensionEventCallback) (jvmtiEnv* env, + jint extension_event_index, + jvmtiExtensionEvent callback); + + /* 127 : Dispose Environment */ + jvmtiError (JNICALL *DisposeEnvironment) (jvmtiEnv* env); + + /* 128 : Get Error Name */ + jvmtiError (JNICALL *GetErrorName) (jvmtiEnv* env, + jvmtiError error, + char** name_ptr); + + /* 129 : Get JLocation Format */ + jvmtiError (JNICALL *GetJLocationFormat) (jvmtiEnv* env, + jvmtiJlocationFormat* format_ptr); + + /* 130 : Get System Properties */ + jvmtiError (JNICALL *GetSystemProperties) (jvmtiEnv* env, + jint* count_ptr, + char*** property_ptr); + + /* 131 : Get System Property */ + jvmtiError (JNICALL *GetSystemProperty) (jvmtiEnv* env, + const char* property, + char** value_ptr); + + /* 132 : Set System Property */ + jvmtiError (JNICALL *SetSystemProperty) (jvmtiEnv* env, + const char* property, + const char* value); + + /* 133 : Get Phase */ + jvmtiError (JNICALL *GetPhase) (jvmtiEnv* env, + jvmtiPhase* phase_ptr); + + /* 134 : Get Current Thread CPU Timer Information */ + jvmtiError (JNICALL *GetCurrentThreadCpuTimerInfo) (jvmtiEnv* env, + jvmtiTimerInfo* info_ptr); + + /* 135 : Get Current Thread CPU Time */ + jvmtiError (JNICALL *GetCurrentThreadCpuTime) (jvmtiEnv* env, + jlong* nanos_ptr); + + /* 136 : Get Thread CPU Timer Information */ + jvmtiError (JNICALL *GetThreadCpuTimerInfo) (jvmtiEnv* env, + jvmtiTimerInfo* info_ptr); + + /* 137 : Get Thread CPU Time */ + jvmtiError (JNICALL *GetThreadCpuTime) (jvmtiEnv* env, + jthread thread, + jlong* nanos_ptr); + + /* 138 : Get Timer Information */ + jvmtiError (JNICALL *GetTimerInfo) (jvmtiEnv* env, + jvmtiTimerInfo* info_ptr); + + /* 139 : Get Time */ + jvmtiError (JNICALL *GetTime) (jvmtiEnv* env, + jlong* nanos_ptr); + + /* 140 : Get Potential Capabilities */ + jvmtiError (JNICALL *GetPotentialCapabilities) (jvmtiEnv* env, + jvmtiCapabilities* capabilities_ptr); + + /* 141 : RESERVED */ + void *reserved141; + + /* 142 : Add Capabilities */ + jvmtiError (JNICALL *AddCapabilities) (jvmtiEnv* env, + const jvmtiCapabilities* capabilities_ptr); + + /* 143 : Relinquish Capabilities */ + jvmtiError (JNICALL *RelinquishCapabilities) (jvmtiEnv* env, + const jvmtiCapabilities* capabilities_ptr); + + /* 144 : Get Available Processors */ + jvmtiError (JNICALL *GetAvailableProcessors) (jvmtiEnv* env, + jint* processor_count_ptr); + + /* 145 : RESERVED */ + void *reserved145; + + /* 146 : RESERVED */ + void *reserved146; + + /* 147 : Get Environment Local Storage */ + jvmtiError (JNICALL *GetEnvironmentLocalStorage) (jvmtiEnv* env, + void** data_ptr); + + /* 148 : Set Environment Local Storage */ + jvmtiError (JNICALL *SetEnvironmentLocalStorage) (jvmtiEnv* env, + const void* data); + + /* 149 : Add To Bootstrap Class Loader Search */ + jvmtiError (JNICALL *AddToBootstrapClassLoaderSearch) (jvmtiEnv* env, + const char* segment); + + /* 150 : Set Verbose Flag */ + jvmtiError (JNICALL *SetVerboseFlag) (jvmtiEnv* env, + jvmtiVerboseFlag flag, + jboolean value); + + /* 151 : RESERVED */ + void *reserved151; + + /* 152 : RESERVED */ + void *reserved152; + + /* 153 : RESERVED */ + void *reserved153; + + /* 154 : Get Object Size */ + jvmtiError (JNICALL *GetObjectSize) (jvmtiEnv* env, + jobject object, + jlong* size_ptr); + +} jvmtiInterface_1; + +struct _jvmtiEnv { + const struct jvmtiInterface_1_ *functions; +#ifdef __cplusplus + + + jvmtiError Allocate(jlong size, + unsigned char** mem_ptr) { + return functions->Allocate(this, size, mem_ptr); + } + + jvmtiError Deallocate(unsigned char* mem) { + return functions->Deallocate(this, mem); + } + + jvmtiError GetThreadState(jthread thread, + jint* thread_state_ptr) { + return functions->GetThreadState(this, thread, thread_state_ptr); + } + + jvmtiError GetAllThreads(jint* threads_count_ptr, + jthread** threads_ptr) { + return functions->GetAllThreads(this, threads_count_ptr, threads_ptr); + } + + jvmtiError SuspendThread(jthread thread) { + return functions->SuspendThread(this, thread); + } + + jvmtiError SuspendThreadList(jint request_count, + const jthread* request_list, + jvmtiError* results) { + return functions->SuspendThreadList(this, request_count, request_list, results); + } + + jvmtiError ResumeThread(jthread thread) { + return functions->ResumeThread(this, thread); + } + + jvmtiError ResumeThreadList(jint request_count, + const jthread* request_list, + jvmtiError* results) { + return functions->ResumeThreadList(this, request_count, request_list, results); + } + + jvmtiError StopThread(jthread thread, + jobject exception) { + return functions->StopThread(this, thread, exception); + } + + jvmtiError InterruptThread(jthread thread) { + return functions->InterruptThread(this, thread); + } + + jvmtiError GetThreadInfo(jthread thread, + jvmtiThreadInfo* info_ptr) { + return functions->GetThreadInfo(this, thread, info_ptr); + } + + jvmtiError GetOwnedMonitorInfo(jthread thread, + jint* owned_monitor_count_ptr, + jobject** owned_monitors_ptr) { + return functions->GetOwnedMonitorInfo(this, thread, owned_monitor_count_ptr, owned_monitors_ptr); + } + + jvmtiError GetCurrentContendedMonitor(jthread thread, + jobject* monitor_ptr) { + return functions->GetCurrentContendedMonitor(this, thread, monitor_ptr); + } + + jvmtiError RunAgentThread(jthread thread, + jvmtiStartFunction proc, + const void* arg, + jint priority) { + return functions->RunAgentThread(this, thread, proc, arg, priority); + } + + jvmtiError SetThreadLocalStorage(jthread thread, + const void* data) { + return functions->SetThreadLocalStorage(this, thread, data); + } + + jvmtiError GetThreadLocalStorage(jthread thread, + void** data_ptr) { + return functions->GetThreadLocalStorage(this, thread, data_ptr); + } + + jvmtiError GetTopThreadGroups(jint* group_count_ptr, + jthreadGroup** groups_ptr) { + return functions->GetTopThreadGroups(this, group_count_ptr, groups_ptr); + } + + jvmtiError GetThreadGroupInfo(jthreadGroup group, + jvmtiThreadGroupInfo* info_ptr) { + return functions->GetThreadGroupInfo(this, group, info_ptr); + } + + jvmtiError GetThreadGroupChildren(jthreadGroup group, + jint* thread_count_ptr, + jthread** threads_ptr, + jint* group_count_ptr, + jthreadGroup** groups_ptr) { + return functions->GetThreadGroupChildren(this, group, thread_count_ptr, threads_ptr, group_count_ptr, groups_ptr); + } + + jvmtiError GetStackTrace(jthread thread, + jint start_depth, + jint max_frame_count, + jvmtiFrameInfo* frame_buffer, + jint* count_ptr) { + return functions->GetStackTrace(this, thread, start_depth, max_frame_count, frame_buffer, count_ptr); + } + + jvmtiError GetAllStackTraces(jint max_frame_count, + jvmtiStackInfo** stack_info_ptr, + jint* thread_count_ptr) { + return functions->GetAllStackTraces(this, max_frame_count, stack_info_ptr, thread_count_ptr); + } + + jvmtiError GetThreadListStackTraces(jint thread_count, + const jthread* thread_list, + jint max_frame_count, + jvmtiStackInfo** stack_info_ptr) { + return functions->GetThreadListStackTraces(this, thread_count, thread_list, max_frame_count, stack_info_ptr); + } + + jvmtiError GetFrameCount(jthread thread, + jint* count_ptr) { + return functions->GetFrameCount(this, thread, count_ptr); + } + + jvmtiError PopFrame(jthread thread) { + return functions->PopFrame(this, thread); + } + + jvmtiError GetFrameLocation(jthread thread, + jint depth, + jmethodID* method_ptr, + jlocation* location_ptr) { + return functions->GetFrameLocation(this, thread, depth, method_ptr, location_ptr); + } + + jvmtiError NotifyFramePop(jthread thread, + jint depth) { + return functions->NotifyFramePop(this, thread, depth); + } + + jvmtiError GetTag(jobject object, + jlong* tag_ptr) { + return functions->GetTag(this, object, tag_ptr); + } + + jvmtiError SetTag(jobject object, + jlong tag) { + return functions->SetTag(this, object, tag); + } + + jvmtiError ForceGarbageCollection() { + return functions->ForceGarbageCollection(this); + } + + jvmtiError IterateOverObjectsReachableFromObject(jobject object, + jvmtiObjectReferenceCallback object_reference_callback, + void* user_data) { + return functions->IterateOverObjectsReachableFromObject(this, object, object_reference_callback, user_data); + } + + jvmtiError IterateOverReachableObjects(jvmtiHeapRootCallback heap_root_callback, + jvmtiStackReferenceCallback stack_ref_callback, + jvmtiObjectReferenceCallback object_ref_callback, + void* user_data) { + return functions->IterateOverReachableObjects(this, heap_root_callback, stack_ref_callback, object_ref_callback, user_data); + } + + jvmtiError IterateOverHeap(jvmtiHeapObjectFilter object_filter, + jvmtiHeapObjectCallback heap_object_callback, + void* user_data) { + return functions->IterateOverHeap(this, object_filter, heap_object_callback, user_data); + } + + jvmtiError IterateOverInstancesOfClass(jclass klass, + jvmtiHeapObjectFilter object_filter, + jvmtiHeapObjectCallback heap_object_callback, + void* user_data) { + return functions->IterateOverInstancesOfClass(this, klass, object_filter, heap_object_callback, user_data); + } + + jvmtiError GetObjectsWithTags(jint tag_count, + const jlong* tags, + jint* count_ptr, + jobject** object_result_ptr, + jlong** tag_result_ptr) { + return functions->GetObjectsWithTags(this, tag_count, tags, count_ptr, object_result_ptr, tag_result_ptr); + } + + jvmtiError GetLocalObject(jthread thread, + jint depth, + jint slot, + jobject* value_ptr) { + return functions->GetLocalObject(this, thread, depth, slot, value_ptr); + } + + jvmtiError GetLocalInt(jthread thread, + jint depth, + jint slot, + jint* value_ptr) { + return functions->GetLocalInt(this, thread, depth, slot, value_ptr); + } + + jvmtiError GetLocalLong(jthread thread, + jint depth, + jint slot, + jlong* value_ptr) { + return functions->GetLocalLong(this, thread, depth, slot, value_ptr); + } + + jvmtiError GetLocalFloat(jthread thread, + jint depth, + jint slot, + jfloat* value_ptr) { + return functions->GetLocalFloat(this, thread, depth, slot, value_ptr); + } + + jvmtiError GetLocalDouble(jthread thread, + jint depth, + jint slot, + jdouble* value_ptr) { + return functions->GetLocalDouble(this, thread, depth, slot, value_ptr); + } + + jvmtiError SetLocalObject(jthread thread, + jint depth, + jint slot, + jobject value) { + return functions->SetLocalObject(this, thread, depth, slot, value); + } + + jvmtiError SetLocalInt(jthread thread, + jint depth, + jint slot, + jint value) { + return functions->SetLocalInt(this, thread, depth, slot, value); + } + + jvmtiError SetLocalLong(jthread thread, + jint depth, + jint slot, + jlong value) { + return functions->SetLocalLong(this, thread, depth, slot, value); + } + + jvmtiError SetLocalFloat(jthread thread, + jint depth, + jint slot, + jfloat value) { + return functions->SetLocalFloat(this, thread, depth, slot, value); + } + + jvmtiError SetLocalDouble(jthread thread, + jint depth, + jint slot, + jdouble value) { + return functions->SetLocalDouble(this, thread, depth, slot, value); + } + + jvmtiError SetBreakpoint(jmethodID method, + jlocation location) { + return functions->SetBreakpoint(this, method, location); + } + + jvmtiError ClearBreakpoint(jmethodID method, + jlocation location) { + return functions->ClearBreakpoint(this, method, location); + } + + jvmtiError SetFieldAccessWatch(jclass klass, + jfieldID field) { + return functions->SetFieldAccessWatch(this, klass, field); + } + + jvmtiError ClearFieldAccessWatch(jclass klass, + jfieldID field) { + return functions->ClearFieldAccessWatch(this, klass, field); + } + + jvmtiError SetFieldModificationWatch(jclass klass, + jfieldID field) { + return functions->SetFieldModificationWatch(this, klass, field); + } + + jvmtiError ClearFieldModificationWatch(jclass klass, + jfieldID field) { + return functions->ClearFieldModificationWatch(this, klass, field); + } + + jvmtiError GetLoadedClasses(jint* class_count_ptr, + jclass** classes_ptr) { + return functions->GetLoadedClasses(this, class_count_ptr, classes_ptr); + } + + jvmtiError GetClassLoaderClasses(jobject initiating_loader, + jint* class_count_ptr, + jclass** classes_ptr) { + return functions->GetClassLoaderClasses(this, initiating_loader, class_count_ptr, classes_ptr); + } + + jvmtiError GetClassSignature(jclass klass, + char** signature_ptr, + char** generic_ptr) { + return functions->GetClassSignature(this, klass, signature_ptr, generic_ptr); + } + + jvmtiError GetClassStatus(jclass klass, + jint* status_ptr) { + return functions->GetClassStatus(this, klass, status_ptr); + } + + jvmtiError GetSourceFileName(jclass klass, + char** source_name_ptr) { + return functions->GetSourceFileName(this, klass, source_name_ptr); + } + + jvmtiError GetClassModifiers(jclass klass, + jint* modifiers_ptr) { + return functions->GetClassModifiers(this, klass, modifiers_ptr); + } + + jvmtiError GetClassMethods(jclass klass, + jint* method_count_ptr, + jmethodID** methods_ptr) { + return functions->GetClassMethods(this, klass, method_count_ptr, methods_ptr); + } + + jvmtiError GetClassFields(jclass klass, + jint* field_count_ptr, + jfieldID** fields_ptr) { + return functions->GetClassFields(this, klass, field_count_ptr, fields_ptr); + } + + jvmtiError GetImplementedInterfaces(jclass klass, + jint* interface_count_ptr, + jclass** interfaces_ptr) { + return functions->GetImplementedInterfaces(this, klass, interface_count_ptr, interfaces_ptr); + } + + jvmtiError IsInterface(jclass klass, + jboolean* is_interface_ptr) { + return functions->IsInterface(this, klass, is_interface_ptr); + } + + jvmtiError IsArrayClass(jclass klass, + jboolean* is_array_class_ptr) { + return functions->IsArrayClass(this, klass, is_array_class_ptr); + } + + jvmtiError GetClassLoader(jclass klass, + jobject* classloader_ptr) { + return functions->GetClassLoader(this, klass, classloader_ptr); + } + + jvmtiError GetSourceDebugExtension(jclass klass, + char** source_debug_extension_ptr) { + return functions->GetSourceDebugExtension(this, klass, source_debug_extension_ptr); + } + + jvmtiError RedefineClasses(jint class_count, + const jvmtiClassDefinition* class_definitions) { + return functions->RedefineClasses(this, class_count, class_definitions); + } + + jvmtiError GetObjectSize(jobject object, + jlong* size_ptr) { + return functions->GetObjectSize(this, object, size_ptr); + } + + jvmtiError GetObjectHashCode(jobject object, + jint* hash_code_ptr) { + return functions->GetObjectHashCode(this, object, hash_code_ptr); + } + + jvmtiError GetObjectMonitorUsage(jobject object, + jvmtiMonitorUsage* info_ptr) { + return functions->GetObjectMonitorUsage(this, object, info_ptr); + } + + jvmtiError GetFieldName(jclass klass, + jfieldID field, + char** name_ptr, + char** signature_ptr, + char** generic_ptr) { + return functions->GetFieldName(this, klass, field, name_ptr, signature_ptr, generic_ptr); + } + + jvmtiError GetFieldDeclaringClass(jclass klass, + jfieldID field, + jclass* declaring_class_ptr) { + return functions->GetFieldDeclaringClass(this, klass, field, declaring_class_ptr); + } + + jvmtiError GetFieldModifiers(jclass klass, + jfieldID field, + jint* modifiers_ptr) { + return functions->GetFieldModifiers(this, klass, field, modifiers_ptr); + } + + jvmtiError IsFieldSynthetic(jclass klass, + jfieldID field, + jboolean* is_synthetic_ptr) { + return functions->IsFieldSynthetic(this, klass, field, is_synthetic_ptr); + } + + jvmtiError GetMethodName(jmethodID method, + char** name_ptr, + char** signature_ptr, + char** generic_ptr) { + return functions->GetMethodName(this, method, name_ptr, signature_ptr, generic_ptr); + } + + jvmtiError GetMethodDeclaringClass(jmethodID method, + jclass* declaring_class_ptr) { + return functions->GetMethodDeclaringClass(this, method, declaring_class_ptr); + } + + jvmtiError GetMethodModifiers(jmethodID method, + jint* modifiers_ptr) { + return functions->GetMethodModifiers(this, method, modifiers_ptr); + } + + jvmtiError GetMaxLocals(jmethodID method, + jint* max_ptr) { + return functions->GetMaxLocals(this, method, max_ptr); + } + + jvmtiError GetArgumentsSize(jmethodID method, + jint* size_ptr) { + return functions->GetArgumentsSize(this, method, size_ptr); + } + + jvmtiError GetLineNumberTable(jmethodID method, + jint* entry_count_ptr, + jvmtiLineNumberEntry** table_ptr) { + return functions->GetLineNumberTable(this, method, entry_count_ptr, table_ptr); + } + + jvmtiError GetMethodLocation(jmethodID method, + jlocation* start_location_ptr, + jlocation* end_location_ptr) { + return functions->GetMethodLocation(this, method, start_location_ptr, end_location_ptr); + } + + jvmtiError GetLocalVariableTable(jmethodID method, + jint* entry_count_ptr, + jvmtiLocalVariableEntry** table_ptr) { + return functions->GetLocalVariableTable(this, method, entry_count_ptr, table_ptr); + } + + jvmtiError GetBytecodes(jmethodID method, + jint* bytecode_count_ptr, + unsigned char** bytecodes_ptr) { + return functions->GetBytecodes(this, method, bytecode_count_ptr, bytecodes_ptr); + } + + jvmtiError IsMethodNative(jmethodID method, + jboolean* is_native_ptr) { + return functions->IsMethodNative(this, method, is_native_ptr); + } + + jvmtiError IsMethodSynthetic(jmethodID method, + jboolean* is_synthetic_ptr) { + return functions->IsMethodSynthetic(this, method, is_synthetic_ptr); + } + + jvmtiError IsMethodObsolete(jmethodID method, + jboolean* is_obsolete_ptr) { + return functions->IsMethodObsolete(this, method, is_obsolete_ptr); + } + + jvmtiError CreateRawMonitor(const char* name, + jrawMonitorID* monitor_ptr) { + return functions->CreateRawMonitor(this, name, monitor_ptr); + } + + jvmtiError DestroyRawMonitor(jrawMonitorID monitor) { + return functions->DestroyRawMonitor(this, monitor); + } + + jvmtiError RawMonitorEnter(jrawMonitorID monitor) { + return functions->RawMonitorEnter(this, monitor); + } + + jvmtiError RawMonitorExit(jrawMonitorID monitor) { + return functions->RawMonitorExit(this, monitor); + } + + jvmtiError RawMonitorWait(jrawMonitorID monitor, + jlong millis) { + return functions->RawMonitorWait(this, monitor, millis); + } + + jvmtiError RawMonitorNotify(jrawMonitorID monitor) { + return functions->RawMonitorNotify(this, monitor); + } + + jvmtiError RawMonitorNotifyAll(jrawMonitorID monitor) { + return functions->RawMonitorNotifyAll(this, monitor); + } + + jvmtiError SetJNIFunctionTable(const jniNativeInterface* function_table) { + return functions->SetJNIFunctionTable(this, function_table); + } + + jvmtiError GetJNIFunctionTable(jniNativeInterface** function_table) { + return functions->GetJNIFunctionTable(this, function_table); + } + + jvmtiError SetEventCallbacks(const jvmtiEventCallbacks* callbacks, + jint size_of_callbacks) { + return functions->SetEventCallbacks(this, callbacks, size_of_callbacks); + } + + jvmtiError SetEventNotificationMode(jvmtiEventMode mode, + jvmtiEvent event_type, + jthread event_thread, + ...) { + return functions->SetEventNotificationMode(this, mode, event_type, event_thread); + } + + jvmtiError GenerateEvents(jvmtiEvent event_type) { + return functions->GenerateEvents(this, event_type); + } + + jvmtiError GetExtensionFunctions(jint* extension_count_ptr, + jvmtiExtensionFunctionInfo** extensions) { + return functions->GetExtensionFunctions(this, extension_count_ptr, extensions); + } + + jvmtiError GetExtensionEvents(jint* extension_count_ptr, + jvmtiExtensionEventInfo** extensions) { + return functions->GetExtensionEvents(this, extension_count_ptr, extensions); + } + + jvmtiError SetExtensionEventCallback(jint extension_event_index, + jvmtiExtensionEvent callback) { + return functions->SetExtensionEventCallback(this, extension_event_index, callback); + } + + jvmtiError GetPotentialCapabilities(jvmtiCapabilities* capabilities_ptr) { + return functions->GetPotentialCapabilities(this, capabilities_ptr); + } + + jvmtiError AddCapabilities(const jvmtiCapabilities* capabilities_ptr) { + return functions->AddCapabilities(this, capabilities_ptr); + } + + jvmtiError RelinquishCapabilities(const jvmtiCapabilities* capabilities_ptr) { + return functions->RelinquishCapabilities(this, capabilities_ptr); + } + + jvmtiError GetCapabilities(jvmtiCapabilities* capabilities_ptr) { + return functions->GetCapabilities(this, capabilities_ptr); + } + + jvmtiError GetCurrentThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) { + return functions->GetCurrentThreadCpuTimerInfo(this, info_ptr); + } + + jvmtiError GetCurrentThreadCpuTime(jlong* nanos_ptr) { + return functions->GetCurrentThreadCpuTime(this, nanos_ptr); + } + + jvmtiError GetThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) { + return functions->GetThreadCpuTimerInfo(this, info_ptr); + } + + jvmtiError GetThreadCpuTime(jthread thread, + jlong* nanos_ptr) { + return functions->GetThreadCpuTime(this, thread, nanos_ptr); + } + + jvmtiError GetTimerInfo(jvmtiTimerInfo* info_ptr) { + return functions->GetTimerInfo(this, info_ptr); + } + + jvmtiError GetTime(jlong* nanos_ptr) { + return functions->GetTime(this, nanos_ptr); + } + + jvmtiError GetAvailableProcessors(jint* processor_count_ptr) { + return functions->GetAvailableProcessors(this, processor_count_ptr); + } + + jvmtiError AddToBootstrapClassLoaderSearch(const char* segment) { + return functions->AddToBootstrapClassLoaderSearch(this, segment); + } + + jvmtiError GetSystemProperties(jint* count_ptr, + char*** property_ptr) { + return functions->GetSystemProperties(this, count_ptr, property_ptr); + } + + jvmtiError GetSystemProperty(const char* property, + char** value_ptr) { + return functions->GetSystemProperty(this, property, value_ptr); + } + + jvmtiError SetSystemProperty(const char* property, + const char* value) { + return functions->SetSystemProperty(this, property, value); + } + + jvmtiError GetPhase(jvmtiPhase* phase_ptr) { + return functions->GetPhase(this, phase_ptr); + } + + jvmtiError DisposeEnvironment() { + return functions->DisposeEnvironment(this); + } + + jvmtiError SetEnvironmentLocalStorage(const void* data) { + return functions->SetEnvironmentLocalStorage(this, data); + } + + jvmtiError GetEnvironmentLocalStorage(void** data_ptr) { + return functions->GetEnvironmentLocalStorage(this, data_ptr); + } + + jvmtiError GetVersionNumber(jint* version_ptr) { + return functions->GetVersionNumber(this, version_ptr); + } + + jvmtiError GetErrorName(jvmtiError error, + char** name_ptr) { + return functions->GetErrorName(this, error, name_ptr); + } + + jvmtiError SetVerboseFlag(jvmtiVerboseFlag flag, + jboolean value) { + return functions->SetVerboseFlag(this, flag, value); + } + + jvmtiError GetJLocationFormat(jvmtiJlocationFormat* format_ptr) { + return functions->GetJLocationFormat(this, format_ptr); + } + +#endif /* __cplusplus */ +}; + + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* !_JAVA_JVMTI_H_ */ + diff --git a/JavaOpenJPEG/java-jni/include/win32/jawt_md.h b/JavaOpenJPEG/java-jni/include/win32/jawt_md.h new file mode 100644 index 00000000..5df3e469 --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/win32/jawt_md.h @@ -0,0 +1,41 @@ +/* + * @(#)jawt_md.h 1.7 03/12/19 + * + * Copyright 2004 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 +#include "jawt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Win32-specific declarations for AWT native interface. + * See notes in jawt.h for an example of use. + */ +typedef struct jawt_Win32DrawingSurfaceInfo { + /* Native window, DDB, or DIB handle */ + union { + HWND hwnd; + HBITMAP hbitmap; + void* pbits; + }; + /* + * This HDC should always be used instead of the HDC returned from + * BeginPaint() or any calls to GetDC(). + */ + HDC hdc; + HPALETTE hpalette; +} JAWT_Win32DrawingSurfaceInfo; + +#ifdef __cplusplus +} +#endif + +#endif /* !_JAVASOFT_JAWT_MD_H_ */ diff --git a/JavaOpenJPEG/java-jni/include/win32/jni_md.h b/JavaOpenJPEG/java-jni/include/win32/jni_md.h new file mode 100644 index 00000000..fdc79a07 --- /dev/null +++ b/JavaOpenJPEG/java-jni/include/win32/jni_md.h @@ -0,0 +1,19 @@ +/* + * @(#)jni_md.h 1.14 03/12/19 + * + * Copyright 2004 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 __declspec(dllexport) +#define JNIIMPORT __declspec(dllimport) +#define JNICALL __stdcall + +typedef long jint; +typedef __int64 jlong; +typedef signed char jbyte; + +#endif /* !_JAVASOFT_JNI_MD_H_ */ diff --git a/JavaOpenJPEG/java-jni/lib/jvm.lib b/JavaOpenJPEG/java-jni/lib/jvm.lib new file mode 100644 index 0000000000000000000000000000000000000000..672855a0f0f4d9f1d4a5f37637b5c160290e1a5b GIT binary patch literal 273276 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 a6% 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 LWKe?6JmUWYI;fM( literal 0 HcmV?d00001