Skip to content

Instantly share code, notes, and snippets.

@robloxarchiver

robloxarchiver/aio.hpp

Last active January 7, 2025 01:59
Show Gist options
  • Save robloxarchiver/26b9e2bc12f0f4ca160219dffdb61fba to your computer and use it in GitHub Desktop.
Save robloxarchiver/26b9e2bc12f0f4ca160219dffdb61fba to your computer and use it in GitHub Desktop.
Download ZIP
JNI All-In-One for easy usage
Raw
aio.hpp
/*
All-In-One (AIO) JVM/JNI Includes File
Crafted with love by BobloxArchiver/Niggenheimer
Files Included: (In order)
classfile_constants.h
win32/jawt_md.h
win32/jni_md.h
jni.h
jvmti.h
jvmticmlr.h
jawt.h
jdwpTransport.h
win32/bridge/AccessBridgePackages.h
win32/bridge/AccessBridgeCallbacks.h
win32/bridge/AccessBridgeCalls.h
*/
#ifndef JNI_AIO_HPP
#define JNI_AIO_HPP
#include <windows.h>
#include <cstdarg>
#include <cstdio>
#ifndef INTERNAL_CLASSFILE_CONSTANTS
#define INTERNAL_CLASSFILE_CONSTANTS
#ifdef __cplusplus
extern "C"
{
#endif
#define JVM_CLASSFILE_MAJOR_VERSION 65
#define JVM_CLASSFILE_MINOR_VERSION 0
enum
{
JVM_ACC_PUBLIC = 0x0001,
JVM_ACC_PRIVATE = 0x0002,
JVM_ACC_PROTECTED = 0x0004,
JVM_ACC_STATIC = 0x0008,
JVM_ACC_FINAL = 0x0010,
JVM_ACC_SYNCHRONIZED = 0x0020,
JVM_ACC_SUPER = 0x0020,
JVM_ACC_VOLATILE = 0x0040,
JVM_ACC_BRIDGE = 0x0040,
JVM_ACC_TRANSIENT = 0x0080,
JVM_ACC_VARARGS = 0x0080,
JVM_ACC_NATIVE = 0x0100,
JVM_ACC_INTERFACE = 0x0200,
JVM_ACC_ABSTRACT = 0x0400,
JVM_ACC_STRICT = 0x0800,
JVM_ACC_SYNTHETIC = 0x1000,
JVM_ACC_ANNOTATION = 0x2000,
JVM_ACC_ENUM = 0x4000,
JVM_ACC_MODULE = 0x8000
};
#define JVM_ACC_PUBLIC_BIT 0
#define JVM_ACC_PRIVATE_BIT 1
#define JVM_ACC_PROTECTED_BIT 2
#define JVM_ACC_STATIC_BIT 3
#define JVM_ACC_FINAL_BIT 4
#define JVM_ACC_SYNCHRONIZED_BIT 5
#define JVM_ACC_SUPER_BIT 5
#define JVM_ACC_VOLATILE_BIT 6
#define JVM_ACC_BRIDGE_BIT 6
#define JVM_ACC_TRANSIENT_BIT 7
#define JVM_ACC_VARARGS_BIT 7
#define JVM_ACC_NATIVE_BIT 8
#define JVM_ACC_INTERFACE_BIT 9
#define JVM_ACC_ABSTRACT_BIT 10
#define JVM_ACC_STRICT_BIT 11
#define JVM_ACC_SYNTHETIC_BIT 12
#define JVM_ACC_ANNOTATION_BIT 13
#define JVM_ACC_ENUM_BIT 14
enum
{
JVM_T_BOOLEAN = 4,
JVM_T_CHAR = 5,
JVM_T_FLOAT = 6,
JVM_T_DOUBLE = 7,
JVM_T_BYTE = 8,
JVM_T_SHORT = 9,
JVM_T_INT = 10,
JVM_T_LONG = 11
};
enum
{
JVM_CONSTANT_Utf8 = 1,
JVM_CONSTANT_Unicode = 2,
JVM_CONSTANT_Integer = 3,
JVM_CONSTANT_Float = 4,
JVM_CONSTANT_Long = 5,
JVM_CONSTANT_Double = 6,
JVM_CONSTANT_Class = 7,
JVM_CONSTANT_String = 8,
JVM_CONSTANT_Fieldref = 9,
JVM_CONSTANT_Methodref = 10,
JVM_CONSTANT_InterfaceMethodref = 11,
JVM_CONSTANT_NameAndType = 12,
JVM_CONSTANT_MethodHandle = 15,
JVM_CONSTANT_MethodType = 16,
JVM_CONSTANT_Dynamic = 17,
JVM_CONSTANT_InvokeDynamic = 18,
JVM_CONSTANT_Module = 19,
JVM_CONSTANT_Package = 20,
JVM_CONSTANT_ExternalMax = 20
};
enum
{
JVM_REF_getField = 1,
JVM_REF_getStatic = 2,
JVM_REF_putField = 3,
JVM_REF_putStatic = 4,
JVM_REF_invokeVirtual = 5,
JVM_REF_invokeStatic = 6,
JVM_REF_invokeSpecial = 7,
JVM_REF_newInvokeSpecial = 8,
JVM_REF_invokeInterface = 9
};
enum
{
JVM_ITEM_Top = 0,
JVM_ITEM_Integer = 1,
JVM_ITEM_Float = 2,
JVM_ITEM_Double = 3,
JVM_ITEM_Long = 4,
JVM_ITEM_Null = 5,
JVM_ITEM_UninitializedThis = 6,
JVM_ITEM_Object = 7,
JVM_ITEM_Uninitialized = 8
};
enum
{
JVM_SIGNATURE_SLASH = '/',
JVM_SIGNATURE_DOT = '.',
JVM_SIGNATURE_SPECIAL = '<',
JVM_SIGNATURE_ENDSPECIAL = '>',
JVM_SIGNATURE_ARRAY = '[',
JVM_SIGNATURE_BYTE = 'B',
JVM_SIGNATURE_CHAR = 'C',
JVM_SIGNATURE_CLASS = 'L',
JVM_SIGNATURE_ENDCLASS = ';',
JVM_SIGNATURE_ENUM = 'E',
JVM_SIGNATURE_FLOAT = 'F',
JVM_SIGNATURE_DOUBLE = 'D',
JVM_SIGNATURE_FUNC = '(',
JVM_SIGNATURE_ENDFUNC = ')',
JVM_SIGNATURE_INT = 'I',
JVM_SIGNATURE_LONG = 'J',
JVM_SIGNATURE_SHORT = 'S',
JVM_SIGNATURE_VOID = 'V',
JVM_SIGNATURE_BOOLEAN = 'Z'
};
enum
{
JVM_OPC_nop = 0,
JVM_OPC_aconst_null = 1,
JVM_OPC_iconst_m1 = 2,
JVM_OPC_iconst_0 = 3,
JVM_OPC_iconst_1 = 4,
JVM_OPC_iconst_2 = 5,
JVM_OPC_iconst_3 = 6,
JVM_OPC_iconst_4 = 7,
JVM_OPC_iconst_5 = 8,
JVM_OPC_lconst_0 = 9,
JVM_OPC_lconst_1 = 10,
JVM_OPC_fconst_0 = 11,
JVM_OPC_fconst_1 = 12,
JVM_OPC_fconst_2 = 13,
JVM_OPC_dconst_0 = 14,
JVM_OPC_dconst_1 = 15,
JVM_OPC_bipush = 16,
JVM_OPC_sipush = 17,
JVM_OPC_ldc = 18,
JVM_OPC_ldc_w = 19,
JVM_OPC_ldc2_w = 20,
JVM_OPC_iload = 21,
JVM_OPC_lload = 22,
JVM_OPC_fload = 23,
JVM_OPC_dload = 24,
JVM_OPC_aload = 25,
JVM_OPC_iload_0 = 26,
JVM_OPC_iload_1 = 27,
JVM_OPC_iload_2 = 28,
JVM_OPC_iload_3 = 29,
JVM_OPC_lload_0 = 30,
JVM_OPC_lload_1 = 31,
JVM_OPC_lload_2 = 32,
JVM_OPC_lload_3 = 33,
JVM_OPC_fload_0 = 34,
JVM_OPC_fload_1 = 35,
JVM_OPC_fload_2 = 36,
JVM_OPC_fload_3 = 37,
JVM_OPC_dload_0 = 38,
JVM_OPC_dload_1 = 39,
JVM_OPC_dload_2 = 40,
JVM_OPC_dload_3 = 41,
JVM_OPC_aload_0 = 42,
JVM_OPC_aload_1 = 43,
JVM_OPC_aload_2 = 44,
JVM_OPC_aload_3 = 45,
JVM_OPC_iaload = 46,
JVM_OPC_laload = 47,
JVM_OPC_faload = 48,
JVM_OPC_daload = 49,
JVM_OPC_aaload = 50,
JVM_OPC_baload = 51,
JVM_OPC_caload = 52,
JVM_OPC_saload = 53,
JVM_OPC_istore = 54,
JVM_OPC_lstore = 55,
JVM_OPC_fstore = 56,
JVM_OPC_dstore = 57,
JVM_OPC_astore = 58,
JVM_OPC_istore_0 = 59,
JVM_OPC_istore_1 = 60,
JVM_OPC_istore_2 = 61,
JVM_OPC_istore_3 = 62,
JVM_OPC_lstore_0 = 63,
JVM_OPC_lstore_1 = 64,
JVM_OPC_lstore_2 = 65,
JVM_OPC_lstore_3 = 66,
JVM_OPC_fstore_0 = 67,
JVM_OPC_fstore_1 = 68,
JVM_OPC_fstore_2 = 69,
JVM_OPC_fstore_3 = 70,
JVM_OPC_dstore_0 = 71,
JVM_OPC_dstore_1 = 72,
JVM_OPC_dstore_2 = 73,
JVM_OPC_dstore_3 = 74,
JVM_OPC_astore_0 = 75,
JVM_OPC_astore_1 = 76,
JVM_OPC_astore_2 = 77,
JVM_OPC_astore_3 = 78,
JVM_OPC_iastore = 79,
JVM_OPC_lastore = 80,
JVM_OPC_fastore = 81,
JVM_OPC_dastore = 82,
JVM_OPC_aastore = 83,
JVM_OPC_bastore = 84,
JVM_OPC_castore = 85,
JVM_OPC_sastore = 86,
JVM_OPC_pop = 87,
JVM_OPC_pop2 = 88,
JVM_OPC_dup = 89,
JVM_OPC_dup_x1 = 90,
JVM_OPC_dup_x2 = 91,
JVM_OPC_dup2 = 92,
JVM_OPC_dup2_x1 = 93,
JVM_OPC_dup2_x2 = 94,
JVM_OPC_swap = 95,
JVM_OPC_iadd = 96,
JVM_OPC_ladd = 97,
JVM_OPC_fadd = 98,
JVM_OPC_dadd = 99,
JVM_OPC_isub = 100,
JVM_OPC_lsub = 101,
JVM_OPC_fsub = 102,
JVM_OPC_dsub = 103,
JVM_OPC_imul = 104,
JVM_OPC_lmul = 105,
JVM_OPC_fmul = 106,
JVM_OPC_dmul = 107,
JVM_OPC_idiv = 108,
JVM_OPC_ldiv = 109,
JVM_OPC_fdiv = 110,
JVM_OPC_ddiv = 111,
JVM_OPC_irem = 112,
JVM_OPC_lrem = 113,
JVM_OPC_frem = 114,
JVM_OPC_drem = 115,
JVM_OPC_ineg = 116,
JVM_OPC_lneg = 117,
JVM_OPC_fneg = 118,
JVM_OPC_dneg = 119,
JVM_OPC_ishl = 120,
JVM_OPC_lshl = 121,
JVM_OPC_ishr = 122,
JVM_OPC_lshr = 123,
JVM_OPC_iushr = 124,
JVM_OPC_lushr = 125,
JVM_OPC_iand = 126,
JVM_OPC_land = 127,
JVM_OPC_ior = 128,
JVM_OPC_lor = 129,
JVM_OPC_ixor = 130,
JVM_OPC_lxor = 131,
JVM_OPC_iinc = 132,
JVM_OPC_i2l = 133,
JVM_OPC_i2f = 134,
JVM_OPC_i2d = 135,
JVM_OPC_l2i = 136,
JVM_OPC_l2f = 137,
JVM_OPC_l2d = 138,
JVM_OPC_f2i = 139,
JVM_OPC_f2l = 140,
JVM_OPC_f2d = 141,
JVM_OPC_d2i = 142,
JVM_OPC_d2l = 143,
JVM_OPC_d2f = 144,
JVM_OPC_i2b = 145,
JVM_OPC_i2c = 146,
JVM_OPC_i2s = 147,
JVM_OPC_lcmp = 148,
JVM_OPC_fcmpl = 149,
JVM_OPC_fcmpg = 150,
JVM_OPC_dcmpl = 151,
JVM_OPC_dcmpg = 152,
JVM_OPC_ifeq = 153,
JVM_OPC_ifne = 154,
JVM_OPC_iflt = 155,
JVM_OPC_ifge = 156,
JVM_OPC_ifgt = 157,
JVM_OPC_ifle = 158,
JVM_OPC_if_icmpeq = 159,
JVM_OPC_if_icmpne = 160,
JVM_OPC_if_icmplt = 161,
JVM_OPC_if_icmpge = 162,
JVM_OPC_if_icmpgt = 163,
JVM_OPC_if_icmple = 164,
JVM_OPC_if_acmpeq = 165,
JVM_OPC_if_acmpne = 166,
JVM_OPC_goto = 167,
JVM_OPC_jsr = 168,
JVM_OPC_ret = 169,
JVM_OPC_tableswitch = 170,
JVM_OPC_lookupswitch = 171,
JVM_OPC_ireturn = 172,
JVM_OPC_lreturn = 173,
JVM_OPC_freturn = 174,
JVM_OPC_dreturn = 175,
JVM_OPC_areturn = 176,
JVM_OPC_return = 177,
JVM_OPC_getstatic = 178,
JVM_OPC_putstatic = 179,
JVM_OPC_getfield = 180,
JVM_OPC_putfield = 181,
JVM_OPC_invokevirtual = 182,
JVM_OPC_invokespecial = 183,
JVM_OPC_invokestatic = 184,
JVM_OPC_invokeinterface = 185,
JVM_OPC_invokedynamic = 186,
JVM_OPC_new = 187,
JVM_OPC_newarray = 188,
JVM_OPC_anewarray = 189,
JVM_OPC_arraylength = 190,
JVM_OPC_athrow = 191,
JVM_OPC_checkcast = 192,
JVM_OPC_instanceof = 193,
JVM_OPC_monitorenter = 194,
JVM_OPC_monitorexit = 195,
JVM_OPC_wide = 196,
JVM_OPC_multianewarray = 197,
JVM_OPC_ifnull = 198,
JVM_OPC_ifnonnull = 199,
JVM_OPC_goto_w = 200,
JVM_OPC_jsr_w = 201,
JVM_OPC_MAX = 201
};
#define JVM_OPCODE_LENGTH_INITIALIZER { \
1, /* nop */ \
1, /* aconst_null */ \
1, /* iconst_m1 */ \
1, /* iconst_0 */ \
1, /* iconst_1 */ \
1, /* iconst_2 */ \
1, /* iconst_3 */ \
1, /* iconst_4 */ \
1, /* iconst_5 */ \
1, /* lconst_0 */ \
1, /* lconst_1 */ \
1, /* fconst_0 */ \
1, /* fconst_1 */ \
1, /* fconst_2 */ \
1, /* dconst_0 */ \
1, /* dconst_1 */ \
2, /* bipush */ \
3, /* sipush */ \
2, /* ldc */ \
3, /* ldc_w */ \
3, /* ldc2_w */ \
2, /* iload */ \
2, /* lload */ \
2, /* fload */ \
2, /* dload */ \
2, /* aload */ \
1, /* iload_0 */ \
1, /* iload_1 */ \
1, /* iload_2 */ \
1, /* iload_3 */ \
1, /* lload_0 */ \
1, /* lload_1 */ \
1, /* lload_2 */ \
1, /* lload_3 */ \
1, /* fload_0 */ \
1, /* fload_1 */ \
1, /* fload_2 */ \
1, /* fload_3 */ \
1, /* dload_0 */ \
1, /* dload_1 */ \
1, /* dload_2 */ \
1, /* dload_3 */ \
1, /* aload_0 */ \
1, /* aload_1 */ \
1, /* aload_2 */ \
1, /* aload_3 */ \
1, /* iaload */ \
1, /* laload */ \
1, /* faload */ \
1, /* daload */ \
1, /* aaload */ \
1, /* baload */ \
1, /* caload */ \
1, /* saload */ \
2, /* istore */ \
2, /* lstore */ \
2, /* fstore */ \
2, /* dstore */ \
2, /* astore */ \
1, /* istore_0 */ \
1, /* istore_1 */ \
1, /* istore_2 */ \
1, /* istore_3 */ \
1, /* lstore_0 */ \
1, /* lstore_1 */ \
1, /* lstore_2 */ \
1, /* lstore_3 */ \
1, /* fstore_0 */ \
1, /* fstore_1 */ \
1, /* fstore_2 */ \
1, /* fstore_3 */ \
1, /* dstore_0 */ \
1, /* dstore_1 */ \
1, /* dstore_2 */ \
1, /* dstore_3 */ \
1, /* astore_0 */ \
1, /* astore_1 */ \
1, /* astore_2 */ \
1, /* astore_3 */ \
1, /* iastore */ \
1, /* lastore */ \
1, /* fastore */ \
1, /* dastore */ \
1, /* aastore */ \
1, /* bastore */ \
1, /* castore */ \
1, /* sastore */ \
1, /* pop */ \
1, /* pop2 */ \
1, /* dup */ \
1, /* dup_x1 */ \
1, /* dup_x2 */ \
1, /* dup2 */ \
1, /* dup2_x1 */ \
1, /* dup2_x2 */ \
1, /* swap */ \
1, /* iadd */ \
1, /* ladd */ \
1, /* fadd */ \
1, /* dadd */ \
1, /* isub */ \
1, /* lsub */ \
1, /* fsub */ \
1, /* dsub */ \
1, /* imul */ \
1, /* lmul */ \
1, /* fmul */ \
1, /* dmul */ \
1, /* idiv */ \
1, /* ldiv */ \
1, /* fdiv */ \
1, /* ddiv */ \
1, /* irem */ \
1, /* lrem */ \
1, /* frem */ \
1, /* drem */ \
1, /* ineg */ \
1, /* lneg */ \
1, /* fneg */ \
1, /* dneg */ \
1, /* ishl */ \
1, /* lshl */ \
1, /* ishr */ \
1, /* lshr */ \
1, /* iushr */ \
1, /* lushr */ \
1, /* iand */ \
1, /* land */ \
1, /* ior */ \
1, /* lor */ \
1, /* ixor */ \
1, /* lxor */ \
3, /* iinc */ \
1, /* i2l */ \
1, /* i2f */ \
1, /* i2d */ \
1, /* l2i */ \
1, /* l2f */ \
1, /* l2d */ \
1, /* f2i */ \
1, /* f2l */ \
1, /* f2d */ \
1, /* d2i */ \
1, /* d2l */ \
1, /* d2f */ \
1, /* i2b */ \
1, /* i2c */ \
1, /* i2s */ \
1, /* lcmp */ \
1, /* fcmpl */ \
1, /* fcmpg */ \
1, /* dcmpl */ \
1, /* dcmpg */ \
3, /* ifeq */ \
3, /* ifne */ \
3, /* iflt */ \
3, /* ifge */ \
3, /* ifgt */ \
3, /* ifle */ \
3, /* if_icmpeq */ \
3, /* if_icmpne */ \
3, /* if_icmplt */ \
3, /* if_icmpge */ \
3, /* if_icmpgt */ \
3, /* if_icmple */ \
3, /* if_acmpeq */ \
3, /* if_acmpne */ \
3, /* goto */ \
3, /* jsr */ \
2, /* ret */ \
99, /* tableswitch */ \
99, /* lookupswitch */ \
1, /* ireturn */ \
1, /* lreturn */ \
1, /* freturn */ \
1, /* dreturn */ \
1, /* areturn */ \
1, /* return */ \
3, /* getstatic */ \
3, /* putstatic */ \
3, /* getfield */ \
3, /* putfield */ \
3, /* invokevirtual */ \
3, /* invokespecial */ \
3, /* invokestatic */ \
5, /* invokeinterface */ \
5, /* invokedynamic */ \
3, /* new */ \
2, /* newarray */ \
3, /* anewarray */ \
1, /* arraylength */ \
1, /* athrow */ \
3, /* checkcast */ \
3, /* instanceof */ \
1, /* monitorenter */ \
1, /* monitorexit */ \
0, /* wide */ \
4, /* multianewarray */ \
3, /* ifnull */ \
3, /* ifnonnull */ \
5, /* goto_w */ \
5 /* jsr_w */ \
}
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_JAWT_MD
#define INTERNAL_JAWT_MD
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct jawt_Win32DrawingSurfaceInfo
{
union
{
HWND hwnd;
HBITMAP hbitmap;
void *pbits;
};
HDC hdc;
HPALETTE hpalette;
} JAWT_Win32DrawingSurfaceInfo;
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_JNI_MD
#define INTERNAL_JNI_MD
#ifndef JNIEXPORT
#define JNIEXPORT __declspec(dllexport)
#endif
#define JNIIMPORT __declspec(dllimport)
#define JNICALL __stdcall
typedef long jint;
typedef __int64 jlong;
typedef signed char jbyte;
#endif
#ifndef INTERNAL_JNI
#define INTERNAL_JNI
#ifdef __cplusplus
extern "C"
{
#endif
#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;
typedef enum _jobjectType
{
JNIInvalidRefType = 0,
JNILocalRefType = 1,
JNIGlobalRefType = 2,
JNIWeakGlobalRefType = 3
} jobjectRefType;
#endif
#define JNI_FALSE 0
#define JNI_TRUE 1
#define JNI_OK 0
#define JNI_ERR (-1)
#define JNI_EDETACHED (-2)
#define JNI_EVERSION (-3)
#define JNI_ENOMEM (-4)
#define JNI_EEXIST (-5)
#define JNI_EINVAL (-6)
#define JNI_COMMIT 1
#define JNI_ABORT 2
typedef struct
{
char *name;
char *signature;
void *fnPtr;
} JNINativeMethod;
struct JNINativeInterface_;
struct JNIEnv_;
#ifdef __cplusplus
typedef JNIEnv_ JNIEnv;
#else
typedef const struct JNINativeInterface_ *JNIEnv;
#endif
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);
jobjectRefType(JNICALL *GetObjectRefType)(JNIEnv *env, jobject obj);
jobject(JNICALL *GetModule)(JNIEnv *env, jclass clazz);
jboolean(JNICALL *IsVirtualThread)(JNIEnv *env, jobject obj);
};
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;
va_start(args, methodID);
jobject 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;
va_start(args, methodID);
jobject 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;
va_start(args, methodID);
jboolean 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;
va_start(args, methodID);
jbyte 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;
va_start(args, methodID);
jchar 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;
va_start(args, methodID);
jshort 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;
va_start(args, methodID);
jint 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;
va_start(args, methodID);
jlong 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;
va_start(args, methodID);
jfloat 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;
va_start(args, methodID);
jdouble 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;
va_start(args, methodID);
jobject 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;
va_start(args, methodID);
jboolean 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;
va_start(args, methodID);
jbyte 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;
va_start(args, methodID);
jchar 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;
va_start(args, methodID);
jshort 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;
va_start(args, methodID);
jint 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;
va_start(args, methodID);
jlong 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;
va_start(args, methodID);
jfloat 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;
va_start(args, methodID);
jdouble 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;
va_start(args, methodID);
jobject 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;
va_start(args, methodID);
jboolean 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;
va_start(args, methodID);
jbyte 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;
va_start(args, methodID);
jchar 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;
va_start(args, methodID);
jshort 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;
va_start(args, methodID);
jint 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;
va_start(args, methodID);
jlong 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;
va_start(args, methodID);
jfloat 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;
va_start(args, methodID);
jdouble 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, const 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); }
jobjectRefType GetObjectRefType(jobject obj) { return functions->GetObjectRefType(this, obj); }
jobject GetModule(jclass clazz) { return functions->GetModule(this, clazz); }
jboolean IsVirtualThread(jobject obj) { return functions->IsVirtualThread(this, obj); }
#endif
};
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;
#define JDK1_2
#define JDK1_4
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 *);
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
#define JNI_VERSION_1_6 0x00010006
#define JNI_VERSION_1_8 0x00010008
#define JNI_VERSION_9 0x00090000
#define JNI_VERSION_10 0x000a0000
#define JNI_VERSION_19 0x00130000
#define JNI_VERSION_20 0x00140000
#define JNI_VERSION_21 0x00150000
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_JVMTI
#define INTERNAL_JVMTI
#ifdef __cplusplus
extern "C"
{
#endif
enum
{
JVMTI_VERSION_1 = 0x30010000,
JVMTI_VERSION_1_0 = 0x30010000,
JVMTI_VERSION_1_1 = 0x30010100,
JVMTI_VERSION_1_2 = 0x30010200,
JVMTI_VERSION_9 = 0x30090000,
JVMTI_VERSION_11 = 0x300B0000,
JVMTI_VERSION_19 = 0x30130000,
JVMTI_VERSION_21 = 0x30150000,
JVMTI_VERSION = 0x30000000 + (21 * 0x10000) + (0 * 0x100) + 0
};
JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *vm, char *options, void *reserved);
JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM *vm, char *options, void *reserved);
JNIEXPORT void JNICALL Agent_OnUnload(JavaVM *vm);
struct _jvmtiEnv;
struct jvmtiInterface_1_;
#ifdef __cplusplus
typedef _jvmtiEnv jvmtiEnv;
#else
typedef const struct jvmtiInterface_1_ *jvmtiEnv;
#endif
typedef jobject jthread;
typedef jobject jthreadGroup;
typedef jlong jlocation;
struct _jrawMonitorID;
typedef struct _jrawMonitorID *jrawMonitorID;
typedef struct JNINativeInterface_ jniNativeInterface;
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
};
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
};
enum
{
JVMTI_THREAD_MIN_PRIORITY = 1,
JVMTI_THREAD_NORM_PRIORITY = 5,
JVMTI_THREAD_MAX_PRIORITY = 10
};
enum
{
JVMTI_HEAP_FILTER_TAGGED = 0x4,
JVMTI_HEAP_FILTER_UNTAGGED = 0x8,
JVMTI_HEAP_FILTER_CLASS_TAGGED = 0x10,
JVMTI_HEAP_FILTER_CLASS_UNTAGGED = 0x20
};
enum
{
JVMTI_VISIT_OBJECTS = 0x100,
JVMTI_VISIT_ABORT = 0x8000
};
typedef enum
{
JVMTI_HEAP_REFERENCE_CLASS = 1,
JVMTI_HEAP_REFERENCE_FIELD = 2,
JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT = 3,
JVMTI_HEAP_REFERENCE_CLASS_LOADER = 4,
JVMTI_HEAP_REFERENCE_SIGNERS = 5,
JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN = 6,
JVMTI_HEAP_REFERENCE_INTERFACE = 7,
JVMTI_HEAP_REFERENCE_STATIC_FIELD = 8,
JVMTI_HEAP_REFERENCE_CONSTANT_POOL = 9,
JVMTI_HEAP_REFERENCE_SUPERCLASS = 10,
JVMTI_HEAP_REFERENCE_JNI_GLOBAL = 21,
JVMTI_HEAP_REFERENCE_SYSTEM_CLASS = 22,
JVMTI_HEAP_REFERENCE_MONITOR = 23,
JVMTI_HEAP_REFERENCE_STACK_LOCAL = 24,
JVMTI_HEAP_REFERENCE_JNI_LOCAL = 25,
JVMTI_HEAP_REFERENCE_THREAD = 26,
JVMTI_HEAP_REFERENCE_OTHER = 27
} jvmtiHeapReferenceKind;
typedef enum
{
JVMTI_PRIMITIVE_TYPE_BOOLEAN = 90,
JVMTI_PRIMITIVE_TYPE_BYTE = 66,
JVMTI_PRIMITIVE_TYPE_CHAR = 67,
JVMTI_PRIMITIVE_TYPE_SHORT = 83,
JVMTI_PRIMITIVE_TYPE_INT = 73,
JVMTI_PRIMITIVE_TYPE_LONG = 74,
JVMTI_PRIMITIVE_TYPE_FLOAT = 70,
JVMTI_PRIMITIVE_TYPE_DOUBLE = 68
} jvmtiPrimitiveType;
typedef enum
{
JVMTI_HEAP_OBJECT_TAGGED = 1,
JVMTI_HEAP_OBJECT_UNTAGGED = 2,
JVMTI_HEAP_OBJECT_EITHER = 3
} jvmtiHeapObjectFilter;
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;
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;
typedef enum
{
JVMTI_ITERATION_CONTINUE = 1,
JVMTI_ITERATION_IGNORE = 2,
JVMTI_ITERATION_ABORT = 0
} jvmtiIterationControl;
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
};
typedef enum
{
JVMTI_ENABLE = 1,
JVMTI_DISABLE = 0
} jvmtiEventMode;
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;
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;
typedef enum
{
JVMTI_TIMER_USER_CPU = 30,
JVMTI_TIMER_TOTAL_CPU = 31,
JVMTI_TIMER_ELAPSED = 32
} jvmtiTimerKind;
typedef enum
{
JVMTI_PHASE_ONLOAD = 1,
JVMTI_PHASE_PRIMORDIAL = 2,
JVMTI_PHASE_START = 6,
JVMTI_PHASE_LIVE = 4,
JVMTI_PHASE_DEAD = 8
} jvmtiPhase;
enum
{
JVMTI_VERSION_INTERFACE_JNI = 0x00000000,
JVMTI_VERSION_INTERFACE_JVMTI = 0x30000000
};
enum
{
JVMTI_VERSION_MASK_INTERFACE_TYPE = 0x70000000,
JVMTI_VERSION_MASK_MAJOR = 0x0FFF0000,
JVMTI_VERSION_MASK_MINOR = 0x0000FF00,
JVMTI_VERSION_MASK_MICRO = 0x000000FF
};
enum
{
JVMTI_VERSION_SHIFT_MAJOR = 16,
JVMTI_VERSION_SHIFT_MINOR = 8,
JVMTI_VERSION_SHIFT_MICRO = 0
};
typedef enum
{
JVMTI_VERBOSE_OTHER = 0,
JVMTI_VERBOSE_GC = 1,
JVMTI_VERBOSE_CLASS = 2,
JVMTI_VERBOSE_JNI = 4
} jvmtiVerboseFlag;
typedef enum
{
JVMTI_JLOCATION_JVMBCI = 1,
JVMTI_JLOCATION_MACHINEPC = 2,
JVMTI_JLOCATION_OTHER = 0
} jvmtiJlocationFormat;
enum
{
JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR = 0x0001,
JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP = 0x0002,
JVMTI_RESOURCE_EXHAUSTED_THREADS = 0x0004
};
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_INVALID_MODULE = 26,
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_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED = 72,
JVMTI_ERROR_UNSUPPORTED_OPERATION = 73,
JVMTI_ERROR_UNMODIFIABLE_CLASS = 79,
JVMTI_ERROR_UNMODIFIABLE_MODULE = 80,
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_CLASS_LOADER_UNSUPPORTED = 106,
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;
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_RESOURCE_EXHAUSTED = 80,
JVMTI_EVENT_GARBAGE_COLLECTION_START = 81,
JVMTI_EVENT_GARBAGE_COLLECTION_FINISH = 82,
JVMTI_EVENT_OBJECT_FREE = 83,
JVMTI_EVENT_VM_OBJECT_ALLOC = 84,
JVMTI_EVENT_SAMPLED_OBJECT_ALLOC = 86,
JVMTI_EVENT_VIRTUAL_THREAD_START = 87,
JVMTI_EVENT_VIRTUAL_THREAD_END = 88,
JVMTI_MAX_EVENT_TYPE_VAL = 88
} jvmtiEvent;
struct jvmtiThreadInfo;
typedef struct jvmtiThreadInfo jvmtiThreadInfo;
struct jvmtiMonitorStackDepthInfo;
typedef struct jvmtiMonitorStackDepthInfo jvmtiMonitorStackDepthInfo;
struct jvmtiThreadGroupInfo;
typedef struct jvmtiThreadGroupInfo jvmtiThreadGroupInfo;
struct jvmtiFrameInfo;
typedef struct jvmtiFrameInfo jvmtiFrameInfo;
struct jvmtiStackInfo;
typedef struct jvmtiStackInfo jvmtiStackInfo;
struct jvmtiHeapReferenceInfoField;
typedef struct jvmtiHeapReferenceInfoField jvmtiHeapReferenceInfoField;
struct jvmtiHeapReferenceInfoArray;
typedef struct jvmtiHeapReferenceInfoArray jvmtiHeapReferenceInfoArray;
struct jvmtiHeapReferenceInfoConstantPool;
typedef struct jvmtiHeapReferenceInfoConstantPool jvmtiHeapReferenceInfoConstantPool;
struct jvmtiHeapReferenceInfoStackLocal;
typedef struct jvmtiHeapReferenceInfoStackLocal jvmtiHeapReferenceInfoStackLocal;
struct jvmtiHeapReferenceInfoJniLocal;
typedef struct jvmtiHeapReferenceInfoJniLocal jvmtiHeapReferenceInfoJniLocal;
struct jvmtiHeapReferenceInfoReserved;
typedef struct jvmtiHeapReferenceInfoReserved jvmtiHeapReferenceInfoReserved;
union jvmtiHeapReferenceInfo;
typedef union jvmtiHeapReferenceInfo jvmtiHeapReferenceInfo;
struct jvmtiHeapCallbacks;
typedef struct jvmtiHeapCallbacks jvmtiHeapCallbacks;
struct jvmtiClassDefinition;
typedef struct jvmtiClassDefinition jvmtiClassDefinition;
struct jvmtiMonitorUsage;
typedef struct jvmtiMonitorUsage jvmtiMonitorUsage;
struct jvmtiLineNumberEntry;
typedef struct jvmtiLineNumberEntry jvmtiLineNumberEntry;
struct jvmtiLocalVariableEntry;
typedef struct jvmtiLocalVariableEntry jvmtiLocalVariableEntry;
struct jvmtiParamInfo;
typedef struct jvmtiParamInfo jvmtiParamInfo;
struct jvmtiExtensionFunctionInfo;
typedef struct jvmtiExtensionFunctionInfo jvmtiExtensionFunctionInfo;
struct jvmtiExtensionEventInfo;
typedef struct jvmtiExtensionEventInfo jvmtiExtensionEventInfo;
struct jvmtiTimerInfo;
typedef struct jvmtiTimerInfo jvmtiTimerInfo;
struct jvmtiAddrLocationMap;
typedef struct jvmtiAddrLocationMap jvmtiAddrLocationMap;
typedef void(JNICALL *jvmtiStartFunction)(jvmtiEnv *jvmti_env, JNIEnv *jni_env, void *arg);
typedef jint(JNICALL *jvmtiHeapIterationCallback)(jlong class_tag, jlong size, jlong *tag_ptr, jint length, void *user_data);
typedef jint(JNICALL *jvmtiHeapReferenceCallback)(jvmtiHeapReferenceKind reference_kind, const jvmtiHeapReferenceInfo *reference_info, jlong class_tag, jlong referrer_class_tag, jlong size, jlong *tag_ptr, jlong *referrer_tag_ptr, jint length, void *user_data);
typedef jint(JNICALL *jvmtiPrimitiveFieldCallback)(jvmtiHeapReferenceKind kind, const jvmtiHeapReferenceInfo *info, jlong object_class_tag, jlong *object_tag_ptr, jvalue value, jvmtiPrimitiveType value_type, void *user_data);
typedef jint(JNICALL *jvmtiArrayPrimitiveValueCallback)(jlong class_tag, jlong size, jlong *tag_ptr, jint element_count, jvmtiPrimitiveType element_type, const void *elements, void *user_data);
typedef jint(JNICALL *jvmtiStringPrimitiveValueCallback)(jlong class_tag, jlong size, jlong *tag_ptr, const jchar *value, jint value_length, void *user_data);
typedef jint(JNICALL *jvmtiReservedCallback)();
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, ...);
struct jvmtiThreadInfo
{
char *name;
jint priority;
jboolean is_daemon;
jthreadGroup thread_group;
jobject context_class_loader;
};
struct jvmtiMonitorStackDepthInfo
{
jobject monitor;
jint stack_depth;
};
struct jvmtiThreadGroupInfo
{
jthreadGroup parent;
char *name;
jint max_priority;
jboolean is_daemon;
};
struct jvmtiFrameInfo
{
jmethodID method;
jlocation location;
};
struct jvmtiStackInfo
{
jthread thread;
jint state;
jvmtiFrameInfo *frame_buffer;
jint frame_count;
};
struct jvmtiHeapReferenceInfoField
{
jint index;
};
struct jvmtiHeapReferenceInfoArray
{
jint index;
};
struct jvmtiHeapReferenceInfoConstantPool
{
jint index;
};
struct jvmtiHeapReferenceInfoStackLocal
{
jlong thread_tag;
jlong thread_id;
jint depth;
jmethodID method;
jlocation location;
jint slot;
};
struct jvmtiHeapReferenceInfoJniLocal
{
jlong thread_tag;
jlong thread_id;
jint depth;
jmethodID method;
};
struct jvmtiHeapReferenceInfoReserved
{
jlong reserved1;
jlong reserved2;
jlong reserved3;
jlong reserved4;
jlong reserved5;
jlong reserved6;
jlong reserved7;
jlong reserved8;
};
union jvmtiHeapReferenceInfo
{
jvmtiHeapReferenceInfoField field;
jvmtiHeapReferenceInfoArray array;
jvmtiHeapReferenceInfoConstantPool constant_pool;
jvmtiHeapReferenceInfoStackLocal stack_local;
jvmtiHeapReferenceInfoJniLocal jni_local;
jvmtiHeapReferenceInfoReserved other;
};
struct jvmtiHeapCallbacks
{
jvmtiHeapIterationCallback heap_iteration_callback;
jvmtiHeapReferenceCallback heap_reference_callback;
jvmtiPrimitiveFieldCallback primitive_field_callback;
jvmtiArrayPrimitiveValueCallback array_primitive_value_callback;
jvmtiStringPrimitiveValueCallback string_primitive_value_callback;
jvmtiReservedCallback reserved5;
jvmtiReservedCallback reserved6;
jvmtiReservedCallback reserved7;
jvmtiReservedCallback reserved8;
jvmtiReservedCallback reserved9;
jvmtiReservedCallback reserved10;
jvmtiReservedCallback reserved11;
jvmtiReservedCallback reserved12;
jvmtiReservedCallback reserved13;
jvmtiReservedCallback reserved14;
jvmtiReservedCallback reserved15;
};
struct jvmtiClassDefinition
{
jclass klass;
jint class_byte_count;
const unsigned char *class_bytes;
};
struct jvmtiMonitorUsage
{
jthread owner;
jint entry_count;
jint waiter_count;
jthread *waiters;
jint notify_waiter_count;
jthread *notify_waiters;
};
struct jvmtiLineNumberEntry
{
jlocation start_location;
jint line_number;
};
struct jvmtiLocalVariableEntry
{
jlocation start_location;
jint length;
char *name;
char *signature;
char *generic_signature;
jint slot;
};
struct jvmtiParamInfo
{
char *name;
jvmtiParamKind kind;
jvmtiParamTypes base_type;
jboolean null_ok;
};
struct jvmtiExtensionFunctionInfo
{
jvmtiExtensionFunction func;
char *id;
char *short_description;
jint param_count;
jvmtiParamInfo *params;
jint error_count;
jvmtiError *errors;
};
struct jvmtiExtensionEventInfo
{
jint extension_event_index;
char *id;
char *short_description;
jint param_count;
jvmtiParamInfo *params;
};
struct jvmtiTimerInfo
{
jlong max_value;
jboolean may_skip_forward;
jboolean may_skip_backward;
jvmtiTimerKind kind;
jlong reserved1;
jlong reserved2;
};
struct jvmtiAddrLocationMap
{
const void *start_address;
jlocation location;
};
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 can_force_early_return : 1;
unsigned int can_get_owned_monitor_stack_depth_info : 1;
unsigned int can_get_constant_pool : 1;
unsigned int can_set_native_method_prefix : 1;
unsigned int can_retransform_classes : 1;
unsigned int can_retransform_any_class : 1;
unsigned int can_generate_resource_exhaustion_heap_events : 1;
unsigned int can_generate_resource_exhaustion_threads_events : 1;
unsigned int can_generate_early_vmstart : 1;
unsigned int can_generate_early_class_hook_events : 1;
unsigned int can_generate_sampled_object_alloc_events : 1;
unsigned int can_support_virtual_threads : 1;
unsigned int : 3;
unsigned int : 16;
unsigned int : 16;
unsigned int : 16;
unsigned int : 16;
unsigned int : 16;
} jvmtiCapabilities;
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 *jvmtiEventResourceExhausted)(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jint flags, const void *reserved, const char *description);
typedef void(JNICALL *jvmtiEventSampledObjectAlloc)(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jobject object, jclass object_klass, jlong size);
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 *jvmtiEventVirtualThreadEnd)(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread virtual_thread);
typedef void(JNICALL *jvmtiEventVirtualThreadStart)(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread virtual_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);
typedef struct
{
jvmtiEventVMInit VMInit;
jvmtiEventVMDeath VMDeath;
jvmtiEventThreadStart ThreadStart;
jvmtiEventThreadEnd ThreadEnd;
jvmtiEventClassFileLoadHook ClassFileLoadHook;
jvmtiEventClassLoad ClassLoad;
jvmtiEventClassPrepare ClassPrepare;
jvmtiEventVMStart VMStart;
jvmtiEventException Exception;
jvmtiEventExceptionCatch ExceptionCatch;
jvmtiEventSingleStep SingleStep;
jvmtiEventFramePop FramePop;
jvmtiEventBreakpoint Breakpoint;
jvmtiEventFieldAccess FieldAccess;
jvmtiEventFieldModification FieldModification;
jvmtiEventMethodEntry MethodEntry;
jvmtiEventMethodExit MethodExit;
jvmtiEventNativeMethodBind NativeMethodBind;
jvmtiEventCompiledMethodLoad CompiledMethodLoad;
jvmtiEventCompiledMethodUnload CompiledMethodUnload;
jvmtiEventDynamicCodeGenerated DynamicCodeGenerated;
jvmtiEventDataDumpRequest DataDumpRequest;
jvmtiEventReserved reserved72;
jvmtiEventMonitorWait MonitorWait;
jvmtiEventMonitorWaited MonitorWaited;
jvmtiEventMonitorContendedEnter MonitorContendedEnter;
jvmtiEventMonitorContendedEntered MonitorContendedEntered;
jvmtiEventReserved reserved77;
jvmtiEventReserved reserved78;
jvmtiEventReserved reserved79;
jvmtiEventResourceExhausted ResourceExhausted;
jvmtiEventGarbageCollectionStart GarbageCollectionStart;
jvmtiEventGarbageCollectionFinish GarbageCollectionFinish;
jvmtiEventObjectFree ObjectFree;
jvmtiEventVMObjectAlloc VMObjectAlloc;
jvmtiEventReserved reserved85;
jvmtiEventSampledObjectAlloc SampledObjectAlloc;
jvmtiEventVirtualThreadStart VirtualThreadStart;
jvmtiEventVirtualThreadEnd VirtualThreadEnd;
} jvmtiEventCallbacks;
typedef struct jvmtiInterface_1_
{
void *reserved1;
jvmtiError(JNICALL *SetEventNotificationMode)(jvmtiEnv *env, jvmtiEventMode mode, jvmtiEvent event_type, jthread event_thread, ...);
jvmtiError(JNICALL *GetAllModules)(jvmtiEnv *env, jint *module_count_ptr, jobject **modules_ptr);
jvmtiError(JNICALL *GetAllThreads)(jvmtiEnv *env, jint *threads_count_ptr, jthread **threads_ptr);
jvmtiError(JNICALL *SuspendThread)(jvmtiEnv *env, jthread thread);
jvmtiError(JNICALL *ResumeThread)(jvmtiEnv *env, jthread thread);
jvmtiError(JNICALL *StopThread)(jvmtiEnv *env, jthread thread, jobject exception);
jvmtiError(JNICALL *InterruptThread)(jvmtiEnv *env, jthread thread);
jvmtiError(JNICALL *GetThreadInfo)(jvmtiEnv *env, jthread thread, jvmtiThreadInfo *info_ptr);
jvmtiError(JNICALL *GetOwnedMonitorInfo)(jvmtiEnv *env, jthread thread, jint *owned_monitor_count_ptr, jobject **owned_monitors_ptr);
jvmtiError(JNICALL *GetCurrentContendedMonitor)(jvmtiEnv *env, jthread thread, jobject *monitor_ptr);
jvmtiError(JNICALL *RunAgentThread)(jvmtiEnv *env, jthread thread, jvmtiStartFunction proc, const void *arg, jint priority);
jvmtiError(JNICALL *GetTopThreadGroups)(jvmtiEnv *env, jint *group_count_ptr, jthreadGroup **groups_ptr);
jvmtiError(JNICALL *GetThreadGroupInfo)(jvmtiEnv *env, jthreadGroup group, jvmtiThreadGroupInfo *info_ptr);
jvmtiError(JNICALL *GetThreadGroupChildren)(jvmtiEnv *env, jthreadGroup group, jint *thread_count_ptr, jthread **threads_ptr, jint *group_count_ptr, jthreadGroup **groups_ptr);
jvmtiError(JNICALL *GetFrameCount)(jvmtiEnv *env, jthread thread, jint *count_ptr);
jvmtiError(JNICALL *GetThreadState)(jvmtiEnv *env, jthread thread, jint *thread_state_ptr);
jvmtiError(JNICALL *GetCurrentThread)(jvmtiEnv *env, jthread *thread_ptr);
jvmtiError(JNICALL *GetFrameLocation)(jvmtiEnv *env, jthread thread, jint depth, jmethodID *method_ptr, jlocation *location_ptr);
jvmtiError(JNICALL *NotifyFramePop)(jvmtiEnv *env, jthread thread, jint depth);
jvmtiError(JNICALL *GetLocalObject)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jobject *value_ptr);
jvmtiError(JNICALL *GetLocalInt)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jint *value_ptr);
jvmtiError(JNICALL *GetLocalLong)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jlong *value_ptr);
jvmtiError(JNICALL *GetLocalFloat)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jfloat *value_ptr);
jvmtiError(JNICALL *GetLocalDouble)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jdouble *value_ptr);
jvmtiError(JNICALL *SetLocalObject)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jobject value);
jvmtiError(JNICALL *SetLocalInt)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jint value);
jvmtiError(JNICALL *SetLocalLong)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jlong value);
jvmtiError(JNICALL *SetLocalFloat)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jfloat value);
jvmtiError(JNICALL *SetLocalDouble)(jvmtiEnv *env, jthread thread, jint depth, jint slot, jdouble value);
jvmtiError(JNICALL *CreateRawMonitor)(jvmtiEnv *env, const char *name, jrawMonitorID *monitor_ptr);
jvmtiError(JNICALL *DestroyRawMonitor)(jvmtiEnv *env, jrawMonitorID monitor);
jvmtiError(JNICALL *RawMonitorEnter)(jvmtiEnv *env, jrawMonitorID monitor);
jvmtiError(JNICALL *RawMonitorExit)(jvmtiEnv *env, jrawMonitorID monitor);
jvmtiError(JNICALL *RawMonitorWait)(jvmtiEnv *env, jrawMonitorID monitor, jlong millis);
jvmtiError(JNICALL *RawMonitorNotify)(jvmtiEnv *env, jrawMonitorID monitor);
jvmtiError(JNICALL *RawMonitorNotifyAll)(jvmtiEnv *env, jrawMonitorID monitor);
jvmtiError(JNICALL *SetBreakpoint)(jvmtiEnv *env, jmethodID method, jlocation location);
jvmtiError(JNICALL *ClearBreakpoint)(jvmtiEnv *env, jmethodID method, jlocation location);
jvmtiError(JNICALL *GetNamedModule)(jvmtiEnv *env, jobject class_loader, const char *package_name, jobject *module_ptr);
jvmtiError(JNICALL *SetFieldAccessWatch)(jvmtiEnv *env, jclass klass, jfieldID field);
jvmtiError(JNICALL *ClearFieldAccessWatch)(jvmtiEnv *env, jclass klass, jfieldID field);
jvmtiError(JNICALL *SetFieldModificationWatch)(jvmtiEnv *env, jclass klass, jfieldID field);
jvmtiError(JNICALL *ClearFieldModificationWatch)(jvmtiEnv *env, jclass klass, jfieldID field);
jvmtiError(JNICALL *IsModifiableClass)(jvmtiEnv *env, jclass klass, jboolean *is_modifiable_class_ptr);
jvmtiError(JNICALL *Allocate)(jvmtiEnv *env, jlong size, unsigned char **mem_ptr);
jvmtiError(JNICALL *Deallocate)(jvmtiEnv *env, unsigned char *mem);
jvmtiError(JNICALL *GetClassSignature)(jvmtiEnv *env, jclass klass, char **signature_ptr, char **generic_ptr);
jvmtiError(JNICALL *GetClassStatus)(jvmtiEnv *env, jclass klass, jint *status_ptr);
jvmtiError(JNICALL *GetSourceFileName)(jvmtiEnv *env, jclass klass, char **source_name_ptr);
jvmtiError(JNICALL *GetClassModifiers)(jvmtiEnv *env, jclass klass, jint *modifiers_ptr);
jvmtiError(JNICALL *GetClassMethods)(jvmtiEnv *env, jclass klass, jint *method_count_ptr, jmethodID **methods_ptr);
jvmtiError(JNICALL *GetClassFields)(jvmtiEnv *env, jclass klass, jint *field_count_ptr, jfieldID **fields_ptr);
jvmtiError(JNICALL *GetImplementedInterfaces)(jvmtiEnv *env, jclass klass, jint *interface_count_ptr, jclass **interfaces_ptr);
jvmtiError(JNICALL *IsInterface)(jvmtiEnv *env, jclass klass, jboolean *is_interface_ptr);
jvmtiError(JNICALL *IsArrayClass)(jvmtiEnv *env, jclass klass, jboolean *is_array_class_ptr);
jvmtiError(JNICALL *GetClassLoader)(jvmtiEnv *env, jclass klass, jobject *classloader_ptr);
jvmtiError(JNICALL *GetObjectHashCode)(jvmtiEnv *env, jobject object, jint *hash_code_ptr);
jvmtiError(JNICALL *GetObjectMonitorUsage)(jvmtiEnv *env, jobject object, jvmtiMonitorUsage *info_ptr);
jvmtiError(JNICALL *GetFieldName)(jvmtiEnv *env, jclass klass, jfieldID field, char **name_ptr, char **signature_ptr, char **generic_ptr);
jvmtiError(JNICALL *GetFieldDeclaringClass)(jvmtiEnv *env, jclass klass, jfieldID field, jclass *declaring_class_ptr);
jvmtiError(JNICALL *GetFieldModifiers)(jvmtiEnv *env, jclass klass, jfieldID field, jint *modifiers_ptr);
jvmtiError(JNICALL *IsFieldSynthetic)(jvmtiEnv *env, jclass klass, jfieldID field, jboolean *is_synthetic_ptr);
jvmtiError(JNICALL *GetMethodName)(jvmtiEnv *env, jmethodID method, char **name_ptr, char **signature_ptr, char **generic_ptr);
jvmtiError(JNICALL *GetMethodDeclaringClass)(jvmtiEnv *env, jmethodID method, jclass *declaring_class_ptr);
jvmtiError(JNICALL *GetMethodModifiers)(jvmtiEnv *env, jmethodID method, jint *modifiers_ptr);
void *reserved67;
jvmtiError(JNICALL *GetMaxLocals)(jvmtiEnv *env, jmethodID method, jint *max_ptr);
jvmtiError(JNICALL *GetArgumentsSize)(jvmtiEnv *env, jmethodID method, jint *size_ptr);
jvmtiError(JNICALL *GetLineNumberTable)(jvmtiEnv *env, jmethodID method, jint *entry_count_ptr, jvmtiLineNumberEntry **table_ptr);
jvmtiError(JNICALL *GetMethodLocation)(jvmtiEnv *env, jmethodID method, jlocation *start_location_ptr, jlocation *end_location_ptr);
jvmtiError(JNICALL *GetLocalVariableTable)(jvmtiEnv *env, jmethodID method, jint *entry_count_ptr, jvmtiLocalVariableEntry **table_ptr);
jvmtiError(JNICALL *SetNativeMethodPrefix)(jvmtiEnv *env, const char *prefix);
jvmtiError(JNICALL *SetNativeMethodPrefixes)(jvmtiEnv *env, jint prefix_count, char **prefixes);
jvmtiError(JNICALL *GetBytecodes)(jvmtiEnv *env, jmethodID method, jint *bytecode_count_ptr, unsigned char **bytecodes_ptr);
jvmtiError(JNICALL *IsMethodNative)(jvmtiEnv *env, jmethodID method, jboolean *is_native_ptr);
jvmtiError(JNICALL *IsMethodSynthetic)(jvmtiEnv *env, jmethodID method, jboolean *is_synthetic_ptr);
jvmtiError(JNICALL *GetLoadedClasses)(jvmtiEnv *env, jint *class_count_ptr, jclass **classes_ptr);
jvmtiError(JNICALL *GetClassLoaderClasses)(jvmtiEnv *env, jobject initiating_loader, jint *class_count_ptr, jclass **classes_ptr);
jvmtiError(JNICALL *PopFrame)(jvmtiEnv *env, jthread thread);
jvmtiError(JNICALL *ForceEarlyReturnObject)(jvmtiEnv *env, jthread thread, jobject value);
jvmtiError(JNICALL *ForceEarlyReturnInt)(jvmtiEnv *env, jthread thread, jint value);
jvmtiError(JNICALL *ForceEarlyReturnLong)(jvmtiEnv *env, jthread thread, jlong value);
jvmtiError(JNICALL *ForceEarlyReturnFloat)(jvmtiEnv *env, jthread thread, jfloat value);
jvmtiError(JNICALL *ForceEarlyReturnDouble)(jvmtiEnv *env, jthread thread, jdouble value);
jvmtiError(JNICALL *ForceEarlyReturnVoid)(jvmtiEnv *env, jthread thread);
jvmtiError(JNICALL *RedefineClasses)(jvmtiEnv *env, jint class_count, const jvmtiClassDefinition *class_definitions);
jvmtiError(JNICALL *GetVersionNumber)(jvmtiEnv *env, jint *version_ptr);
jvmtiError(JNICALL *GetCapabilities)(jvmtiEnv *env, jvmtiCapabilities *capabilities_ptr);
jvmtiError(JNICALL *GetSourceDebugExtension)(jvmtiEnv *env, jclass klass, char **source_debug_extension_ptr);
jvmtiError(JNICALL *IsMethodObsolete)(jvmtiEnv *env, jmethodID method, jboolean *is_obsolete_ptr);
jvmtiError(JNICALL *SuspendThreadList)(jvmtiEnv *env, jint request_count, const jthread *request_list, jvmtiError *results);
jvmtiError(JNICALL *ResumeThreadList)(jvmtiEnv *env, jint request_count, const jthread *request_list, jvmtiError *results);
jvmtiError(JNICALL *AddModuleReads)(jvmtiEnv *env, jobject module, jobject to_module);
jvmtiError(JNICALL *AddModuleExports)(jvmtiEnv *env, jobject module, const char *pkg_name, jobject to_module);
jvmtiError(JNICALL *AddModuleOpens)(jvmtiEnv *env, jobject module, const char *pkg_name, jobject to_module);
jvmtiError(JNICALL *AddModuleUses)(jvmtiEnv *env, jobject module, jclass service);
jvmtiError(JNICALL *AddModuleProvides)(jvmtiEnv *env, jobject module, jclass service, jclass impl_class);
jvmtiError(JNICALL *IsModifiableModule)(jvmtiEnv *env, jobject module, jboolean *is_modifiable_module_ptr);
jvmtiError(JNICALL *GetAllStackTraces)(jvmtiEnv *env, jint max_frame_count, jvmtiStackInfo **stack_info_ptr, jint *thread_count_ptr);
jvmtiError(JNICALL *GetThreadListStackTraces)(jvmtiEnv *env, jint thread_count, const jthread *thread_list, jint max_frame_count, jvmtiStackInfo **stack_info_ptr);
jvmtiError(JNICALL *GetThreadLocalStorage)(jvmtiEnv *env, jthread thread, void **data_ptr);
jvmtiError(JNICALL *SetThreadLocalStorage)(jvmtiEnv *env, jthread thread, const void *data);
jvmtiError(JNICALL *GetStackTrace)(jvmtiEnv *env, jthread thread, jint start_depth, jint max_frame_count, jvmtiFrameInfo *frame_buffer, jint *count_ptr);
void *reserved105;
jvmtiError(JNICALL *GetTag)(jvmtiEnv *env, jobject object, jlong *tag_ptr);
jvmtiError(JNICALL *SetTag)(jvmtiEnv *env, jobject object, jlong tag);
jvmtiError(JNICALL *ForceGarbageCollection)(jvmtiEnv *env);
jvmtiError(JNICALL *IterateOverObjectsReachableFromObject)(jvmtiEnv *env, jobject object, jvmtiObjectReferenceCallback object_reference_callback, const void *user_data);
jvmtiError(JNICALL *IterateOverReachableObjects)(jvmtiEnv *env, jvmtiHeapRootCallback heap_root_callback, jvmtiStackReferenceCallback stack_ref_callback, jvmtiObjectReferenceCallback object_ref_callback, const void *user_data);
jvmtiError(JNICALL *IterateOverHeap)(jvmtiEnv *env, jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void *user_data);
jvmtiError(JNICALL *IterateOverInstancesOfClass)(jvmtiEnv *env, jclass klass, jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void *user_data);
void *reserved113;
jvmtiError(JNICALL *GetObjectsWithTags)(jvmtiEnv *env, jint tag_count, const jlong *tags, jint *count_ptr, jobject **object_result_ptr, jlong **tag_result_ptr);
jvmtiError(JNICALL *FollowReferences)(jvmtiEnv *env, jint heap_filter, jclass klass, jobject initial_object, const jvmtiHeapCallbacks *callbacks, const void *user_data);
jvmtiError(JNICALL *IterateThroughHeap)(jvmtiEnv *env, jint heap_filter, jclass klass, const jvmtiHeapCallbacks *callbacks, const void *user_data);
void *reserved117;
jvmtiError(JNICALL *SuspendAllVirtualThreads)(jvmtiEnv *env, jint except_count, const jthread *except_list);
jvmtiError(JNICALL *ResumeAllVirtualThreads)(jvmtiEnv *env, jint except_count, const jthread *except_list);
jvmtiError(JNICALL *SetJNIFunctionTable)(jvmtiEnv *env, const jniNativeInterface *function_table);
jvmtiError(JNICALL *GetJNIFunctionTable)(jvmtiEnv *env, jniNativeInterface **function_table);
jvmtiError(JNICALL *SetEventCallbacks)(jvmtiEnv *env, const jvmtiEventCallbacks *callbacks, jint size_of_callbacks);
jvmtiError(JNICALL *GenerateEvents)(jvmtiEnv *env, jvmtiEvent event_type);
jvmtiError(JNICALL *GetExtensionFunctions)(jvmtiEnv *env, jint *extension_count_ptr, jvmtiExtensionFunctionInfo **extensions);
jvmtiError(JNICALL *GetExtensionEvents)(jvmtiEnv *env, jint *extension_count_ptr, jvmtiExtensionEventInfo **extensions);
jvmtiError(JNICALL *SetExtensionEventCallback)(jvmtiEnv *env, jint extension_event_index, jvmtiExtensionEvent callback);
jvmtiError(JNICALL *DisposeEnvironment)(jvmtiEnv *env);
jvmtiError(JNICALL *GetErrorName)(jvmtiEnv *env, jvmtiError error, char **name_ptr);
jvmtiError(JNICALL *GetJLocationFormat)(jvmtiEnv *env, jvmtiJlocationFormat *format_ptr);
jvmtiError(JNICALL *GetSystemProperties)(jvmtiEnv *env, jint *count_ptr, char ***property_ptr);
jvmtiError(JNICALL *GetSystemProperty)(jvmtiEnv *env, const char *property, char **value_ptr);
jvmtiError(JNICALL *SetSystemProperty)(jvmtiEnv *env, const char *property, const char *value_ptr);
jvmtiError(JNICALL *GetPhase)(jvmtiEnv *env, jvmtiPhase *phase_ptr);
jvmtiError(JNICALL *GetCurrentThreadCpuTimerInfo)(jvmtiEnv *env, jvmtiTimerInfo *info_ptr);
jvmtiError(JNICALL *GetCurrentThreadCpuTime)(jvmtiEnv *env, jlong *nanos_ptr);
jvmtiError(JNICALL *GetThreadCpuTimerInfo)(jvmtiEnv *env, jvmtiTimerInfo *info_ptr);
jvmtiError(JNICALL *GetThreadCpuTime)(jvmtiEnv *env, jthread thread, jlong *nanos_ptr);
jvmtiError(JNICALL *GetTimerInfo)(jvmtiEnv *env, jvmtiTimerInfo *info_ptr);
jvmtiError(JNICALL *GetTime)(jvmtiEnv *env, jlong *nanos_ptr);
jvmtiError(JNICALL *GetPotentialCapabilities)(jvmtiEnv *env, jvmtiCapabilities *capabilities_ptr);
void *reserved141;
jvmtiError(JNICALL *AddCapabilities)(jvmtiEnv *env, const jvmtiCapabilities *capabilities_ptr);
jvmtiError(JNICALL *RelinquishCapabilities)(jvmtiEnv *env, const jvmtiCapabilities *capabilities_ptr);
jvmtiError(JNICALL *GetAvailableProcessors)(jvmtiEnv *env, jint *processor_count_ptr);
jvmtiError(JNICALL *GetClassVersionNumbers)(jvmtiEnv *env, jclass klass, jint *minor_version_ptr, jint *major_version_ptr);
jvmtiError(JNICALL *GetConstantPool)(jvmtiEnv *env, jclass klass, jint *constant_pool_count_ptr, jint *constant_pool_byte_count_ptr, unsigned char **constant_pool_bytes_ptr);
jvmtiError(JNICALL *GetEnvironmentLocalStorage)(jvmtiEnv *env, void **data_ptr);
jvmtiError(JNICALL *SetEnvironmentLocalStorage)(jvmtiEnv *env, const void *data);
jvmtiError(JNICALL *AddToBootstrapClassLoaderSearch)(jvmtiEnv *env, const char *segment);
jvmtiError(JNICALL *SetVerboseFlag)(jvmtiEnv *env, jvmtiVerboseFlag flag, jboolean value);
jvmtiError(JNICALL *AddToSystemClassLoaderSearch)(jvmtiEnv *env, const char *segment);
jvmtiError(JNICALL *RetransformClasses)(jvmtiEnv *env, jint class_count, const jclass *classes);
jvmtiError(JNICALL *GetOwnedMonitorStackDepthInfo)(jvmtiEnv *env, jthread thread, jint *monitor_info_count_ptr, jvmtiMonitorStackDepthInfo **monitor_info_ptr);
jvmtiError(JNICALL *GetObjectSize)(jvmtiEnv *env, jobject object, jlong *size_ptr);
jvmtiError(JNICALL *GetLocalInstance)(jvmtiEnv *env, jthread thread, jint depth, jobject *value_ptr);
jvmtiError(JNICALL *SetHeapSamplingInterval)(jvmtiEnv *env, jint sampling_interval);
} 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 GetCurrentThread(jthread *thread_ptr) { return functions->GetCurrentThread(this, thread_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 SuspendAllVirtualThreads(jint except_count, const jthread *except_list) { return functions->SuspendAllVirtualThreads(this, except_count, except_list); }
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 ResumeAllVirtualThreads(jint except_count, const jthread *except_list) { return functions->ResumeAllVirtualThreads(this, except_count, except_list); }
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 GetOwnedMonitorStackDepthInfo(jthread thread, jint *monitor_info_count_ptr, jvmtiMonitorStackDepthInfo **monitor_info_ptr) { return functions->GetOwnedMonitorStackDepthInfo(this, thread, monitor_info_count_ptr, monitor_info_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 ForceEarlyReturnObject(jthread thread, jobject value) { return functions->ForceEarlyReturnObject(this, thread, value); }
jvmtiError ForceEarlyReturnInt(jthread thread, jint value) { return functions->ForceEarlyReturnInt(this, thread, value); }
jvmtiError ForceEarlyReturnLong(jthread thread, jlong value) { return functions->ForceEarlyReturnLong(this, thread, value); }
jvmtiError ForceEarlyReturnFloat(jthread thread, jfloat value) { return functions->ForceEarlyReturnFloat(this, thread, value); }
jvmtiError ForceEarlyReturnDouble(jthread thread, jdouble value) { return functions->ForceEarlyReturnDouble(this, thread, value); }
jvmtiError ForceEarlyReturnVoid(jthread thread) { return functions->ForceEarlyReturnVoid(this, thread); }
jvmtiError FollowReferences(jint heap_filter, jclass klass, jobject initial_object, const jvmtiHeapCallbacks *callbacks, const void *user_data) { return functions->FollowReferences(this, heap_filter, klass, initial_object, callbacks, user_data); }
jvmtiError IterateThroughHeap(jint heap_filter, jclass klass, const jvmtiHeapCallbacks *callbacks, const void *user_data) { return functions->IterateThroughHeap(this, heap_filter, klass, callbacks, user_data); }
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 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 ForceGarbageCollection() { return functions->ForceGarbageCollection(this); }
jvmtiError IterateOverObjectsReachableFromObject(jobject object, jvmtiObjectReferenceCallback object_reference_callback, const 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, const 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, const 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, const void *user_data) { return functions->IterateOverInstancesOfClass(this, klass, object_filter, heap_object_callback, user_data); }
jvmtiError GetLocalObject(jthread thread, jint depth, jint slot, jobject *value_ptr) { return functions->GetLocalObject(this, thread, depth, slot, value_ptr); }
jvmtiError GetLocalInstance(jthread thread, jint depth, jobject *value_ptr) { return functions->GetLocalInstance(this, thread, depth, 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 GetAllModules(jint *module_count_ptr, jobject **modules_ptr) { return functions->GetAllModules(this, module_count_ptr, modules_ptr); }
jvmtiError GetNamedModule(jobject class_loader, const char *package_name, jobject *module_ptr) { return functions->GetNamedModule(this, class_loader, package_name, module_ptr); }
jvmtiError AddModuleReads(jobject module, jobject to_module) { return functions->AddModuleReads(this, module, to_module); }
jvmtiError AddModuleExports(jobject module, const char *pkg_name, jobject to_module) { return functions->AddModuleExports(this, module, pkg_name, to_module); }
jvmtiError AddModuleOpens(jobject module, const char *pkg_name, jobject to_module) { return functions->AddModuleOpens(this, module, pkg_name, to_module); }
jvmtiError AddModuleUses(jobject module, jclass service) { return functions->AddModuleUses(this, module, service); }
jvmtiError AddModuleProvides(jobject module, jclass service, jclass impl_class) { return functions->AddModuleProvides(this, module, service, impl_class); }
jvmtiError IsModifiableModule(jobject module, jboolean *is_modifiable_module_ptr) { return functions->IsModifiableModule(this, module, is_modifiable_module_ptr); }
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 GetClassVersionNumbers(jclass klass, jint *minor_version_ptr, jint *major_version_ptr) { return functions->GetClassVersionNumbers(this, klass, minor_version_ptr, major_version_ptr); }
jvmtiError GetConstantPool(jclass klass, jint *constant_pool_count_ptr, jint *constant_pool_byte_count_ptr, unsigned char **constant_pool_bytes_ptr) { return functions->GetConstantPool(this, klass, constant_pool_count_ptr, constant_pool_byte_count_ptr, constant_pool_bytes_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 IsModifiableClass(jclass klass, jboolean *is_modifiable_class_ptr) { return functions->IsModifiableClass(this, klass, is_modifiable_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 RetransformClasses(jint class_count, const jclass *classes) { return functions->RetransformClasses(this, class_count, classes); }
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 SetNativeMethodPrefix(const char *prefix) { return functions->SetNativeMethodPrefix(this, prefix); }
jvmtiError SetNativeMethodPrefixes(jint prefix_count, char **prefixes) { return functions->SetNativeMethodPrefixes(this, prefix_count, prefixes); }
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 AddToSystemClassLoaderSearch(const char *segment) { return functions->AddToSystemClassLoaderSearch(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_ptr) { return functions->SetSystemProperty(this, property, value_ptr); }
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); }
jvmtiError SetHeapSamplingInterval(jint sampling_interval) { return functions->SetHeapSamplingInterval(this, sampling_interval); }
#endif
};
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_JVMTI_CMLR
#define INTERNAL_JVMTI_CMLR
enum
{
JVMTI_CMLR_MAJOR_VERSION_1 = 0x00000001,
JVMTI_CMLR_MINOR_VERSION_0 = 0x00000000,
JVMTI_CMLR_MAJOR_VERSION = 0x00000001,
JVMTI_CMLR_MINOR_VERSION = 0x00000000
};
typedef enum
{
JVMTI_CMLR_DUMMY = 1,
JVMTI_CMLR_INLINE_INFO = 2
} jvmtiCMLRKind;
typedef struct jvmtiCompiledMethodLoadRecordHeader
{
jvmtiCMLRKind kind;
jint majorinfoversion;
jint minorinfoversion;
struct jvmtiCompiledMethodLoadRecordHeader *next;
} jvmtiCompiledMethodLoadRecordHeader;
typedef struct PCStackInfo
{
void *pc;
jint numstackframes;
jmethodID *methods;
jint *bcis;
} PCStackInfo;
typedef struct jvmtiCompiledMethodLoadInlineRecord
{
jvmtiCompiledMethodLoadRecordHeader header;
jint numpcs;
PCStackInfo *pcinfo;
} jvmtiCompiledMethodLoadInlineRecord;
typedef struct jvmtiCompiledMethodLoadDummyRecord
{
jvmtiCompiledMethodLoadRecordHeader header;
char message[50];
} jvmtiCompiledMethodLoadDummyRecord;
#endif
#ifndef INTERNAL_JAWT
#define INTERNAL_JAWT
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct jawt_Rectangle
{
jint x;
jint y;
jint width;
jint height;
} JAWT_Rectangle;
struct jawt_DrawingSurface;
typedef struct jawt_DrawingSurfaceInfo
{
void *platformInfo;
struct jawt_DrawingSurface *ds;
JAWT_Rectangle bounds;
jint clipSize;
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
typedef struct jawt_DrawingSurface
{
JNIEnv *env;
jobject target;
jint(JNICALL *Lock)(struct jawt_DrawingSurface *ds);
JAWT_DrawingSurfaceInfo *(JNICALL *GetDrawingSurfaceInfo)(struct jawt_DrawingSurface *ds);
void(JNICALL *FreeDrawingSurfaceInfo)(JAWT_DrawingSurfaceInfo *dsi);
void(JNICALL *Unlock)(struct jawt_DrawingSurface *ds);
} JAWT_DrawingSurface;
typedef struct jawt
{
jint version;
JAWT_DrawingSurface *(JNICALL *GetDrawingSurface)(JNIEnv *env, jobject target);
void(JNICALL *FreeDrawingSurface)(JAWT_DrawingSurface *ds);
void(JNICALL *Lock)(JNIEnv *env);
void(JNICALL *Unlock)(JNIEnv *env);
jobject(JNICALL *GetComponent)(JNIEnv *env, void *platformInfo);
jobject(JNICALL *CreateEmbeddedFrame)(JNIEnv *env, void *platformInfo);
void(JNICALL *SetBounds)(JNIEnv *env, jobject embeddedFrame, jint x, jint y, jint w, jint h);
void(JNICALL *SynthesizeWindowActivation)(JNIEnv *env, jobject embeddedFrame, jboolean doActivate);
} JAWT;
JNI_IMPORT_OR_EXPORT
jboolean JNICALL JAWT_GetAWT(JNIEnv *env, JAWT *awt);
#define JAWT_VERSION_1_3 0x00010003
#define JAWT_VERSION_1_4 0x00010004
#define JAWT_VERSION_1_7 0x00010007
#define JAWT_VERSION_9 0x00090000
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_JDWPTRANSPORT
#define INTERNAL_JDWPTRANSPORT
enum
{
JDWPTRANSPORT_VERSION_1_0 = 0x00010000,
JDWPTRANSPORT_VERSION_1_1 = 0x00010001
};
#ifdef __cplusplus
extern "C"
{
#endif
struct jdwpTransportNativeInterface_;
struct _jdwpTransportEnv;
#ifdef __cplusplus
typedef _jdwpTransportEnv jdwpTransportEnv;
#else
typedef const struct jdwpTransportNativeInterface_ *jdwpTransportEnv;
#endif
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;
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;
#define JDWP_HEADER_SIZE 11
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;
typedef struct jdwpTransportCallback
{
void *(*alloc)(jint numBytes);
void (*free)(void *buffer);
} jdwpTransportCallback;
typedef jint(JNICALL *jdwpTransport_OnLoad_t)(JavaVM *jvm, jdwpTransportCallback *callback, jint version, jdwpTransportEnv **env);
typedef struct jdwpTransportConfiguration
{
const char *allowed_peers;
} jdwpTransportConfiguration;
struct jdwpTransportNativeInterface_
{
void *reserved1;
jdwpTransportError(JNICALL *GetCapabilities)(jdwpTransportEnv *env, JDWPTransportCapabilities *capabilities_ptr);
jdwpTransportError(JNICALL *Attach)(jdwpTransportEnv *env, const char *address, jlong attach_timeout, jlong handshake_timeout);
jdwpTransportError(JNICALL *StartListening)(jdwpTransportEnv *env, const char *address, char **actual_address);
jdwpTransportError(JNICALL *StopListening)(jdwpTransportEnv *env);
jdwpTransportError(JNICALL *Accept)(jdwpTransportEnv *env, jlong accept_timeout, jlong handshake_timeout);
jboolean(JNICALL *IsOpen)(jdwpTransportEnv *env);
jdwpTransportError(JNICALL *Close)(jdwpTransportEnv *env);
jdwpTransportError(JNICALL *ReadPacket)(jdwpTransportEnv *env, jdwpPacket *pkt);
jdwpTransportError(JNICALL *WritePacket)(jdwpTransportEnv *env, const jdwpPacket *pkt);
jdwpTransportError(JNICALL *GetLastError)(jdwpTransportEnv *env, char **error);
jdwpTransportError(JNICALL *SetTransportConfiguration)(jdwpTransportEnv *env, jdwpTransportConfiguration *config);
};
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() { return functions->StopListening(this); }
jdwpTransportError Accept(jlong accept_timeout, jlong handshake_timeout) { return functions->Accept(this, accept_timeout, handshake_timeout); }
jboolean IsOpen() { return functions->IsOpen(this); }
jdwpTransportError Close() { 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); }
jdwpTransportError SetTransportConfiguration(jdwpTransportConfiguration *config) { return functions->SetTransportConfiguration(this, config); }
#endif
};
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_ACCESSBRIDGEPACKAGES
#define INTERNAL_ACCESSBRIDGEPACKAGES
#ifdef __cplusplus
extern "C"
{
#endif
#ifdef ACCESSBRIDGE_ARCH_LEGACY
typedef jobject JOBJECT64;
typedef HWND ABHWND64;
#define ABHandleToLong
#define ABLongToHandle
#else
typedef jlong JOBJECT64;
typedef long ABHWND64;
#define ABHandleToLong HandleToLong
#define ABLongToHandle LongToHandle
#endif
#define MAX_BUFFER_SIZE 10240
#define MAX_STRING_SIZE 1024
#define SHORT_STRING_SIZE 256
typedef JOBJECT64 AccessibleContext;
typedef JOBJECT64 AccessibleText;
typedef JOBJECT64 AccessibleValue;
typedef JOBJECT64 AccessibleSelection;
typedef JOBJECT64 Java_Object;
typedef JOBJECT64 PropertyChangeEvent;
typedef JOBJECT64 FocusEvent;
typedef JOBJECT64 CaretEvent;
typedef JOBJECT64 MouseEvent;
typedef JOBJECT64 MenuEvent;
typedef JOBJECT64 AccessibleTable;
typedef JOBJECT64 AccessibleHyperlink;
typedef JOBJECT64 AccessibleHypertext;
#define cPropertyChangeEvent (jlong)1 // 1
#define cFocusGainedEvent (jlong)2 // 2
#define cFocusLostEvent (jlong)4 // 4
#define cCaretUpdateEvent (jlong)8 // 8
#define cMouseClickedEvent (jlong)16 // 10
#define cMouseEnteredEvent (jlong)32 // 20
#define cMouseExitedEvent (jlong)64 // 40
#define cMousePressedEvent (jlong)128 // 80
#define cMouseReleasedEvent (jlong)256 // 100
#define cMenuCanceledEvent (jlong)512 // 200
#define cMenuDeselectedEvent (jlong)1024 // 400
#define cMenuSelectedEvent (jlong)2048 // 800
#define cPopupMenuCanceledEvent (jlong)4096 // 1000
#define cPopupMenuWillBecomeInvisibleEvent (jlong)8192 // 2000
#define cPopupMenuWillBecomeVisibleEvent (jlong)16384 // 4000
#define cJavaShutdownEvent (jlong)32768 // 8000
#define ACCESSIBLE_ALERT L"alert"
#define ACCESSIBLE_COLUMN_HEADER L"column header"
#define ACCESSIBLE_CANVAS L"canvas"
#define ACCESSIBLE_COMBO_BOX L"combo box"
#define ACCESSIBLE_DESKTOP_ICON L"desktop icon"
#define ACCESSIBLE_INTERNAL_FRAME L"internal frame"
#define ACCESSIBLE_DESKTOP_PANE L"desktop pane"
#define ACCESSIBLE_OPTION_PANE L"option pane"
#define ACCESSIBLE_WINDOW L"window"
#define ACCESSIBLE_FRAME L"frame"
#define ACCESSIBLE_DIALOG L"dialog"
#define ACCESSIBLE_COLOR_CHOOSER L"color chooser"
#define ACCESSIBLE_DIRECTORY_PANE L"directory pane"
#define ACCESSIBLE_FILE_CHOOSER L"file chooser"
#define ACCESSIBLE_FILLER L"filler"
#define ACCESSIBLE_HYPERLINK L"hyperlink"
#define ACCESSIBLE_ICON L"icon"
#define ACCESSIBLE_LABEL L"label"
#define ACCESSIBLE_ROOT_PANE L"root pane"
#define ACCESSIBLE_GLASS_PANE L"glass pane"
#define ACCESSIBLE_LAYERED_PANE L"layered pane"
#define ACCESSIBLE_LIST L"list"
#define ACCESSIBLE_LIST_ITEM L"list item"
#define ACCESSIBLE_MENU_BAR L"menu bar"
#define ACCESSIBLE_POPUP_MENU L"popup menu"
#define ACCESSIBLE_MENU L"menu"
#define ACCESSIBLE_MENU_ITEM L"menu item"
#define ACCESSIBLE_SEPARATOR L"separator"
#define ACCESSIBLE_PAGE_TAB_LIST L"page tab list"
#define ACCESSIBLE_PAGE_TAB L"page tab"
#define ACCESSIBLE_PANEL L"panel"
#define ACCESSIBLE_PROGRESS_BAR L"progress bar"
#define ACCESSIBLE_PASSWORD_TEXT L"password text"
#define ACCESSIBLE_PUSH_BUTTON L"push button"
#define ACCESSIBLE_TOGGLE_BUTTON L"toggle button"
#define ACCESSIBLE_CHECK_BOX L"check box"
#define ACCESSIBLE_RADIO_BUTTON L"radio button"
#define ACCESSIBLE_ROW_HEADER L"row header"
#define ACCESSIBLE_SCROLL_PANE L"scroll pane"
#define ACCESSIBLE_SCROLL_BAR L"scroll bar"
#define ACCESSIBLE_VIEWPORT L"viewport"
#define ACCESSIBLE_SLIDER L"slider"
#define ACCESSIBLE_SPLIT_PANE L"split pane"
#define ACCESSIBLE_TABLE L"table"
#define ACCESSIBLE_TEXT L"text"
#define ACCESSIBLE_TREE L"tree"
#define ACCESSIBLE_TOOL_BAR L"tool bar"
#define ACCESSIBLE_TOOL_TIP L"tool tip"
#define ACCESSIBLE_AWT_COMPONENT L"awt component"
#define ACCESSIBLE_SWING_COMPONENT L"swing component"
#define ACCESSIBLE_UNKNOWN L"unknown"
#define ACCESSIBLE_STATUS_BAR L"status bar"
#define ACCESSIBLE_DATE_EDITOR L"date editor"
#define ACCESSIBLE_SPIN_BOX L"spin box"
#define ACCESSIBLE_FONT_CHOOSER L"font chooser"
#define ACCESSIBLE_GROUP_BOX L"group box"
#define ACCESSIBLE_HEADER L"header"
#define ACCESSIBLE_FOOTER L"footer"
#define ACCESSIBLE_PARAGRAPH L"paragraph"
#define ACCESSIBLE_RULER L"ruler"
#define ACCESSIBLE_EDITBAR L"editbar"
#define PROGRESS_MONITOR L"progress monitor"
#define cPropertyNameChangeEvent (jlong)1 // 1
#define cPropertyDescriptionChangeEvent (jlong)2 // 2
#define cPropertyStateChangeEvent (jlong)4 // 4
#define cPropertyValueChangeEvent (jlong)8 // 8
#define cPropertySelectionChangeEvent (jlong)16 // 10
#define cPropertyTextChangeEvent (jlong)32 // 20
#define cPropertyCaretChangeEvent (jlong)64 // 40
#define cPropertyVisibleDataChangeEvent (jlong)128 // 80
#define cPropertyChildChangeEvent (jlong)256 // 100
#define cPropertyActiveDescendentChangeEvent (jlong)512 // 200
#define cPropertyTableModelChangeEvent (jlong)1024 // 400
#define cAccessibleValueInterface (jlong)1 // 1 << 1 (TRUE)
#define cAccessibleActionInterface (jlong)2 // 1 << 2
#define cAccessibleComponentInterface (jlong)4 // 1 << 3
#define cAccessibleSelectionInterface (jlong)8 // 1 << 4
#define cAccessibleTableInterface (jlong)16 // 1 << 5
#define cAccessibleTextInterface (jlong)32 // 1 << 6
#define cAccessibleHypertextInterface (jlong)64 // 1 << 7
typedef struct AccessBridgeVersionInfoTag
{
wchar_t VMversion[SHORT_STRING_SIZE];
wchar_t bridgeJavaClassVersion[SHORT_STRING_SIZE];
wchar_t bridgeJavaDLLVersion[SHORT_STRING_SIZE];
wchar_t bridgeWinDLLVersion[SHORT_STRING_SIZE];
} AccessBridgeVersionInfo;
typedef struct AccessibleContextInfoTag
{
wchar_t name[MAX_STRING_SIZE];
wchar_t description[MAX_STRING_SIZE];
wchar_t role[SHORT_STRING_SIZE];
wchar_t role_en_US[SHORT_STRING_SIZE];
wchar_t states[SHORT_STRING_SIZE];
wchar_t states_en_US[SHORT_STRING_SIZE];
jint indexInParent;
jint childrenCount;
jint x;
jint y;
jint width;
jint height;
BOOL accessibleComponent;
BOOL accessibleAction;
BOOL accessibleSelection;
BOOL accessibleText;
BOOL accessibleInterfaces;
} AccessibleContextInfo;
typedef struct AccessibleTextInfoTag
{
jint charCount;
jint caretIndex;
jint indexAtPoint;
} AccessibleTextInfo;
typedef struct AccessibleTextItemsInfoTag
{
wchar_t letter;
wchar_t word[SHORT_STRING_SIZE];
wchar_t sentence[MAX_STRING_SIZE];
} AccessibleTextItemsInfo;
typedef struct AccessibleTextSelectionInfoTag
{
jint selectionStartIndex;
jint selectionEndIndex;
wchar_t selectedText[MAX_STRING_SIZE];
} AccessibleTextSelectionInfo;
typedef struct AccessibleTextRectInfoTag
{
jint x;
jint y;
jint width;
jint height;
} AccessibleTextRectInfo;
typedef struct AccessibleTextAttributesInfoTag
{
BOOL bold;
BOOL italic;
BOOL underline;
BOOL strikethrough;
BOOL superscript;
BOOL subscript;
wchar_t backgroundColor[SHORT_STRING_SIZE];
wchar_t foregroundColor[SHORT_STRING_SIZE];
wchar_t fontFamily[SHORT_STRING_SIZE];
jint fontSize;
jint alignment;
jint bidiLevel;
jfloat firstLineIndent;
jfloat leftIndent;
jfloat rightIndent;
jfloat lineSpacing;
jfloat spaceAbove;
jfloat spaceBelow;
wchar_t fullAttributesString[MAX_STRING_SIZE];
} AccessibleTextAttributesInfo;
#define cMemoryMappedNameSize 255
typedef struct MemoryMappedFileCreatedPackageTag
{
ABHWND64 bridgeWindow;
char filename[cMemoryMappedNameSize];
} MemoryMappedFileCreatedPackage;
typedef struct JavaVMCreatedPackageTag
{
ABHWND64 bridgeWindow;
long vmID;
} JavaVMCreatedPackage;
typedef struct JavaVMDestroyedPackageTag
{
ABHWND64 bridgeWindow;
} JavaVMDestroyedPackage;
typedef struct WindowsATCreatedPackageTag
{
ABHWND64 bridgeWindow;
} WindowsATCreatedPackage;
typedef struct WindowsATDestroyedPackageTag
{
ABHWND64 bridgeWindow;
} WindowsATDestroyedPackage;
typedef struct JavaVMPresentNotificationPackageTag
{
ABHWND64 bridgeWindow;
long vmID;
} JavaVMPresentNotificationPackage;
typedef struct WindowsATPresentNotificationPackageTag
{
ABHWND64 bridgeWindow;
} WindowsATPresentNotificationPackage;
typedef struct ReleaseJavaObjectPackageTag
{
long vmID;
JOBJECT64 object;
} ReleaseJavaObjectPackage;
typedef struct GetAccessBridgeVersionPackageTag
{
long vmID;
AccessBridgeVersionInfo rVersionInfo;
} GetAccessBridgeVersionPackage;
typedef struct IsSameObjectPackageTag
{
long vmID;
JOBJECT64 obj1;
JOBJECT64 obj2;
jboolean rResult;
} IsSameObjectPackage;
typedef struct IsJavaWindowPackageTag
{
jint window;
jboolean rResult;
} IsJavaWindowPackage;
typedef struct GetAccessibleContextFromHWNDPackageTag
{
jint window;
long rVMID;
JOBJECT64 rAccessibleContext;
} GetAccessibleContextFromHWNDPackage;
typedef struct GetHWNDFromAccessibleContextPackageTag
{
JOBJECT64 accessibleContext;
ABHWND64 rHWND;
} GetHWNDFromAccessibleContextPackage;
typedef struct GetAccessibleContextAtPackageTag
{
jint x;
jint y;
long vmID;
JOBJECT64 AccessibleContext;
JOBJECT64 rAccessibleContext;
} GetAccessibleContextAtPackage;
typedef struct GetAccessibleContextWithFocusPackageTag
{
long rVMID;
JOBJECT64 rAccessibleContext;
} GetAccessibleContextWithFocusPackage;
typedef struct GetAccessibleContextInfoPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
AccessibleContextInfo rAccessibleContextInfo;
} GetAccessibleContextInfoPackage;
typedef struct GetAccessibleChildFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint childIndex;
JOBJECT64 rAccessibleContext;
} GetAccessibleChildFromContextPackage;
typedef struct GetAccessibleParentFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
JOBJECT64 rAccessibleContext;
} GetAccessibleParentFromContextPackage;
#define MAX_TABLE_SELECTIONS 64
typedef struct AccessibleTableInfoTag
{
JOBJECT64 caption;
JOBJECT64 summary;
jint rowCount;
jint columnCount;
JOBJECT64 accessibleContext;
JOBJECT64 accessibleTable;
} AccessibleTableInfo;
typedef struct GetAccessibleTableInfoPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleTableInfo rTableInfo;
} GetAccessibleTableInfoPackage;
typedef struct AccessibleTableCellInfoTag
{
JOBJECT64 accessibleContext;
jint index;
jint row;
jint column;
jint rowExtent;
jint columnExtent;
jboolean isSelected;
} AccessibleTableCellInfo;
typedef struct GetAccessibleTableCellInfoPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint row;
jint column;
AccessibleTableCellInfo rTableCellInfo;
} GetAccessibleTableCellInfoPackage;
typedef struct GetAccessibleTableRowHeaderPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleTableInfo rTableInfo;
} GetAccessibleTableRowHeaderPackage;
typedef struct GetAccessibleTableColumnHeaderPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleTableInfo rTableInfo;
} GetAccessibleTableColumnHeaderPackage;
typedef struct GetAccessibleTableRowDescriptionPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
jint row;
JOBJECT64 rAccessibleContext;
} GetAccessibleTableRowDescriptionPackage;
typedef struct GetAccessibleTableColumnDescriptionPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
jint column;
JOBJECT64 rAccessibleContext;
} GetAccessibleTableColumnDescriptionPackage;
typedef struct GetAccessibleTableRowSelectionCountPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint rCount;
} GetAccessibleTableRowSelectionCountPackage;
typedef struct IsAccessibleTableRowSelectedPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint row;
jboolean rResult;
} IsAccessibleTableRowSelectedPackage;
typedef struct GetAccessibleTableRowSelectionsPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint count;
jint rSelections[MAX_TABLE_SELECTIONS];
} GetAccessibleTableRowSelectionsPackage;
typedef struct GetAccessibleTableColumnSelectionCountPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint rCount;
} GetAccessibleTableColumnSelectionCountPackage;
typedef struct IsAccessibleTableColumnSelectedPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint column;
jboolean rResult;
} IsAccessibleTableColumnSelectedPackage;
typedef struct GetAccessibleTableColumnSelectionsPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint count;
jint rSelections[MAX_TABLE_SELECTIONS];
} GetAccessibleTableColumnSelectionsPackage;
typedef struct GetAccessibleTableRowPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint index;
jint rRow;
} GetAccessibleTableRowPackage;
typedef struct GetAccessibleTableColumnPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint index;
jint rColumn;
} GetAccessibleTableColumnPackage;
typedef struct GetAccessibleTableIndexPackageTag
{
long vmID;
JOBJECT64 accessibleTable;
jint row;
jint column;
jint rIndex;
} GetAccessibleTableIndexPackage;
#define MAX_RELATION_TARGETS 25
#define MAX_RELATIONS 5
typedef struct AccessibleRelationInfoTag
{
wchar_t key[SHORT_STRING_SIZE];
jint targetCount;
JOBJECT64 targets[MAX_RELATION_TARGETS];
} AccessibleRelationInfo;
typedef struct AccessibleRelationSetInfoTag
{
jint relationCount;
AccessibleRelationInfo relations[MAX_RELATIONS];
} AccessibleRelationSetInfo;
typedef struct GetAccessibleRelationSetPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleRelationSetInfo rAccessibleRelationSetInfo;
} GetAccessibleRelationSetPackage;
#define MAX_HYPERLINKS 64 // maximum number of hyperlinks returned
typedef struct AccessibleHyperlinkInfoTag
{
wchar_t text[SHORT_STRING_SIZE];
jint startIndex;
jint endIndex;
JOBJECT64 accessibleHyperlink;
} AccessibleHyperlinkInfo;
typedef struct AccessibleHypertextInfoTag
{
jint linkCount;
AccessibleHyperlinkInfo links[MAX_HYPERLINKS];
JOBJECT64 accessibleHypertext;
} AccessibleHypertextInfo;
typedef struct GetAccessibleHypertextPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleHypertextInfo rAccessibleHypertextInfo;
} GetAccessibleHypertextPackage;
typedef struct ActivateAccessibleHyperlinkPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
JOBJECT64 accessibleHyperlink;
BOOL rResult;
} ActivateAccessibleHyperlinkPackage;
typedef struct GetAccessibleHyperlinkCountPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
jint rLinkCount;
} GetAccessibleHyperlinkCountPackage;
typedef struct GetAccessibleHypertextExtPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
jint startIndex;
AccessibleHypertextInfo rAccessibleHypertextInfo;
BOOL rSuccess;
} GetAccessibleHypertextExtPackage;
typedef struct GetAccessibleHyperlinkPackageTag
{
long vmID;
JOBJECT64 hypertext;
jint linkIndex;
AccessibleHyperlinkInfo rAccessibleHyperlinkInfo;
} GetAccessibleHyperlinkPackage;
typedef struct GetAccessibleHypertextLinkIndexPackageTag
{
long vmID;
JOBJECT64 hypertext;
jint charIndex;
jint rLinkIndex;
} GetAccessibleHypertextLinkIndexPackage;
#define MAX_KEY_BINDINGS 10
#define ACCESSIBLE_SHIFT_KEYSTROKE 1
#define ACCESSIBLE_CONTROL_KEYSTROKE 2
#define ACCESSIBLE_META_KEYSTROKE 4
#define ACCESSIBLE_ALT_KEYSTROKE 8
#define ACCESSIBLE_ALT_GRAPH_KEYSTROKE 16
#define ACCESSIBLE_BUTTON1_KEYSTROKE 32
#define ACCESSIBLE_BUTTON2_KEYSTROKE 64
#define ACCESSIBLE_BUTTON3_KEYSTROKE 128
#define ACCESSIBLE_FKEY_KEYSTROKE 256 // F key pressed, character contains 1-24
#define ACCESSIBLE_CONTROLCODE_KEYSTROKE 512 // Control code key pressed, character contains control code.
#define ACCESSIBLE_VK_BACK_SPACE 8
#define ACCESSIBLE_VK_DELETE 127
#define ACCESSIBLE_VK_DOWN 40
#define ACCESSIBLE_VK_END 35
#define ACCESSIBLE_VK_HOME 36
#define ACCESSIBLE_VK_INSERT 155
#define ACCESSIBLE_VK_KP_DOWN 225
#define ACCESSIBLE_VK_KP_LEFT 226
#define ACCESSIBLE_VK_KP_RIGHT 227
#define ACCESSIBLE_VK_KP_UP 224
#define ACCESSIBLE_VK_LEFT 37
#define ACCESSIBLE_VK_PAGE_DOWN 34
#define ACCESSIBLE_VK_PAGE_UP 33
#define ACCESSIBLE_VK_RIGHT 39
#define ACCESSIBLE_VK_UP 38
typedef struct AccessibleKeyBindingInfoTag
{
jchar character;
jint modifiers;
} AccessibleKeyBindingInfo;
typedef struct AccessibleKeyBindingsTag
{
int keyBindingsCount;
AccessibleKeyBindingInfo keyBindingInfo[MAX_KEY_BINDINGS];
} AccessibleKeyBindings;
typedef struct GetAccessibleKeyBindingsPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleKeyBindings rAccessibleKeyBindings;
} GetAccessibleKeyBindingsPackage;
#define MAX_ICON_INFO 8
typedef struct AccessibleIconInfoTag
{
wchar_t description[SHORT_STRING_SIZE];
jint height;
jint width;
} AccessibleIconInfo;
typedef struct AccessibleIconsTag
{
jint iconsCount;
AccessibleIconInfo iconInfo[MAX_ICON_INFO];
} AccessibleIcons;
typedef struct GetAccessibleIconsPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleIcons rAccessibleIcons;
} GetAccessibleIconsPackage;
#define MAX_ACTION_INFO 256
#define MAX_ACTIONS_TO_DO 32
typedef struct AccessibleActionInfoTag
{
wchar_t name[SHORT_STRING_SIZE];
} AccessibleActionInfo;
typedef struct AccessibleActionsTag
{
jint actionsCount;
AccessibleActionInfo actionInfo[MAX_ACTION_INFO];
} AccessibleActions;
typedef struct GetAccessibleActionsPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleActions rAccessibleActions;
} GetAccessibleActionsPackage;
typedef struct AccessibleActionsToDoTag
{
jint actionsCount;
AccessibleActionInfo actions[MAX_ACTIONS_TO_DO];
} AccessibleActionsToDo;
typedef struct DoAccessibleActionsPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
AccessibleActionsToDo actionsToDo;
BOOL rResult;
jint failure;
} DoAccessibleActionsPackage;
typedef struct GetAccessibleTextInfoPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint x;
jint y;
AccessibleTextInfo rTextInfo;
} GetAccessibleTextInfoPackage;
typedef struct GetAccessibleTextItemsPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
AccessibleTextItemsInfo rTextItemsInfo;
} GetAccessibleTextItemsPackage;
typedef struct GetAccessibleTextSelectionInfoPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
AccessibleTextSelectionInfo rTextSelectionItemsInfo;
} GetAccessibleTextSelectionInfoPackage;
typedef struct GetAccessibleTextAttributeInfoPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
AccessibleTextAttributesInfo rAttributeInfo;
} GetAccessibleTextAttributeInfoPackage;
typedef struct GetAccessibleTextRectInfoPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
AccessibleTextRectInfo rTextRectInfo;
} GetAccessibleTextRectInfoPackage;
typedef struct GetCaretLocationPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
AccessibleTextRectInfo rTextRectInfo;
} GetCaretLocationPackage;
typedef struct GetAccessibleTextLineBoundsPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
jint rLineStart;
jint rLineEnd;
} GetAccessibleTextLineBoundsPackage;
typedef struct GetAccessibleTextRangePackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint start;
jint end;
wchar_t rText[MAX_BUFFER_SIZE];
} GetAccessibleTextRangePackage;
typedef struct SetTextContentsPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
wchar_t text[MAX_STRING_SIZE];
BOOL rResult;
} SetTextContentsPackage;
typedef struct GetParentWithRolePackageTag
{
long vmID;
JOBJECT64 accessibleContext;
wchar_t role[SHORT_STRING_SIZE];
JOBJECT64 rAccessibleContext;
} GetParentWithRolePackage;
typedef struct GetTopLevelObjectPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
JOBJECT64 rAccessibleContext;
} GetTopLevelObjectPackage;
typedef struct GetParentWithRoleElseRootPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
wchar_t role[SHORT_STRING_SIZE];
JOBJECT64 rAccessibleContext;
} GetParentWithRoleElseRootPackage;
typedef struct GetObjectDepthPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
jint rResult;
} GetObjectDepthPackage;
typedef struct GetActiveDescendentPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
JOBJECT64 rAccessibleContext;
} GetActiveDescendentPackage;
typedef struct GetCurrentAccessibleValueFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
wchar_t rValue[SHORT_STRING_SIZE];
} GetCurrentAccessibleValueFromContextPackage;
typedef struct GetMaximumAccessibleValueFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
wchar_t rValue[SHORT_STRING_SIZE];
} GetMaximumAccessibleValueFromContextPackage;
typedef struct GetMinimumAccessibleValueFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
wchar_t rValue[SHORT_STRING_SIZE];
} GetMinimumAccessibleValueFromContextPackage;
typedef struct AddAccessibleSelectionFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
} AddAccessibleSelectionFromContextPackage;
typedef struct ClearAccessibleSelectionFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
} ClearAccessibleSelectionFromContextPackage;
typedef struct GetAccessibleSelectionFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
JOBJECT64 rAccessibleContext;
} GetAccessibleSelectionFromContextPackage;
typedef struct GetAccessibleSelectionCountFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint rCount;
} GetAccessibleSelectionCountFromContextPackage;
typedef struct IsAccessibleChildSelectedFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
jboolean rResult;
} IsAccessibleChildSelectedFromContextPackage;
typedef struct RemoveAccessibleSelectionFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
jint index;
} RemoveAccessibleSelectionFromContextPackage;
typedef struct SelectAllAccessibleSelectionFromContextPackageTag
{
long vmID;
JOBJECT64 AccessibleContext;
} SelectAllAccessibleSelectionFromContextPackage;
typedef struct AddJavaEventNotificationPackageTag
{
jlong type;
ABHWND64 DLLwindow;
} AddJavaEventNotificationPackage;
typedef struct RemoveJavaEventNotificationPackageTag
{
jlong type;
ABHWND64 DLLwindow;
} RemoveJavaEventNotificationPackage;
typedef struct AddAccessibilityEventNotificationPackageTag
{
jlong type;
ABHWND64 DLLwindow;
} AddAccessibilityEventNotificationPackage;
typedef struct RemoveAccessibilityEventNotificationPackageTag
{
jlong type;
ABHWND64 DLLwindow;
} RemoveAccessibilityEventNotificationPackage;
typedef struct PropertyCaretChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
jint oldPosition;
jint newPosition;
} PropertyCaretChangePackage;
typedef struct PropertyDescriptionChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
wchar_t oldDescription[SHORT_STRING_SIZE];
wchar_t newDescription[SHORT_STRING_SIZE];
} PropertyDescriptionChangePackage;
typedef struct PropertyNameChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
wchar_t oldName[SHORT_STRING_SIZE];
wchar_t newName[SHORT_STRING_SIZE];
} PropertyNameChangePackage;
typedef struct PropertySelectionChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} PropertySelectionChangePackage;
typedef struct PropertyStateChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
wchar_t oldState[SHORT_STRING_SIZE];
wchar_t newState[SHORT_STRING_SIZE];
} PropertyStateChangePackage;
typedef struct PropertyTextChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} PropertyTextChangePackage;
typedef struct PropertyValueChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
wchar_t oldValue[SHORT_STRING_SIZE];
wchar_t newValue[SHORT_STRING_SIZE];
} PropertyValueChangePackage;
typedef struct PropertyVisibleDataChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} PropertyVisibleDataChangePackage;
typedef struct PropertyChildChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
JOBJECT64 oldChildAccessibleContext;
JOBJECT64 newChildAccessibleContext;
} PropertyChildChangePackage;
typedef struct PropertyActiveDescendentChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
JOBJECT64 oldActiveDescendentAccessibleContext;
JOBJECT64 newActiveDescendentAccessibleContext;
} PropertyActiveDescendentChangePackage;
typedef struct PropertyTableModelChangePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
wchar_t oldValue[SHORT_STRING_SIZE];
wchar_t newValue[SHORT_STRING_SIZE];
} PropertyTableModelChangePackage;
typedef struct JavaShutdownPackageTag
{
long vmID;
} JavaShutdownPackage;
typedef struct FocusGainedPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} FocusGainedPackage;
typedef struct FocusLostPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} FocusLostPackage;
typedef struct CaretUpdatePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} CaretUpdatePackage;
typedef struct MouseClickedPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MouseClickedPackage;
typedef struct MouseEnteredPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MouseEnteredPackage;
typedef struct MouseExitedPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MouseExitedPackage;
typedef struct MousePressedPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MousePressedPackage;
typedef struct MouseReleasedPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MouseReleasedPackage;
typedef struct MenuCanceledPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MenuCanceledPackage;
typedef struct MenuDeselectedPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MenuDeselectedPackage;
typedef struct MenuSelectedPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} MenuSelectedPackage;
typedef struct PopupMenuCanceledPackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} PopupMenuCanceledPackage;
typedef struct PopupMenuWillBecomeInvisiblePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} PopupMenuWillBecomeInvisiblePackage;
typedef struct PopupMenuWillBecomeVisiblePackageTag
{
long vmID;
JOBJECT64 Event;
JOBJECT64 AccessibleContextSource;
} PopupMenuWillBecomeVisiblePackage;
typedef struct GetVirtualAccessibleNamePackageTag
{
long vmID;
AccessibleContext accessibleContext;
wchar_t rName[MAX_STRING_SIZE];
int len;
} GetVirtualAccessibleNamePackage;
typedef struct RequestFocusPackageTag
{
long vmID;
AccessibleContext accessibleContext;
} RequestFocusPackage;
typedef struct SelectTextRangePackageTag
{
long vmID;
AccessibleContext accessibleContext;
jint startIndex;
jint endIndex;
} SelectTextRangePackage;
typedef struct GetTextAttributesInRangePackageTag
{
long vmID;
AccessibleContext accessibleContext;
jint startIndex;
jint endIndex;
AccessibleTextAttributesInfo attributes;
short rLength;
} GetTextAttributesInRangePackage;
#define MAX_VISIBLE_CHILDREN 256
typedef struct VisibleChildenInfoTag
{
int returnedChildrenCount;
AccessibleContext children[MAX_VISIBLE_CHILDREN];
} VisibleChildrenInfo;
typedef struct GetVisibleChildrenCountPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
jint rChildrenCount;
} GetVisibleChildrenCountPackage;
typedef struct GetVisibleChildrenPackageTag
{
long vmID;
JOBJECT64 accessibleContext;
jint startIndex;
VisibleChildrenInfo rVisibleChildrenInfo;
BOOL rSuccess;
} GetVisibleChildrenPackage;
typedef struct SetCaretPositionPackageTag
{
long vmID;
AccessibleContext accessibleContext;
jint position;
} SetCaretPositionPackage;
typedef enum PackageType
{
cMemoryMappedFileCreatedPackage = 0x11000,
cJavaVMCreatedPackage = 0x10000,
cJavaVMDestroyedPackage,
cWindowsATCreatedPackage,
cWindowsATDestroyedPackage,
cJavaVMPresentNotificationPackage,
cWindowsATPresentNotificationPackage,
cReleaseJavaObjectPackage = 1,
cGetAccessBridgeVersionPackage = 2,
cGetAccessibleContextFromHWNDPackage = 0x10,
cIsJavaWindowPackage,
cGetHWNDFromAccessibleContextPackage,
cGetAccessibleContextAtPackage = 0x100,
cGetAccessibleContextWithFocusPackage,
cGetAccessibleContextInfoPackage,
cGetAccessibleChildFromContextPackage,
cGetAccessibleParentFromContextPackage,
cIsSameObjectPackage,
cGetAccessibleTextInfoPackage = 0x200,
cGetAccessibleTextItemsPackage,
cGetAccessibleTextSelectionInfoPackage,
cGetAccessibleTextAttributeInfoPackage,
cGetAccessibleTextRectInfoPackage,
cGetAccessibleTextLineBoundsPackage,
cGetAccessibleTextRangePackage,
cGetCurrentAccessibleValueFromContextPackage = 0x300,
cGetMaximumAccessibleValueFromContextPackage,
cGetMinimumAccessibleValueFromContextPackage,
cAddAccessibleSelectionFromContextPackage = 0x400,
cClearAccessibleSelectionFromContextPackage,
cGetAccessibleSelectionFromContextPackage,
cGetAccessibleSelectionCountFromContextPackage,
cIsAccessibleChildSelectedFromContextPackage,
cRemoveAccessibleSelectionFromContextPackage,
cSelectAllAccessibleSelectionFromContextPackage,
cAddJavaEventNotificationPackage = 0x900,
cRemoveJavaEventNotificationPackage,
cAddAccessibilityEventNotificationPackage,
cRemoveAccessibilityEventNotificationPackage,
cPropertyChangePackage = 0x1000,
cJavaShutdownPackage = 0x1010,
cFocusGainedPackage,
cFocusLostPackage,
cCaretUpdatePackage = 0x1020,
cMouseClickedPackage = 0x1030,
cMouseEnteredPackage,
cMouseExitedPackage,
cMousePressedPackage,
cMouseReleasedPackage,
cMenuCanceledPackage = 0x1040,
cMenuDeselectedPackage,
cMenuSelectedPackage,
cPopupMenuCanceledPackage,
cPopupMenuWillBecomeInvisiblePackage,
cPopupMenuWillBecomeVisiblePackage,
cPropertyCaretChangePackage = 0x1100,
cPropertyDescriptionChangePackage,
cPropertyNameChangePackage,
cPropertySelectionChangePackage,
cPropertyStateChangePackage,
cPropertyTextChangePackage,
cPropertyValueChangePackage,
cPropertyVisibleDataChangePackage,
cPropertyChildChangePackage,
cPropertyActiveDescendentChangePackage,
cGetAccessibleTableInfoPackage = 0x1200,
cGetAccessibleTableCellInfoPackage,
cGetAccessibleTableRowHeaderPackage,
cGetAccessibleTableColumnHeaderPackage,
cGetAccessibleTableRowDescriptionPackage,
cGetAccessibleTableColumnDescriptionPackage,
cGetAccessibleTableRowSelectionCountPackage,
cIsAccessibleTableRowSelectedPackage,
cGetAccessibleTableRowSelectionsPackage,
cGetAccessibleTableColumnSelectionCountPackage,
cIsAccessibleTableColumnSelectedPackage,
cGetAccessibleTableColumnSelectionsPackage,
cGetAccessibleTableRowPackage,
cGetAccessibleTableColumnPackage,
cGetAccessibleTableIndexPackage,
cPropertyTableModelChangePackage,
cGetAccessibleRelationSetPackage = 0x1300,
cGetAccessibleHypertextPackage = 0x1400,
cActivateAccessibleHyperlinkPackage,
cGetAccessibleHyperlinkCountPackage,
cGetAccessibleHypertextExtPackage,
cGetAccessibleHypertextLinkIndexPackage,
cGetAccessibleHyperlinkPackage,
cGetAccessibleKeyBindingsPackage = 0x1500,
cGetAccessibleIconsPackage,
cGetAccessibleActionsPackage,
cDoAccessibleActionsPackage,
cSetTextContentsPackage = 0x1600,
cGetParentWithRolePackage,
cGetTopLevelObjectPackage,
cGetParentWithRoleElseRootPackage,
cGetObjectDepthPackage,
cGetActiveDescendentPackage,
cGetVirtualAccessibleNamePackage = 0x1700,
cRequestFocusPackage,
cSelectTextRangePackage,
cGetTextAttributesInRangePackage,
cGetSameTextAttributesInRangePackage,
cGetVisibleChildrenCountPackage,
cGetVisibleChildrenPackage,
cSetCaretPositionPackage,
cGetCaretLocationPackage
} PackageType;
typedef union AllPackagesTag
{
MemoryMappedFileCreatedPackage memoryMappedFileCreatedPackage;
JavaVMCreatedPackage javaVMCreatedPackage;
JavaVMDestroyedPackage javaVMDestroyedPackage;
WindowsATCreatedPackage windowsATCreatedPackage;
WindowsATDestroyedPackage windowsATDestroyedPackage;
JavaVMPresentNotificationPackage javaVMPresentNotificationPackage;
WindowsATPresentNotificationPackage windowsATPresentNotificationPackage;
ReleaseJavaObjectPackage releaseJavaObject;
GetAccessBridgeVersionPackage getAccessBridgeVersion;
GetAccessibleContextFromHWNDPackage getAccessibleContextFromHWND;
GetHWNDFromAccessibleContextPackage getHWNDFromAccessibleContext;
GetAccessibleContextAtPackage getAccessibleContextAt;
GetAccessibleContextWithFocusPackage getAccessibleContextWithFocus;
GetAccessibleContextInfoPackage getAccessibleContextInfo;
GetAccessibleChildFromContextPackage getAccessibleChildFromContext;
GetAccessibleParentFromContextPackage getAccessibleParentFromContext;
GetAccessibleTextInfoPackage getAccessibleTextInfo;
GetAccessibleTextItemsPackage getAccessibleTextItems;
GetAccessibleTextSelectionInfoPackage getAccessibleTextSelectionInfo;
GetAccessibleTextAttributeInfoPackage getAccessibleTextAttributeInfo;
GetAccessibleTextRectInfoPackage getAccessibleTextRectInfo;
GetAccessibleTextLineBoundsPackage getAccessibleTextLineBounds;
GetAccessibleTextRangePackage getAccessibleTextRange;
GetCurrentAccessibleValueFromContextPackage getCurrentAccessibleValueFromContext;
GetMaximumAccessibleValueFromContextPackage getMaximumAccessibleValueFromContext;
GetMinimumAccessibleValueFromContextPackage getMinimumAccessibleValueFromContext;
AddAccessibleSelectionFromContextPackage addAccessibleSelectionFromContext;
ClearAccessibleSelectionFromContextPackage clearAccessibleSelectionFromContext;
GetAccessibleSelectionFromContextPackage getAccessibleSelectionFromContext;
GetAccessibleSelectionCountFromContextPackage getAccessibleSelectionCountFromContext;
IsAccessibleChildSelectedFromContextPackage isAccessibleChildSelectedFromContext;
RemoveAccessibleSelectionFromContextPackage removeAccessibleSelectionFromContext;
SelectAllAccessibleSelectionFromContextPackage selectAllAccessibleSelectionFromContext;
AddJavaEventNotificationPackage addJavaEventNotification;
RemoveJavaEventNotificationPackage removeJavaEventNotification;
AddAccessibilityEventNotificationPackage addAccessibilityEventNotification;
RemoveAccessibilityEventNotificationPackage removeAccessibilityEventNotification;
PropertyCaretChangePackage propertyCaretChangePackage;
PropertyDescriptionChangePackage propertyDescriptionChangePackage;
PropertyNameChangePackage propertyNameChangePackage;
PropertySelectionChangePackage propertySelectionChangePackage;
PropertyStateChangePackage propertyStateChangePackage;
PropertyTextChangePackage propertyTextChangePackage;
PropertyValueChangePackage propertyValueChangePackage;
PropertyVisibleDataChangePackage propertyVisibleDataChangePackage;
PropertyChildChangePackage propertyChildChangePackage;
PropertyActiveDescendentChangePackage propertyActiveDescendentChangePackage;
PropertyTableModelChangePackage propertyTableModelChangePackage;
JavaShutdownPackage JavaShutdown;
FocusGainedPackage focusGained;
FocusLostPackage focusLost;
CaretUpdatePackage caretUpdate;
MouseClickedPackage mouseClicked;
MouseEnteredPackage mouseEntered;
MouseExitedPackage mouseExited;
MousePressedPackage mousePressed;
MouseReleasedPackage mouseReleased;
MenuCanceledPackage menuCanceled;
MenuDeselectedPackage menuDeselected;
MenuSelectedPackage menuSelected;
PopupMenuCanceledPackage popupMenuCanceled;
PopupMenuWillBecomeInvisiblePackage popupMenuWillBecomeInvisible;
PopupMenuWillBecomeVisiblePackage popupMenuWillBecomeVisible;
GetAccessibleRelationSetPackage getAccessibleRelationSet;
GetAccessibleHypertextPackage _getAccessibleHypertext;
ActivateAccessibleHyperlinkPackage _activateAccessibleHyperlink;
GetAccessibleHyperlinkCountPackage _getAccessibleHyperlinkCount;
GetAccessibleHypertextExtPackage _getAccessibleHypertextExt;
GetAccessibleHypertextLinkIndexPackage _getAccessibleHypertextLinkIndex;
GetAccessibleHyperlinkPackage _getAccessibleHyperlink;
GetAccessibleKeyBindingsPackage getAccessibleKeyBindings;
GetAccessibleIconsPackage getAccessibleIcons;
GetAccessibleActionsPackage getAccessibleActions;
DoAccessibleActionsPackage doAccessibleActions;
SetTextContentsPackage _setTextContents;
GetParentWithRolePackage _getParentWithRole;
GetTopLevelObjectPackage _getTopLevelObject;
GetParentWithRoleElseRootPackage _getParentWithRoleElseRoot;
GetObjectDepthPackage _getObjectDepth;
GetActiveDescendentPackage _getActiveDescendent;
GetVirtualAccessibleNamePackage _getVirtualAccessibleName;
RequestFocusPackage _requestFocus;
SelectTextRangePackage _selectTextRange;
GetTextAttributesInRangePackage _getTextAttributesInRange;
GetVisibleChildrenCountPackage _getVisibleChildrenCount;
GetVisibleChildrenPackage _getVisibleChildren;
SetCaretPositionPackage _setCaretPosition;
} AllPackages;
typedef union JavaInitiatedPackagesTag
{
JavaVMCreatedPackage javaVMCreatedPackage;
JavaVMDestroyedPackage javaVMDestroyedPackage;
JavaVMPresentNotificationPackage javaVMPresentNotificationPackage;
PropertyCaretChangePackage propertyCaretChangePackage;
PropertyDescriptionChangePackage propertyDescriptionChangePackage;
PropertyNameChangePackage propertyNameChangePackage;
PropertySelectionChangePackage propertySelectionChangePackage;
PropertyStateChangePackage propertyStateChangePackage;
PropertyTextChangePackage propertyTextChangePackage;
PropertyValueChangePackage propertyValueChangePackage;
PropertyVisibleDataChangePackage propertyVisibleDataChangePackage;
PropertyChildChangePackage propertyChildChangePackage;
PropertyActiveDescendentChangePackage propertyActiveDescendentChangePackage;
PropertyTableModelChangePackage propertyTableModelChangePackage;
JavaShutdownPackage JavaShutdown;
FocusGainedPackage focusGained;
FocusLostPackage focusLost;
CaretUpdatePackage caretUpdate;
MouseClickedPackage mouseClicked;
MouseEnteredPackage mouseEntered;
MouseExitedPackage mouseExited;
MousePressedPackage mousePressed;
MouseReleasedPackage mouseReleased;
MenuCanceledPackage menuCanceled;
MenuDeselectedPackage menuDeselected;
MenuSelectedPackage menuSelected;
PopupMenuCanceledPackage popupMenuCanceled;
PopupMenuWillBecomeInvisiblePackage popupMenuWillBecomeInvisible;
PopupMenuWillBecomeVisiblePackage popupMenuWillBecomeVisible;
} JavaInitiatedPackages;
typedef union WindowsInitiatedPackagesTag
{
MemoryMappedFileCreatedPackage memoryMappedFileCreatedPackage;
WindowsATCreatedPackage windowsATCreatedPackage;
WindowsATDestroyedPackage windowsATDestroyedPackage;
WindowsATPresentNotificationPackage windowsATPresentNotificationPackage;
ReleaseJavaObjectPackage releaseJavaObject;
GetAccessBridgeVersionPackage getAccessBridgeVersion;
GetAccessibleContextFromHWNDPackage getAccessibleContextFromHWND;
GetHWNDFromAccessibleContextPackage getHWNDFromAccessibleContext;
GetAccessibleContextAtPackage getAccessibleContextAt;
GetAccessibleContextWithFocusPackage getAccessibleContextWithFocus;
GetAccessibleContextInfoPackage getAccessibleContextInfo;
GetAccessibleChildFromContextPackage getAccessibleChildFromContext;
GetAccessibleParentFromContextPackage getAccessibleParentFromContext;
GetAccessibleTextInfoPackage getAccessibleTextInfo;
GetAccessibleTextItemsPackage getAccessibleTextItems;
GetAccessibleTextSelectionInfoPackage getAccessibleTextSelectionInfo;
GetAccessibleTextAttributeInfoPackage getAccessibleTextAttributeInfo;
GetAccessibleTextRectInfoPackage getAccessibleTextRectInfo;
GetAccessibleTextLineBoundsPackage getAccessibleTextLineBounds;
GetAccessibleTextRangePackage getAccessibleTextRange;
GetCurrentAccessibleValueFromContextPackage getCurrentAccessibleValueFromContext;
GetMaximumAccessibleValueFromContextPackage getMaximumAccessibleValueFromContext;
GetMinimumAccessibleValueFromContextPackage getMinimumAccessibleValueFromContext;
AddAccessibleSelectionFromContextPackage addAccessibleSelectionFromContext;
ClearAccessibleSelectionFromContextPackage clearAccessibleSelectionFromContext;
GetAccessibleSelectionFromContextPackage getAccessibleSelectionFromContext;
GetAccessibleSelectionCountFromContextPackage getAccessibleSelectionCountFromContext;
IsAccessibleChildSelectedFromContextPackage isAccessibleChildSelectedFromContext;
RemoveAccessibleSelectionFromContextPackage removeAccessibleSelectionFromContext;
SelectAllAccessibleSelectionFromContextPackage selectAllAccessibleSelectionFromContext;
AddJavaEventNotificationPackage addJavaEventNotification;
RemoveJavaEventNotificationPackage removeJavaEventNotification;
AddAccessibilityEventNotificationPackage addAccessibilityEventNotification;
RemoveAccessibilityEventNotificationPackage removeAccessibilityEventNotification;
GetAccessibleTableInfoPackage _getAccessibleTableInfo;
GetAccessibleTableCellInfoPackage _getAccessibleTableCellInfo;
GetAccessibleTableRowHeaderPackage _getAccessibleTableRowHeader;
GetAccessibleTableColumnHeaderPackage _getAccessibleTableColumnHeader;
GetAccessibleTableRowDescriptionPackage _getAccessibleTableRowDescription;
GetAccessibleTableColumnDescriptionPackage _getAccessibleTableColumnDescription;
GetAccessibleTableRowSelectionCountPackage _getAccessibleTableRowSelectionCount;
IsAccessibleTableRowSelectedPackage _isAccessibleTableRowSelected;
GetAccessibleTableRowSelectionsPackage _getAccessibleTableRowSelections;
GetAccessibleTableColumnSelectionCountPackage _getAccessibleTableColumnSelectionCount;
IsAccessibleTableColumnSelectedPackage _isAccessibleTableColumnSelected;
GetAccessibleTableColumnSelectionsPackage _getAccessibleTableColumnSelections;
GetAccessibleTableRowPackage _getAccessibleTableRow;
GetAccessibleTableColumnPackage _getAccessibleTableColumn;
GetAccessibleTableIndexPackage _getAccessibleTableIndex;
GetAccessibleRelationSetPackage _getAccessibleRelationSet;
GetAccessibleKeyBindingsPackage _getAccessibleKeyBindings;
GetAccessibleIconsPackage _getAccessibleIcons;
GetAccessibleActionsPackage _getAccessibleActions;
DoAccessibleActionsPackage _doAccessibleActions;
IsSameObjectPackage _isSameObject;
SetTextContentsPackage _setTextContents;
GetParentWithRolePackage _getParentWithRole;
GetTopLevelObjectPackage _getTopLevelObject;
GetParentWithRoleElseRootPackage _getParentWithRoleElseRoot;
GetObjectDepthPackage _getObjectDepth;
GetActiveDescendentPackage _getActiveDescendent;
GetVirtualAccessibleNamePackage _getVirtualAccessibleName;
RequestFocusPackage _requestFocus;
SelectTextRangePackage _selectTextRange;
GetTextAttributesInRangePackage _getTextAttributesInRange;
GetVisibleChildrenCountPackage _getVisibleChildrenCount;
GetVisibleChildrenPackage _getVisibleChildren;
SetCaretPositionPackage _setCaretPosition;
} WindowsInitiatedPackages;
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_BRIDGECALLBACKS
#define INTERNAL_BRIDGECALLBACKS
#ifdef __cplusplus
extern "C"
{
#endif
typedef void (*AccessBridge_PropertyChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, wchar_t *property, wchar_t *oldValue, wchar_t *newValue);
typedef void (*AccessBridge_JavaShutdownFP)(long vmID);
typedef void (*AccessBridge_JavaShutdownFP)(long vmID);
typedef void (*AccessBridge_FocusGainedFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_FocusLostFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_CaretUpdateFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MouseClickedFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MouseEnteredFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MouseExitedFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MousePressedFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MouseReleasedFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MenuCanceledFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MenuDeselectedFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_MenuSelectedFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_PopupMenuCanceledFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_PopupMenuWillBecomeInvisibleFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_PopupMenuWillBecomeVisibleFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_PropertyNameChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, wchar_t *oldName, wchar_t *newName);
typedef void (*AccessBridge_PropertyDescriptionChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, wchar_t *oldDescription, wchar_t *newDescription);
typedef void (*AccessBridge_PropertyStateChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, wchar_t *oldState, wchar_t *newState);
typedef void (*AccessBridge_PropertyValueChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, wchar_t *oldValue, wchar_t *newValue);
typedef void (*AccessBridge_PropertySelectionChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_PropertyTextChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_PropertyCaretChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, int oldPosition, int newPosition);
typedef void (*AccessBridge_PropertyVisibleDataChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source);
typedef void (*AccessBridge_PropertyChildChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, JOBJECT64 oldChild, JOBJECT64 newChild);
typedef void (*AccessBridge_PropertyActiveDescendentChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 source, JOBJECT64 oldActiveDescendent, JOBJECT64 newActiveDescendent);
typedef void (*AccessBridge_PropertyTableModelChangeFP)(long vmID, JOBJECT64 event, JOBJECT64 src, wchar_t *oldValue, wchar_t *newValue);
#ifdef __cplusplus
}
#endif
#endif
#ifndef INTERNAL_ACCESSBRIDGECALLS
#define INTERNAL_ACCESSBRIDGECALLS
#ifdef __cplusplus
extern "C"
{
#endif
#define null NULL
typedef JOBJECT64 AccessibleContext;
typedef JOBJECT64 AccessibleText;
typedef JOBJECT64 AccessibleValue;
typedef JOBJECT64 AccessibleSelection;
typedef JOBJECT64 Java_Object;
typedef JOBJECT64 PropertyChangeEvent;
typedef JOBJECT64 FocusEvent;
typedef JOBJECT64 CaretEvent;
typedef JOBJECT64 MouseEvent;
typedef JOBJECT64 MenuEvent;
typedef JOBJECT64 AccessibleTable;
typedef JOBJECT64 AccessibleHyperlink;
typedef JOBJECT64 AccessibleHypertext;
typedef void (*Windows_runFP)();
typedef void (*SetPropertyChangeFP)(AccessBridge_PropertyChangeFP fp);
typedef void (*SetJavaShutdownFP)(AccessBridge_JavaShutdownFP fp);
typedef void (*SetFocusGainedFP)(AccessBridge_FocusGainedFP fp);
typedef void (*SetFocusLostFP)(AccessBridge_FocusLostFP fp);
typedef void (*SetCaretUpdateFP)(AccessBridge_CaretUpdateFP fp);
typedef void (*SetMouseClickedFP)(AccessBridge_MouseClickedFP fp);
typedef void (*SetMouseEnteredFP)(AccessBridge_MouseEnteredFP fp);
typedef void (*SetMouseExitedFP)(AccessBridge_MouseExitedFP fp);
typedef void (*SetMousePressedFP)(AccessBridge_MousePressedFP fp);
typedef void (*SetMouseReleasedFP)(AccessBridge_MouseReleasedFP fp);
typedef void (*SetMenuCanceledFP)(AccessBridge_MenuCanceledFP fp);
typedef void (*SetMenuDeselectedFP)(AccessBridge_MenuDeselectedFP fp);
typedef void (*SetMenuSelectedFP)(AccessBridge_MenuSelectedFP fp);
typedef void (*SetPopupMenuCanceledFP)(AccessBridge_PopupMenuCanceledFP fp);
typedef void (*SetPopupMenuWillBecomeInvisibleFP)(AccessBridge_PopupMenuWillBecomeInvisibleFP fp);
typedef void (*SetPopupMenuWillBecomeVisibleFP)(AccessBridge_PopupMenuWillBecomeVisibleFP fp);
typedef void (*SetPropertyNameChangeFP)(AccessBridge_PropertyNameChangeFP fp);
typedef void (*SetPropertyDescriptionChangeFP)(AccessBridge_PropertyDescriptionChangeFP fp);
typedef void (*SetPropertyStateChangeFP)(AccessBridge_PropertyStateChangeFP fp);
typedef void (*SetPropertyValueChangeFP)(AccessBridge_PropertyValueChangeFP fp);
typedef void (*SetPropertySelectionChangeFP)(AccessBridge_PropertySelectionChangeFP fp);
typedef void (*SetPropertyTextChangeFP)(AccessBridge_PropertyTextChangeFP fp);
typedef void (*SetPropertyCaretChangeFP)(AccessBridge_PropertyCaretChangeFP fp);
typedef void (*SetPropertyVisibleDataChangeFP)(AccessBridge_PropertyVisibleDataChangeFP fp);
typedef void (*SetPropertyChildChangeFP)(AccessBridge_PropertyChildChangeFP fp);
typedef void (*SetPropertyActiveDescendentChangeFP)(AccessBridge_PropertyActiveDescendentChangeFP fp);
typedef void (*SetPropertyTableModelChangeFP)(AccessBridge_PropertyTableModelChangeFP fp);
typedef void (*ReleaseJavaObjectFP)(long vmID, Java_Object object);
typedef BOOL (*GetVersionInfoFP)(long vmID, AccessBridgeVersionInfo *info);
typedef BOOL (*IsJavaWindowFP)(HWND window);
typedef BOOL (*IsSameObjectFP)(long vmID, JOBJECT64 obj1, JOBJECT64 obj2);
typedef BOOL (*GetAccessibleContextFromHWNDFP)(HWND window, long *vmID, AccessibleContext *ac);
typedef HWND (*getHWNDFromAccessibleContextFP)(long vmID, AccessibleContext ac);
typedef BOOL (*GetAccessibleContextAtFP)(long vmID, AccessibleContext acParent, jint x, jint y, AccessibleContext *ac);
typedef BOOL (*GetAccessibleContextWithFocusFP)(HWND window, long *vmID, AccessibleContext *ac);
typedef BOOL (*GetAccessibleContextInfoFP)(long vmID, AccessibleContext ac, AccessibleContextInfo *info);
typedef AccessibleContext (*GetAccessibleChildFromContextFP)(long vmID, AccessibleContext ac, jint i);
typedef AccessibleContext (*GetAccessibleParentFromContextFP)(long vmID, AccessibleContext ac);
typedef BOOL (*getAccessibleTableInfoFP)(long vmID, AccessibleContext ac, AccessibleTableInfo *tableInfo);
typedef BOOL (*getAccessibleTableCellInfoFP)(long vmID, AccessibleTable accessibleTable, jint row, jint column, AccessibleTableCellInfo *tableCellInfo);
typedef BOOL (*getAccessibleTableRowHeaderFP)(long vmID, AccessibleContext acParent, AccessibleTableInfo *tableInfo);
typedef BOOL (*getAccessibleTableColumnHeaderFP)(long vmID, AccessibleContext acParent, AccessibleTableInfo *tableInfo);
typedef AccessibleContext (*getAccessibleTableRowDescriptionFP)(long vmID, AccessibleContext acParent, jint row);
typedef AccessibleContext (*getAccessibleTableColumnDescriptionFP)(long vmID, AccessibleContext acParent, jint column);
typedef jint (*getAccessibleTableRowSelectionCountFP)(long vmID, AccessibleTable table);
typedef BOOL (*isAccessibleTableRowSelectedFP)(long vmID, AccessibleTable table, jint row);
typedef BOOL (*getAccessibleTableRowSelectionsFP)(long vmID, AccessibleTable table, jint count, jint *selections);
typedef jint (*getAccessibleTableColumnSelectionCountFP)(long vmID, AccessibleTable table);
typedef BOOL (*isAccessibleTableColumnSelectedFP)(long vmID, AccessibleTable table, jint column);
typedef BOOL (*getAccessibleTableColumnSelectionsFP)(long vmID, AccessibleTable table, jint count, jint *selections);
typedef jint (*getAccessibleTableRowFP)(long vmID, AccessibleTable table, jint index);
typedef jint (*getAccessibleTableColumnFP)(long vmID, AccessibleTable table, jint index);
typedef jint (*getAccessibleTableIndexFP)(long vmID, AccessibleTable table, jint row, jint column);
typedef BOOL (*getAccessibleRelationSetFP)(long vmID, AccessibleContext accessibleContext, AccessibleRelationSetInfo *relationSetInfo);
typedef BOOL (*getAccessibleHypertextFP)(long vmID, AccessibleContext accessibleContext, AccessibleHypertextInfo *hypertextInfo);
typedef BOOL (*activateAccessibleHyperlinkFP)(long vmID, AccessibleContext accessibleContext, AccessibleHyperlink accessibleHyperlink);
typedef jint (*getAccessibleHyperlinkCountFP)(const long vmID, const AccessibleContext accessibleContext);
typedef BOOL (*getAccessibleHypertextExtFP)(const long vmID, const AccessibleContext accessibleContext, const jint nStartIndex, AccessibleHypertextInfo *hypertextInfo);
typedef jint (*getAccessibleHypertextLinkIndexFP)(const long vmID, const AccessibleHypertext hypertext, const jint nIndex);
typedef BOOL (*getAccessibleHyperlinkFP)(const long vmID, const AccessibleHypertext hypertext, const jint nIndex, AccessibleHyperlinkInfo *hyperlinkInfo);
typedef BOOL (*getAccessibleKeyBindingsFP)(long vmID, AccessibleContext accessibleContext, AccessibleKeyBindings *keyBindings);
typedef BOOL (*getAccessibleIconsFP)(long vmID, AccessibleContext accessibleContext, AccessibleIcons *icons);
typedef BOOL (*getAccessibleActionsFP)(long vmID, AccessibleContext accessibleContext, AccessibleActions *actions);
typedef BOOL (*doAccessibleActionsFP)(long vmID, AccessibleContext accessibleContext, AccessibleActionsToDo *actionsToDo, jint *failure);
typedef BOOL (*GetAccessibleTextInfoFP)(long vmID, AccessibleText at, AccessibleTextInfo *textInfo, jint x, jint y);
typedef BOOL (*GetAccessibleTextItemsFP)(long vmID, AccessibleText at, AccessibleTextItemsInfo *textItems, jint index);
typedef BOOL (*GetAccessibleTextSelectionInfoFP)(long vmID, AccessibleText at, AccessibleTextSelectionInfo *textSelection);
typedef BOOL (*GetAccessibleTextAttributesFP)(long vmID, AccessibleText at, jint index, AccessibleTextAttributesInfo *attributes);
typedef BOOL (*GetAccessibleTextRectFP)(long vmID, AccessibleText at, AccessibleTextRectInfo *rectInfo, jint index);
typedef BOOL (*GetAccessibleTextLineBoundsFP)(long vmID, AccessibleText at, jint index, jint *startIndex, jint *endIndex);
typedef BOOL (*GetAccessibleTextRangeFP)(long vmID, AccessibleText at, jint start, jint end, wchar_t *text, short len);
typedef BOOL (*GetCurrentAccessibleValueFromContextFP)(long vmID, AccessibleValue av, wchar_t *value, short len);
typedef BOOL (*GetMaximumAccessibleValueFromContextFP)(long vmID, AccessibleValue av, wchar_t *value, short len);
typedef BOOL (*GetMinimumAccessibleValueFromContextFP)(long vmID, AccessibleValue av, wchar_t *value, short len);
typedef void (*AddAccessibleSelectionFromContextFP)(long vmID, AccessibleSelection as, int i);
typedef void (*ClearAccessibleSelectionFromContextFP)(long vmID, AccessibleSelection as);
typedef JOBJECT64 (*GetAccessibleSelectionFromContextFP)(long vmID, AccessibleSelection as, int i);
typedef int (*GetAccessibleSelectionCountFromContextFP)(long vmID, AccessibleSelection as);
typedef BOOL (*IsAccessibleChildSelectedFromContextFP)(long vmID, AccessibleSelection as, int i);
typedef void (*RemoveAccessibleSelectionFromContextFP)(long vmID, AccessibleSelection as, int i);
typedef void (*SelectAllAccessibleSelectionFromContextFP)(long vmID, AccessibleSelection as);
typedef BOOL (*setTextContentsFP)(const long vmID, const AccessibleContext ac, const wchar_t *text);
typedef AccessibleContext (*getParentWithRoleFP)(const long vmID, const AccessibleContext ac, const wchar_t *role);
typedef AccessibleContext (*getParentWithRoleElseRootFP)(const long vmID, const AccessibleContext ac, const wchar_t *role);
typedef AccessibleContext (*getTopLevelObjectFP)(const long vmID, const AccessibleContext ac);
typedef int (*getObjectDepthFP)(const long vmID, const AccessibleContext ac);
typedef AccessibleContext (*getActiveDescendentFP)(const long vmID, const AccessibleContext ac);
typedef BOOL (*getVirtualAccessibleNameFP)(const long vmID, const AccessibleContext accessibleContext, wchar_t *name, int len);
typedef BOOL (*requestFocusFP)(const long vmID, const AccessibleContext accessibleContext);
typedef BOOL (*selectTextRangeFP)(const long vmID, const AccessibleContext accessibleContext, const int startIndex, const int endIndex);
typedef BOOL (*getTextAttributesInRangeFP)(const long vmID, const AccessibleContext accessibleContext, const int startIndex, const int endIndex, AccessibleTextAttributesInfo *attributes, short *len);
typedef int (*getVisibleChildrenCountFP)(const long vmID, const AccessibleContext accessibleContext);
typedef BOOL (*getVisibleChildrenFP)(const long vmID, const AccessibleContext accessibleContext, const int startIndex, VisibleChildrenInfo *children);
typedef BOOL (*setCaretPositionFP)(const long vmID, const AccessibleContext accessibleContext, const int position);
typedef BOOL (*getCaretLocationFP)(long vmID, AccessibleContext ac, AccessibleTextRectInfo *rectInfo, jint index);
typedef int (*getEventsWaitingFP)();
typedef struct AccessBridgeFPsTag
{
Windows_runFP Windows_run;
SetPropertyChangeFP SetPropertyChange;
SetJavaShutdownFP SetJavaShutdown;
SetFocusGainedFP SetFocusGained;
SetFocusLostFP SetFocusLost;
SetCaretUpdateFP SetCaretUpdate;
SetMouseClickedFP SetMouseClicked;
SetMouseEnteredFP SetMouseEntered;
SetMouseExitedFP SetMouseExited;
SetMousePressedFP SetMousePressed;
SetMouseReleasedFP SetMouseReleased;
SetMenuCanceledFP SetMenuCanceled;
SetMenuDeselectedFP SetMenuDeselected;
SetMenuSelectedFP SetMenuSelected;
SetPopupMenuCanceledFP SetPopupMenuCanceled;
SetPopupMenuWillBecomeInvisibleFP SetPopupMenuWillBecomeInvisible;
SetPopupMenuWillBecomeVisibleFP SetPopupMenuWillBecomeVisible;
SetPropertyNameChangeFP SetPropertyNameChange;
SetPropertyDescriptionChangeFP SetPropertyDescriptionChange;
SetPropertyStateChangeFP SetPropertyStateChange;
SetPropertyValueChangeFP SetPropertyValueChange;
SetPropertySelectionChangeFP SetPropertySelectionChange;
SetPropertyTextChangeFP SetPropertyTextChange;
SetPropertyCaretChangeFP SetPropertyCaretChange;
SetPropertyVisibleDataChangeFP SetPropertyVisibleDataChange;
SetPropertyChildChangeFP SetPropertyChildChange;
SetPropertyActiveDescendentChangeFP SetPropertyActiveDescendentChange;
SetPropertyTableModelChangeFP SetPropertyTableModelChange;
ReleaseJavaObjectFP ReleaseJavaObject;
GetVersionInfoFP GetVersionInfo;
IsJavaWindowFP IsJavaWindow;
IsSameObjectFP IsSameObject;
GetAccessibleContextFromHWNDFP GetAccessibleContextFromHWND;
getHWNDFromAccessibleContextFP getHWNDFromAccessibleContext;
GetAccessibleContextAtFP GetAccessibleContextAt;
GetAccessibleContextWithFocusFP GetAccessibleContextWithFocus;
GetAccessibleContextInfoFP GetAccessibleContextInfo;
GetAccessibleChildFromContextFP GetAccessibleChildFromContext;
GetAccessibleParentFromContextFP GetAccessibleParentFromContext;
getAccessibleTableInfoFP getAccessibleTableInfo;
getAccessibleTableCellInfoFP getAccessibleTableCellInfo;
getAccessibleTableRowHeaderFP getAccessibleTableRowHeader;
getAccessibleTableColumnHeaderFP getAccessibleTableColumnHeader;
getAccessibleTableRowDescriptionFP getAccessibleTableRowDescription;
getAccessibleTableColumnDescriptionFP getAccessibleTableColumnDescription;
getAccessibleTableRowSelectionCountFP getAccessibleTableRowSelectionCount;
isAccessibleTableRowSelectedFP isAccessibleTableRowSelected;
getAccessibleTableRowSelectionsFP getAccessibleTableRowSelections;
getAccessibleTableColumnSelectionCountFP getAccessibleTableColumnSelectionCount;
isAccessibleTableColumnSelectedFP isAccessibleTableColumnSelected;
getAccessibleTableColumnSelectionsFP getAccessibleTableColumnSelections;
getAccessibleTableRowFP getAccessibleTableRow;
getAccessibleTableColumnFP getAccessibleTableColumn;
getAccessibleTableIndexFP getAccessibleTableIndex;
getAccessibleRelationSetFP getAccessibleRelationSet;
getAccessibleHypertextFP getAccessibleHypertext;
activateAccessibleHyperlinkFP activateAccessibleHyperlink;
getAccessibleHyperlinkCountFP getAccessibleHyperlinkCount;
getAccessibleHypertextExtFP getAccessibleHypertextExt;
getAccessibleHypertextLinkIndexFP getAccessibleHypertextLinkIndex;
getAccessibleHyperlinkFP getAccessibleHyperlink;
getAccessibleKeyBindingsFP getAccessibleKeyBindings;
getAccessibleIconsFP getAccessibleIcons;
getAccessibleActionsFP getAccessibleActions;
doAccessibleActionsFP doAccessibleActions;
GetAccessibleTextInfoFP GetAccessibleTextInfo;
GetAccessibleTextItemsFP GetAccessibleTextItems;
GetAccessibleTextSelectionInfoFP GetAccessibleTextSelectionInfo;
GetAccessibleTextAttributesFP GetAccessibleTextAttributes;
GetAccessibleTextRectFP GetAccessibleTextRect;
GetAccessibleTextLineBoundsFP GetAccessibleTextLineBounds;
GetAccessibleTextRangeFP GetAccessibleTextRange;
GetCurrentAccessibleValueFromContextFP GetCurrentAccessibleValueFromContext;
GetMaximumAccessibleValueFromContextFP GetMaximumAccessibleValueFromContext;
GetMinimumAccessibleValueFromContextFP GetMinimumAccessibleValueFromContext;
AddAccessibleSelectionFromContextFP AddAccessibleSelectionFromContext;
ClearAccessibleSelectionFromContextFP ClearAccessibleSelectionFromContext;
GetAccessibleSelectionFromContextFP GetAccessibleSelectionFromContext;
GetAccessibleSelectionCountFromContextFP GetAccessibleSelectionCountFromContext;
IsAccessibleChildSelectedFromContextFP IsAccessibleChildSelectedFromContext;
RemoveAccessibleSelectionFromContextFP RemoveAccessibleSelectionFromContext;
SelectAllAccessibleSelectionFromContextFP SelectAllAccessibleSelectionFromContext;
setTextContentsFP setTextContents;
getParentWithRoleFP getParentWithRole;
getTopLevelObjectFP getTopLevelObject;
getParentWithRoleElseRootFP getParentWithRoleElseRoot;
getObjectDepthFP getObjectDepth;
getActiveDescendentFP getActiveDescendent;
getVirtualAccessibleNameFP getVirtualAccessibleName;
requestFocusFP requestFocus;
selectTextRangeFP selectTextRange;
getTextAttributesInRangeFP getTextAttributesInRange;
getVisibleChildrenCountFP getVisibleChildrenCount;
getVisibleChildrenFP getVisibleChildren;
setCaretPositionFP setCaretPosition;
getCaretLocationFP getCaretLocation;
getEventsWaitingFP getEventsWaiting;
} AccessBridgeFPs;
BOOL initializeAccessBridge();
BOOL shutdownAccessBridge();
BOOL IsJavaWindow(HWND window);
BOOL GetAccessibleContextFromHWND(HWND target, long *vmID, AccessibleContext *ac);
HWND getHWNDFromAccessibleContext(long vmID, AccessibleContext ac);
void SetJavaShutdown(AccessBridge_JavaShutdownFP fp);
void SetFocusGained(AccessBridge_FocusGainedFP fp);
void SetFocusLost(AccessBridge_FocusLostFP fp);
void SetCaretUpdate(AccessBridge_CaretUpdateFP fp);
void SetMouseClicked(AccessBridge_MouseClickedFP fp);
void SetMouseEntered(AccessBridge_MouseEnteredFP fp);
void SetMouseExited(AccessBridge_MouseExitedFP fp);
void SetMousePressed(AccessBridge_MousePressedFP fp);
void SetMouseReleased(AccessBridge_MouseReleasedFP fp);
void SetMenuCanceled(AccessBridge_MenuCanceledFP fp);
void SetMenuDeselected(AccessBridge_MenuDeselectedFP fp);
void SetMenuSelected(AccessBridge_MenuSelectedFP fp);
void SetPopupMenuCanceled(AccessBridge_PopupMenuCanceledFP fp);
void SetPopupMenuWillBecomeInvisible(AccessBridge_PopupMenuWillBecomeInvisibleFP fp);
void SetPopupMenuWillBecomeVisible(AccessBridge_PopupMenuWillBecomeVisibleFP fp);
void SetPropertyNameChange(AccessBridge_PropertyNameChangeFP fp);
void SetPropertyDescriptionChange(AccessBridge_PropertyDescriptionChangeFP fp);
void SetPropertyStateChange(AccessBridge_PropertyStateChangeFP fp);
void SetPropertyValueChange(AccessBridge_PropertyValueChangeFP fp);
void SetPropertySelectionChange(AccessBridge_PropertySelectionChangeFP fp);
void SetPropertyTextChange(AccessBridge_PropertyTextChangeFP fp);
void SetPropertyCaretChange(AccessBridge_PropertyCaretChangeFP fp);
void SetPropertyVisibleDataChange(AccessBridge_PropertyVisibleDataChangeFP fp);
void SetPropertyChildChange(AccessBridge_PropertyChildChangeFP fp);
void SetPropertyActiveDescendentChange(AccessBridge_PropertyActiveDescendentChangeFP fp);
void SetPropertyTableModelChange(AccessBridge_PropertyTableModelChangeFP fp);
void ReleaseJavaObject(long vmID, Java_Object object);
BOOL GetVersionInfo(long vmID, AccessBridgeVersionInfo *info);
HWND GetHWNDFromAccessibleContext(long vmID, JOBJECT64 accesibleContext);
BOOL GetAccessibleContextAt(long vmID, AccessibleContext acParent, jint x, jint y, AccessibleContext *ac);
BOOL GetAccessibleContextWithFocus(HWND window, long *vmID, AccessibleContext *ac);
BOOL GetAccessibleContextInfo(long vmID, AccessibleContext ac, AccessibleContextInfo *info);
AccessibleContext GetAccessibleChildFromContext(long vmID, AccessibleContext ac, jint index);
AccessibleContext GetAccessibleParentFromContext(long vmID, AccessibleContext ac);
BOOL GetAccessibleTextInfo(long vmID, AccessibleText at, AccessibleTextInfo *textInfo, jint x, jint y);
BOOL GetAccessibleTextItems(long vmID, AccessibleText at, AccessibleTextItemsInfo *textItems, jint index);
BOOL GetAccessibleTextSelectionInfo(long vmID, AccessibleText at, AccessibleTextSelectionInfo *textSelection);
BOOL GetAccessibleTextAttributes(long vmID, AccessibleText at, jint index, AccessibleTextAttributesInfo *attributes);
BOOL GetAccessibleTextRect(long vmID, AccessibleText at, AccessibleTextRectInfo *rectInfo, jint index);
BOOL GetAccessibleTextLineBounds(long vmID, AccessibleText at, jint index, jint *startIndex, jint *endIndex);
BOOL GetAccessibleTextRange(long vmID, AccessibleText at, jint start, jint end, wchar_t *text, short len);
BOOL getAccessibleTableInfo(long vmID, AccessibleContext acParent, AccessibleTableInfo *tableInfo);
BOOL getAccessibleTableCellInfo(long vmID, AccessibleTable accessibleTable, jint row, jint column, AccessibleTableCellInfo *tableCellInfo);
BOOL getAccessibleTableRowHeader(long vmID, AccessibleContext acParent, AccessibleTableInfo *tableInfo);
BOOL getAccessibleTableColumnHeader(long vmID, AccessibleContext acParent, AccessibleTableInfo *tableInfo);
AccessibleContext getAccessibleTableRowDescription(long vmID, AccessibleContext acParent, jint row);
AccessibleContext getAccessibleTableColumnDescription(long vmID, AccessibleContext acParent, jint column);
jint getAccessibleTableRowSelectionCount(long vmID, AccessibleTable table);
BOOL isAccessibleTableRowSelected(long vmID, AccessibleTable table, jint row);
BOOL getAccessibleTableRowSelections(long vmID, AccessibleTable table, jint count, jint *selections);
jint getAccessibleTableColumnSelectionCount(long vmID, AccessibleTable table);
BOOL isAccessibleTableColumnSelected(long vmID, AccessibleTable table, jint column);
BOOL getAccessibleTableColumnSelections(long vmID, AccessibleTable table, jint count, jint *selections);
jint getAccessibleTableRow(long vmID, AccessibleTable table, jint index);
jint getAccessibleTableColumn(long vmID, AccessibleTable table, jint index);
jint getAccessibleTableIndex(long vmID, AccessibleTable table, jint row, jint column);
BOOL getAccessibleRelationSet(long vmID, AccessibleContext accessibleContext, AccessibleRelationSetInfo *relationSetInfo);
BOOL getAccessibleHypertext(long vmID, AccessibleContext accessibleContext, AccessibleHypertextInfo *hypertextInfo);
BOOL activateAccessibleHyperlink(long vmID, AccessibleContext accessibleContext, AccessibleHyperlink accessibleHyperlink);
jint getAccessibleHyperlinkCount(long vmID, AccessibleHypertext hypertext);
BOOL getAccessibleHypertextExt(long vmID, AccessibleContext accessibleContext, jint nStartIndex, AccessibleHypertextInfo *hypertextInfo);
jint getAccessibleHypertextLinkIndex(long vmID, AccessibleHypertext hypertext, jint nIndex);
BOOL getAccessibleHyperlink(long vmID, AccessibleHypertext hypertext, jint nIndex, AccessibleHyperlinkInfo *hyperlinkInfo);
BOOL getAccessibleKeyBindings(long vmID, AccessibleContext accessibleContext, AccessibleKeyBindings *keyBindings);
BOOL getAccessibleIcons(long vmID, AccessibleContext accessibleContext, AccessibleIcons *icons);
BOOL getAccessibleActions(long vmID, AccessibleContext accessibleContext, AccessibleActions *actions);
BOOL doAccessibleActions(long vmID, AccessibleContext accessibleContext, AccessibleActionsToDo *actionsToDo, jint *failure);
BOOL IsSameObject(long vmID, JOBJECT64 obj1, JOBJECT64 obj2);
BOOL setTextContents(long vmID, AccessibleContext accessibleContext, const wchar_t *text);
AccessibleContext getParentWithRole(long vmID, AccessibleContext accessibleContext, const wchar_t *role);
AccessibleContext getParentWithRoleElseRoot(long vmID, AccessibleContext accessibleContext, const wchar_t *role);
AccessibleContext getTopLevelObject(long vmID, AccessibleContext accessibleContext);
int getObjectDepth(long vmID, AccessibleContext accessibleContext);
AccessibleContext getActiveDescendent(long vmID, AccessibleContext accessibleContext);
BOOL GetCurrentAccessibleValueFromContext(long vmID, AccessibleValue av, wchar_t *value, short len);
BOOL GetMaximumAccessibleValueFromContext(long vmID, AccessibleValue av, wchar_t *value, short len);
BOOL GetMinimumAccessibleValueFromContext(long vmID, AccessibleValue av, wchar_t *value, short len);
void AddAccessibleSelectionFromContext(long vmID, AccessibleSelection as, int i);
void ClearAccessibleSelectionFromContext(long vmID, AccessibleSelection as);
JOBJECT64 GetAccessibleSelectionFromContext(long vmID, AccessibleSelection as, int i);
int GetAccessibleSelectionCountFromContext(long vmID, AccessibleSelection as);
BOOL IsAccessibleChildSelectedFromContext(long vmID, AccessibleSelection as, int i);
void RemoveAccessibleSelectionFromContext(long vmID, AccessibleSelection as, int i);
void SelectAllAccessibleSelectionFromContext(long vmID, AccessibleSelection as);
BOOL getVirtualAccessibleName(long vmID, AccessibleContext accessibleContext, wchar_t *name, int len);
BOOL requestFocus(long vmID, AccessibleContext accessibleContext);
BOOL selectTextRange(long vmID, AccessibleContext accessibleContext, int startIndex, int endIndex);
BOOL getTextAttributesInRange(long vmID, AccessibleContext accessibleContext, int startIndex, int endIndex, AccessibleTextAttributesInfo *attributes, short *len);
int getVisibleChildrenCount(long vmID, AccessibleContext accessibleContext);
BOOL getVisibleChildren(long vmID, AccessibleContext accessibleContext, int startIndex, VisibleChildrenInfo *visibleChildrenInfo);
BOOL setCaretPosition(long vmID, AccessibleContext accessibleContext, int position);
BOOL getCaretLocation(long vmID, AccessibleContext ac, AccessibleTextRectInfo *rectInfo, jint index);
int getEventsWaiting();
#ifdef __cplusplus
}
#endif
#endif
#endif
@robloxarchiver
Copy link
Author

1/5/2025 - Added a slightly minified version

@robloxarchiver
Copy link
Author

1/5/2025 - Fixed quick but I accidentally made when reviewing some stuff

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment