Results 1 to 8 of 8

Thread: JVM for Simba

  1. #1
    Join Date
    Feb 2011
    Location
    The Future.
    Posts
    5,600
    Mentioned
    396 Post(s)
    Quoted
    1598 Post(s)

    Default JVM for Simba

    I ported/wrapped most (if not all.. maybe I missed a few) of the JNI API for Simba: SimbaVM.zip.. This allows you to create full fledged Java applications directly in Simba. You can run jars or do w/e you want..

    Example:

    Simba Code:
    {$loadlib SimbaVM}

    var
      JVM: JavaVM;
      jvm_args: TStringArray;

      cls: jclass;
      mid: jmethodID;
      strcls: jclass;
      main_args: jobjectArray;
    begin
      jvm_args := ['-Djava.compiler=NONE', '-Djava.class.path=C:/Users/Brandon/Desktop/Eos.jar'];
      JVM.Init(2, @jvm_args[0]);

      cls := JVM.FindClass('eos/Bootloader');
      mid := JVM.GetStaticMethodID(cls, 'main', '([Ljava/lang/String;)V');

      strcls := JVM.FindClass('java/lang/String');
      main_args := JVM.NewObjectArray(0, strcls, nil);
      JVM.CallStaticVoidMethod(cls, mid, @main_args);

      JVM.Free();
    end.


    And that runs my loader:





    You can also create JFrames and do anything that you can do in Java (including compile Java code with Simba):

    Simba Code:
    jframe := JVM.FindClass('javax/swing/JFrame');
    strcls = JVM.FindClass('java/lang/String');

    frametitle := JVM.NewStringUTF('hello frame');
    frameconstructor := JVM.GetMethodID(jframe, '<init>', '(Ljava/lang/String;)V');
    localobj := JVM.NewObject(jframe, frameconstructor, frametitle);


    You can use Java libraries directly, run updaters, etc..


    Source is only three files so I didn't bother zipping the project.. Enjoy..


    Exports.hxx:
    C++ Code:
    #ifndef EXPORTS_HXX_INCLUDED
    #define EXPORTS_HXX_INCLUDED

    #if defined _WIN32 || defined _WIN64
    #define EXPORT_FUNC __declspec(dllexport)
    #else
    #define EXPORT_FUNC
    #define __stdcall
    #endif


    #include <cstdint>
    #include <jni.h>


    extern const char* PascalTypes[];
    extern const char* PascalFunctions[];

    extern const int ABI_VERSION;
    extern const int PascalTypeCount;
    extern const int PascalFunctionCount;

    int32_t pascal_length(void* arr);
    void* allocate_memory(int32_t size, int32_t element_size, void* (*SimbaAllocator)(int size));





    typedef struct
    {
        JNIEnv* env;
        JavaVM* vm;
    } Jvm;


    #if defined __cplusplus
    extern "C"
    {
    #endif // defined

    EXPORT_FUNC void setMemoryAllocator(void* (*mallocator)(int size));

    EXPORT_FUNC bool JavaVM_Init(Jvm* &ptr);
    EXPORT_FUNC bool JavaVM_InitEx(Jvm* &ptr, int argc, const char* argv[]);
    EXPORT_FUNC void JavaVM_Free(Jvm* &ptr);



    EXPORT_FUNC jint JavaVM_GetVersion(Jvm* &ptr);
    EXPORT_FUNC jclass JavaVM_DefineClass(Jvm* &ptr, const char *name, jobject loader, const jbyte *buf, jsize len);
    EXPORT_FUNC jclass JavaVM_FindClass(Jvm* &ptr, const char *name);
    EXPORT_FUNC jmethodID JavaVM_FromReflectedMethod(Jvm* &ptr, jobject method);
    EXPORT_FUNC jfieldID JavaVM_FromReflectedField(Jvm* &ptr, jobject field);
    EXPORT_FUNC jobject JavaVM_ToReflectedMethod(Jvm* &ptr, jclass cls, jmethodID methodID, jboolean isStatic);
    EXPORT_FUNC jclass JavaVM_GetSuperclass(Jvm* &ptr, jclass sub);
    EXPORT_FUNC jboolean JavaVM_IsAssignableFrom(Jvm* &ptr, jclass sub, jclass sup);
    EXPORT_FUNC jobject JavaVM_ToReflectedField(Jvm* &ptr, jclass cls, jfieldID fieldID, jboolean isStatic);
    EXPORT_FUNC jint JavaVM_Throw(Jvm* &ptr, jthrowable obj);
    EXPORT_FUNC jint JavaVM_ThrowNew(Jvm* &ptr, jclass clazz, const char *msg);
    EXPORT_FUNC jthrowable JavaVM_ExceptionOccurred(Jvm* &ptr);
    EXPORT_FUNC void JavaVM_ExceptionDescribe(Jvm* &ptr);
    EXPORT_FUNC void JavaVM_ExceptionClear(Jvm* &ptr);
    EXPORT_FUNC void JavaVM_FatalError(Jvm* &ptr, const char *msg);
    EXPORT_FUNC jint JavaVM_PushLocalFrame(Jvm* &ptr, jint capacity);
    EXPORT_FUNC jobject JavaVM_PopLocalFrame(Jvm* &ptr, jobject result);
    EXPORT_FUNC jobject JavaVM_NewGlobalRef(Jvm* &ptr, jobject lobj);
    EXPORT_FUNC void JavaVM_DeleteGlobalRef(Jvm* &ptr, jobject gref);
    EXPORT_FUNC void JavaVM_DeleteLocalRef(Jvm* &ptr, jobject obj);
    EXPORT_FUNC jboolean JavaVM_IsSameObject(Jvm* &ptr, jobject obj1, jobject obj2);
    EXPORT_FUNC jobject JavaVM_NewLocalRef(Jvm* &ptr, jobject ref);
    EXPORT_FUNC jint JavaVM_EnsureLocalCapacity(Jvm* &ptr, jint capacity);
    EXPORT_FUNC jobject JavaVM_AllocObject(Jvm* &ptr, jclass clazz);
    EXPORT_FUNC jobject JavaVM_NewObjectA(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jclass JavaVM_GetObjectClass(Jvm* &ptr, jobject obj);
    EXPORT_FUNC jboolean JavaVM_IsInstanceOf(Jvm* &ptr, jobject obj, jclass clazz);
    EXPORT_FUNC jmethodID JavaVM_GetMethodID(Jvm* &ptr, jclass clazz, const char *name, const char *sig);
    EXPORT_FUNC jobject JavaVM_CallObjectMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jboolean JavaVM_CallBooleanMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jbyte JavaVM_CallByteMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jchar JavaVM_CallCharMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jshort JavaVM_CallShortMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jint JavaVM_CallIntMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jlong JavaVM_CallLongMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jfloat JavaVM_CallFloatMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jdouble JavaVM_CallDoubleMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC void JavaVM_CallVoidMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jobject JavaVM_CallNonvirtualObjectMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jboolean JavaVM_CallNonvirtualBooleanMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jbyte JavaVM_CallNonvirtualByteMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jchar JavaVM_CallNonvirtualCharMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jshort JavaVM_CallNonvirtualShortMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jint JavaVM_CallNonvirtualIntMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jlong JavaVM_CallNonvirtualLongMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jfloat JavaVM_CallNonvirtualFloatMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jdouble JavaVM_CallNonvirtualDoubleMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC void JavaVM_CallNonvirtualVoidMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jfieldID JavaVM_GetFieldID(Jvm* &ptr, jclass clazz, const char *name, const char *sig);
    EXPORT_FUNC jobject JavaVM_GetObjectField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jboolean JavaVM_GetBooleanField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jbyte JavaVM_GetByteField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jchar JavaVM_GetCharField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jshort JavaVM_GetShortField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jint JavaVM_GetIntField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jlong JavaVM_GetLongField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jfloat JavaVM_GetFloatField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC jdouble JavaVM_GetDoubleField(Jvm* &ptr, jobject obj, jfieldID fieldID);
    EXPORT_FUNC void JavaVM_SetObjectField(Jvm* &ptr, jobject obj, jfieldID fieldID, jobject val);
    EXPORT_FUNC void JavaVM_SetBooleanField(Jvm* &ptr, jobject obj, jfieldID fieldID, jboolean val);
    EXPORT_FUNC void JavaVM_SetByteField(Jvm* &ptr, jobject obj, jfieldID fieldID, jbyte val);
    EXPORT_FUNC void JavaVM_SetCharField(Jvm* &ptr, jobject obj, jfieldID fieldID, jchar val);
    EXPORT_FUNC void JavaVM_SetShortField(Jvm* &ptr, jobject obj, jfieldID fieldID, jshort val);
    EXPORT_FUNC void JavaVM_SetIntField(Jvm* &ptr, jobject obj, jfieldID fieldID, jint val);
    EXPORT_FUNC void JavaVM_SetLongField(Jvm* &ptr, jobject obj, jfieldID fieldID, jlong val);
    EXPORT_FUNC void JavaVM_SetFloatField(Jvm* &ptr, jobject obj, jfieldID fieldID, jfloat val);
    EXPORT_FUNC void JavaVM_SetDoubleField(Jvm* &ptr, jobject obj, jfieldID fieldID, jdouble val);
    EXPORT_FUNC jmethodID JavaVM_GetStaticMethodID(Jvm* &ptr, jclass clazz, const char *name, const char *sig);
    EXPORT_FUNC jobject JavaVM_CallStaticObjectMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jboolean JavaVM_CallStaticBooleanMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jbyte JavaVM_CallStaticByteMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jchar JavaVM_CallStaticCharMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jshort JavaVM_CallStaticShortMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jint JavaVM_CallStaticIntMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jlong JavaVM_CallStaticLongMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jfloat JavaVM_CallStaticFloatMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jdouble JavaVM_CallStaticDoubleMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC void JavaVM_CallStaticVoidMethod(Jvm* &ptr, jclass cls, jmethodID methodID, const jvalue *args);
    EXPORT_FUNC jfieldID JavaVM_GetStaticFieldID(Jvm* &ptr, jclass clazz, const char *name, const char *sig);
    EXPORT_FUNC jobject JavaVM_GetStaticObjectField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jboolean JavaVM_GetStaticBooleanField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jbyte JavaVM_GetStaticByteField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jchar JavaVM_GetStaticCharField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jshort JavaVM_GetStaticShortField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jint JavaVM_GetStaticIntField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jlong JavaVM_GetStaticLongField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jfloat JavaVM_GetStaticFloatField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC jdouble JavaVM_GetStaticDoubleField(Jvm* &ptr, jclass clazz, jfieldID fieldID);
    EXPORT_FUNC void JavaVM_SetStaticObjectField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jobject value);
    EXPORT_FUNC void JavaVM_SetStaticBooleanField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jboolean value);
    EXPORT_FUNC void JavaVM_SetStaticByteField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jbyte value);
    EXPORT_FUNC void JavaVM_SetStaticCharField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jchar value);
    EXPORT_FUNC void JavaVM_SetStaticShortField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jshort value);
    EXPORT_FUNC void JavaVM_SetStaticIntField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jint value);
    EXPORT_FUNC void JavaVM_SetStaticLongField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jlong value);
    EXPORT_FUNC void JavaVM_SetStaticFloatField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jfloat value);
    EXPORT_FUNC void JavaVM_SetStaticDoubleField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jdouble value);
    EXPORT_FUNC jstring JavaVM_NewString(Jvm* &ptr, const jchar *unicode, jsize len);
    EXPORT_FUNC jsize JavaVM_GetStringLength(Jvm* &ptr, jstring str);
    EXPORT_FUNC const jchar *JavaVM_GetStringChars(Jvm* &ptr, jstring str, jboolean *isCopy);
    EXPORT_FUNC void JavaVM_ReleaseStringChars(Jvm* &ptr, jstring str, const jchar *chars);
    EXPORT_FUNC jstring JavaVM_NewStringUTF(Jvm* &ptr, const char *utf);
    EXPORT_FUNC jsize JavaVM_GetStringUTFLength(Jvm* &ptr, jstring str);
    EXPORT_FUNC const char* JavaVM_GetStringUTFChars(Jvm* &ptr, jstring str, jboolean *isCopy);
    EXPORT_FUNC void JavaVM_ReleaseStringUTFChars(Jvm* &ptr, jstring str, const char* chars);
    EXPORT_FUNC jsize JavaVM_GetArrayLength(Jvm* &ptr, jarray array);
    EXPORT_FUNC jobjectArray JavaVM_NewObjectArray(Jvm* &ptr, jsize len, jclass clazz, jobject init);
    EXPORT_FUNC jobject JavaVM_GetObjectArrayElement(Jvm* &ptr, jobjectArray array, jsize index);
    EXPORT_FUNC void JavaVM_SetObjectArrayElement(Jvm* &ptr, jobjectArray array, jsize index, jobject val);
    EXPORT_FUNC jbooleanArray JavaVM_NewBooleanArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jbyteArray JavaVM_NewByteArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jcharArray JavaVM_NewCharArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jshortArray JavaVM_NewShortArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jintArray JavaVM_NewIntArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jlongArray JavaVM_NewLongArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jfloatArray JavaVM_NewFloatArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jdoubleArray JavaVM_NewDoubleArray(Jvm* &ptr, jsize len);
    EXPORT_FUNC jboolean* JavaVM_GetBooleanArrayElements(Jvm* &ptr, jbooleanArray array, jboolean *isCopy);
    EXPORT_FUNC jbyte* JavaVM_GetByteArrayElements(Jvm* &ptr, jbyteArray array, jboolean *isCopy);
    EXPORT_FUNC jchar* JavaVM_GetCharArrayElements(Jvm* &ptr, jcharArray array, jboolean *isCopy);
    EXPORT_FUNC jshort* JavaVM_GetShortArrayElements(Jvm* &ptr, jshortArray array, jboolean *isCopy);
    EXPORT_FUNC jint* JavaVM_GetIntArrayElements(Jvm* &ptr, jintArray array, jboolean *isCopy);
    EXPORT_FUNC jlong* JavaVM_GetLongArrayElements(Jvm* &ptr, jlongArray array, jboolean *isCopy);
    EXPORT_FUNC jfloat* JavaVM_GetFloatArrayElements(Jvm* &ptr, jfloatArray array, jboolean *isCopy);
    EXPORT_FUNC jdouble* JavaVM_GetDoubleArrayElements(Jvm* &ptr, jdoubleArray array, jboolean *isCopy);
    EXPORT_FUNC void JavaVM_ReleaseBooleanArrayElements(Jvm* &ptr, jbooleanArray array, jboolean *elems, jint mode);
    EXPORT_FUNC void JavaVM_ReleaseByteArrayElements(Jvm* &ptr, jbyteArray array, jbyte *elems, jint mode);
    EXPORT_FUNC void JavaVM_ReleaseCharArrayElements(Jvm* &ptr, jcharArray array, jchar *elems, jint mode);
    EXPORT_FUNC void JavaVM_ReleaseShortArrayElements(Jvm* &ptr, jshortArray array, jshort *elems, jint mode);
    EXPORT_FUNC void JavaVM_ReleaseIntArrayElements(Jvm* &ptr, jintArray array, jint *elems, jint mode);
    EXPORT_FUNC void JavaVM_ReleaseLongArrayElements(Jvm* &ptr, jlongArray array, jlong *elems, jint mode);
    EXPORT_FUNC void JavaVM_ReleaseFloatArrayElements(Jvm* &ptr, jfloatArray array, jfloat *elems, jint mode);
    EXPORT_FUNC void JavaVM_ReleaseDoubleArrayElements(Jvm* &ptr, jdoubleArray array, jdouble *elems, jint mode);
    EXPORT_FUNC void JavaVM_GetBooleanArrayRegion(Jvm* &ptr, jbooleanArray array, jsize start, jsize len, jboolean *buf);
    EXPORT_FUNC void JavaVM_GetByteArrayRegion(Jvm* &ptr, jbyteArray array, jsize start, jsize len, jbyte *buf);
    EXPORT_FUNC void JavaVM_GetCharArrayRegion(Jvm* &ptr, jcharArray array, jsize start, jsize len, jchar *buf);
    EXPORT_FUNC void JavaVM_GetShortArrayRegion(Jvm* &ptr, jshortArray array, jsize start, jsize len, jshort *buf);
    EXPORT_FUNC void JavaVM_GetIntArrayRegion(Jvm* &ptr, jintArray array, jsize start, jsize len, jint *buf);
    EXPORT_FUNC void JavaVM_GetLongArrayRegion(Jvm* &ptr, jlongArray array, jsize start, jsize len, jlong *buf);
    EXPORT_FUNC void JavaVM_GetFloatArrayRegion(Jvm* &ptr, jfloatArray array, jsize start, jsize len, jfloat *buf);
    EXPORT_FUNC void JavaVM_GetDoubleArrayRegion(Jvm* &ptr, jdoubleArray array, jsize start, jsize len, jdouble *buf);
    EXPORT_FUNC void JavaVM_SetBooleanArrayRegion(Jvm* &ptr, jbooleanArray array, jsize start, jsize len, const jboolean *buf);
    EXPORT_FUNC void JavaVM_SetByteArrayRegion(Jvm* &ptr, jbyteArray array, jsize start, jsize len, const jbyte *buf);
    EXPORT_FUNC void JavaVM_SetCharArrayRegion(Jvm* &ptr, jcharArray array, jsize start, jsize len, const jchar *buf);
    EXPORT_FUNC void JavaVM_SetShortArrayRegion(Jvm* &ptr, jshortArray array, jsize start, jsize len, const jshort *buf);
    EXPORT_FUNC void JavaVM_SetIntArrayRegion(Jvm* &ptr, jintArray array, jsize start, jsize len, const jint *buf);
    EXPORT_FUNC void JavaVM_SetLongArrayRegion(Jvm* &ptr, jlongArray array, jsize start, jsize len, const jlong *buf);
    EXPORT_FUNC void JavaVM_SetFloatArrayRegion(Jvm* &ptr, jfloatArray array, jsize start, jsize len, const jfloat *buf);
    EXPORT_FUNC void JavaVM_SetDoubleArrayRegion(Jvm* &ptr, jdoubleArray array, jsize start, jsize len, const jdouble *buf);
    EXPORT_FUNC jint JavaVM_RegisterNatives(Jvm* &ptr, jclass clazz, const JNINativeMethod *methods, jint nMethods);
    EXPORT_FUNC jint JavaVM_UnregisterNatives(Jvm* &ptr, jclass clazz);
    EXPORT_FUNC jint JavaVM_MonitorEnter(Jvm* &ptr, jobject obj);
    EXPORT_FUNC jint JavaVM_MonitorExit(Jvm* &ptr, jobject obj);
    EXPORT_FUNC jint JavaVM_GetJavaVM(Jvm* &ptr, JavaVM **vm);
    EXPORT_FUNC void JavaVM_GetStringRegion(Jvm* &ptr, jstring str, jsize start, jsize len, jchar *buf);
    EXPORT_FUNC void JavaVM_GetStringUTFRegion(Jvm* &ptr, jstring str, jsize start, jsize len, char *buf);
    EXPORT_FUNC void* JavaVM_GetPrimitiveArrayCritical(Jvm* &ptr, jarray array, jboolean *isCopy);
    EXPORT_FUNC void JavaVM_ReleasePrimitiveArrayCritical(Jvm* &ptr, jarray array, void *carray, jint mode);
    EXPORT_FUNC const jchar* JavaVM_GetStringCritical(Jvm* &ptr, jstring string, jboolean *isCopy);
    EXPORT_FUNC void JavaVM_ReleaseStringCritical(Jvm* &ptr, jstring string, const jchar *cstring);
    EXPORT_FUNC jweak JavaVM_NewWeakGlobalRef(Jvm* &ptr, jobject obj);
    EXPORT_FUNC void JavaVM_DeleteWeakGlobalRef(Jvm* &ptr, jweak ref);
    EXPORT_FUNC jboolean JavaVM_ExceptionCheck(Jvm* &ptr);
    EXPORT_FUNC jobject JavaVM_NewDirectByteBuffer(Jvm* &ptr, void* address, jlong capacity);
    EXPORT_FUNC void* JavaVM_GetDirectBufferAddress(Jvm* &ptr, jobject buf);
    EXPORT_FUNC jlong JavaVM_GetDirectBufferCapacity(Jvm* &ptr, jobject buf);
    EXPORT_FUNC jobjectRefType JavaVM_GetObjectRefType(Jvm* &ptr, jobject obj);

    #if defined __cplusplus
    }
    #endif

    #endif // EXPORTS_HXX_INCLUDED


    Exports.cxx:
    C++ Code:
    #include "Exports.hxx"

    const char* PascalTypes[] =
    {
        "jint", "Int32",
        "jlong", "Int64",
        "jbyte", "char",
        "jboolean", "ByteBool",
        "jchar", "Word",
        "jshort", "SmallInt",
        "jfloat", "Single",
        "jdouble", "Double",
        "jsize", "jint",

        "jobject", "Pointer",
        "jclass", "jobject",
        "jthrowable", "jobject",
        "jstring", "jobject",
        "jarray", "jobject",

        "jbooleanArray", "jarray",
        "jbyteArray", "jarray",
        "jcharArray", "jarray",
        "jshortArray", "jarray",
        "jintArray", "jarray",
        "jlongArray", "jarray",
        "jfloatArray", "jarray",
        "jdoubleArray", "jarray",
        "jobjectArray", "jarray",

        "jweak", "jobject",
        "jfieldID", "Pointer",
        "jmethodID", "Pointer",

        "jvalue", "union z: jboolean; b: jbyte; c: jchar; s: jshort; i: jint; j: jlong; f: jfloat; d: jdouble; l: jobject; end",
        "jobjectRefType", "(JNIInvalidRefType = 0, JNILocalRefType = 1, JNIGlobalRefType = 2, JNIWeakGlobalRefType = 3)",
        "JNINativeMethod", "record name: ^char; signature: ^char; fnPtr: Pointer; end",


        "JavaVM", "type TObject"
    };

    const char* PascalFunctions[] =
    {
        "setMemoryAllocator", "Procedure setMemoryAllocator(mallocator: Function(size: Integer): Pointer);",


        "JavaVM_Init", "Function JavaVM.Init(): Boolean;",
        "JavaVM_InitEx", "Function JavaVM.Init(argc: integer; args: ^string): Boolean; overload;",
        "JavaVM_Free", "Procedure JavaVM.Free();",

        "JavaVM_GetVersion", "Function JavaVM.GetVersion(): jint;",
        "JavaVM_DefineClass", "Function JavaVM.DefineClass(const name: string; loader: jobject; const buf: ^jbyte; len: jsize): jclass;",
        "JavaVM_FindClass", "Function JavaVM.FindClass(const name: string): jclass;",
        "JavaVM_FromReflectedMethod", "Function JavaVM.FromReflectedMethod(method: jobject): jmethodID;",
        "JavaVM_FromReflectedField", "Function JavaVM.FromReflectedField(field: jobject): jfieldID;",
        "JavaVM_ToReflectedMethod", "Function JavaVM.ToReflectedMethod(cls: jclass; methodID: jmethodID; isStatic: jboolean): jobject;",
        "JavaVM_GetSuperclass", "Function JavaVM.GetSuperclass(sub: jclass): jclass;",
        "JavaVM_IsAssignableFrom", "Function JavaVM.IsAssignableFrom(sub, sup: jclass): jboolean;",
        "JavaVM_ToReflectedField", "Function JavaVM.ToReflectedField(cls: jclass; fieldID: jfieldID; isStatic: jboolean): jobject;",
        "JavaVM_Throw", "Function JavaVM.Throw(obj: jthrowable): jint;",
        "JavaVM_ThrowNew", "Function JavaVM.ThrowNew(clazz: jclass; const msg: string): jint;",
        "JavaVM_ExceptionOccurred", "Function JavaVM.ExceptionOccurred(): jthrowable;",
        "JavaVM_ExceptionDescribe", "Procedure JavaVM.ExceptionDescribe();",
        "JavaVM_ExceptionClear", "Procedure JavaVM.ExceptionClear();",
        "JavaVM_FatalError", "Procedure JavaVM.FatalError(const msg: string);",
        "JavaVM_PushLocalFrame", "Function JavaVM.PushLocalFrame(capacity: jint): jint;",
        "JavaVM_PopLocalFrame", "Function JavaVM.PopLocalFrame(res: jobject): jobject;",
        "JavaVM_NewGlobalRef", "Function JavaVM.NewGlobalRef(lobj: jobject): jobject;",
        "JavaVM_DeleteGlobalRef", "Procedure JavaVM.DeleteGlobalRef(gref: jobject);",
        "JavaVM_DeleteLocalRef", "Procedure JavaVM.DeleteLocalRef(obj: jobject);",
        "JavaVM_IsSameObject", "Function JavaVM.IsSameObject(obj1, obj2: jobject): jboolean;",
        "JavaVM_NewLocalRef", "Function JavaVM.NewLocalRef(ref: jobject): jobject;",
        "JavaVM_EnsureLocalCapacity", "Function JavaVM.EnsureLocalCapacity(capacity: jint): jint;",
        "JavaVM_AllocObject", "Function JavaVM.AllocObject(clazz: jobject): jobject;",
        "JavaVM_NewObject", "Function JavaVM.NewObject(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jobject;",
        "JavaVM_GetObjectClass", "Function JavaVM.GetObjectClass(obj: jobject): jclass;",
        "JavaVM_IsInstanceOf", "Function JavaVM.IsInstanceOf(obj: jobject; clazz: jclass): jboolean;",
        "JavaVM_GetMethodID", "Function JavaVM.GetMethodID(clazz: jclass; const name: string; const sig: string): jmethodID;",
        "JavaVM_CallObjectMethod", "Function JavaVM.CallObjectMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jobject;",
        "JavaVM_CallBooleanMethod", "Function JavaVM.CallBooleanMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jboolean;",
        "JavaVM_CallByteMethod", "Function JavaVM.CallByteMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jbyte;",
        "JavaVM_CallCharMethod", "Function JavaVM.CallCharMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jchar;",
        "JavaVM_CallShortMethod", "Function JavaVM.CallShortMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jshort;",
        "JavaVM_CallIntMethod", "Function JavaVM.CallIntMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jint;",
        "JavaVM_CallLongMethod", "Function JavaVM.CallLongMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jlong;",
        "JavaVM_CallFloatMethod", "Function JavaVM.CallFloatMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jfloat;",
        "JavaVM_CallDoubleMethod", "Function JavaVM.CallDoubleMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue): jdouble;",
        "JavaVM_CallVoidMethod", "Procedure JavaVM.CallVoidMethod(obj: jobject; methodID: jmethodID; const args: ^jvalue);",
        "JavaVM_CallNonvirtualObjectMethod", "Function JavaVM.CallNonvirtualObjectMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jobject;",
        "JavaVM_CallNonvirtualBooleanMethod", "Function JavaVM.CallNonvirtualBooleanMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jboolean;",
        "JavaVM_CallNonvirtualByteMethod", "Function JavaVM.CallNonvirtualByteMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jbyte;",
        "JavaVM_CallNonvirtualCharMethod", "Function JavaVM.CallNonvirtualCharMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jchar;",
        "JavaVM_CallNonvirtualShortMethod", "Function JavaVM.CallNonvirtualShortMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jshort;",
        "JavaVM_CallNonvirtualIntMethod", "Function JavaVM.CallNonvirtualIntMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jint;",
        "JavaVM_CallNonvirtualLongMethod", "Function JavaVM.CallNonvirtualLongMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jlong;",
        "JavaVM_CallNonvirtualFloatMethod", "Function JavaVM.CallNonvirtualFloatMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jfloat;",
        "JavaVM_CallNonvirtualDoubleMethod", "Function JavaVM.CallNonvirtualDoubleMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue): jdouble;",
        "JavaVM_CallNonvirtualVoidMethod", "Procedure JavaVM.CallNonvirtualVoidMethod(obj: jobject; clazz: jclass; methodID: jmethodID; const args: ^jvalue);",
        "JavaVM_GetFieldID", "Function JavaVM.GetFieldID(clazz: jclass; const name: string; const sign: string): jfieldID;",
        "JavaVM_GetObjectField", "Function JavaVM.GetObjectField(obj: jobject; fieldID: jfieldID): jobject;",
        "JavaVM_GetBooleanField", "Function JavaVM.GetBooleanField(obj: jobject; fieldID: jfieldID): jboolean;",
        "JavaVM_GetByteField", "Function JavaVM.GetByteField(obj: jobject; fieldID: jfieldID): jbyte;",
        "JavaVM_GetCharField", "Function JavaVM.GetCharField(obj: jobject; fieldID: jfieldID): jchar;",
        "JavaVM_GetShortField", "Function JavaVM.GetShortField(obj: jobject; fieldID: jfieldID): jshort;",
        "JavaVM_GetIntField", "Function JavaVM.GetIntField(obj: jobject; fieldID: jfieldID): jint;",
        "JavaVM_GetFloatField", "Function JavaVM.GetFloatField(obj: jobject; fieldID: jfieldID): jfloat;",
        "JavaVM_GetDoubleField", "Function JavaVM.GetDoubleField(obj: jobject; fieldID: jfieldID): jdouble;",
        "JavaVM_SetObjectField", "Procedure JavaVM.SetObjectField(obj: jobject; fieldID: jfieldID; val: jobject);",
        "JavaVM_SetBooleanField", "Procedure JavaVM.SetBooleanField(obj: jobject; fieldID: jfieldID; val: jboolean);",
        "JavaVM_SetByteField", "Procedure JavaVM.SetByteField(obj: jobject; fieldID: jfieldID; val: jbyte);",
        "JavaVM_SetCharField", "Procedure JavaVM.SetCharField(obj: jobject; fieldID: jfieldID; val: jchar);",
        "JavaVM_SetShortField", "Procedure JavaVM.SetShortField(obj: jobject; fieldID: jfieldID; val: jshort);",
        "JavaVM_SetIntField", "Procedure JavaVM.SetIntField(obj: jobject; fieldID: jfieldID; val: jint);",
        "JavaVM_SetFloatField", "Procedure JavaVM.SetFloatField(obj: jobject; fieldID: jfieldID; val: jfloat);",
        "JavaVM_SetDoubleField", "Procedure JavaVM.SetDoubleField(obj: jobject; fieldID: jfieldID; val: jdouble);",
        "JavaVM_GetStaticMethodID", "Function JavaVM.GetStaticMethodID(clazz: jclass; const name: string; const sig: string): jmethodID;",
        "JavaVM_CallStaticObjectMethod", "Function JavaVM.CallStaticObjectMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jobject;",
        "JavaVM_CallStaticBooleanMethod", "Function JavaVM.CallStaticBooleanMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jboolean;",
        "JavaVM_CallStaticByteMethod", "Function JavaVM.CallStaticByteMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jbyte;",
        "JavaVM_CallStaticCharMethod", "Function JavaVM.CallStaticCharMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jchar;",
        "JavaVM_CallStaticShortMethod", "Function JavaVM.CallStaticShortMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jshort;",
        "JavaVM_CallStaticIntMethod", "Function JavaVM.CallIntStaticMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jint;",
        "JavaVM_CallStaticLongMethod", "Function JavaVM.CallStaticLongMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jlong;",
        "JavaVM_CallStaticFloatMethod", "Function JavaVM.CallStaticFloatMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jfloat;",
        "JavaVM_CallStaticDoubleMethod", "Function JavaVM.CallStaticDoubleMethod(clazz: jclass; methodID: jmethodID; const args: ^jvalue): jdouble;",
        "JavaVM_CallStaticVoidMethod", "Procedure JavaVM.CallStaticVoidMethod(cls: jclass; methodID: jmethodID; const args: ^jvalue);",
        "JavaVM_GetStaticFieldID", "Function JavaVM.GetStaticFieldID(clazz: jclass; const name: string; const sign: string): jfieldID;",
        "JavaVM_GetStaticObjectField", "Function JavaVM.GetStaticObjectField(clazz: jclass; fieldID: jfieldID): jobject;",
        "JavaVM_GetStaticBooleanField", "Function JavaVM.GetStaticBooleanField(clazz: jclass; fieldID: jfieldID): jboolean;",
        "JavaVM_GetStaticByteField", "Function JavaVM.GetStaticByteField(clazz: jclass; fieldID: jfieldID): jbyte;",
        "JavaVM_GetStaticCharField", "Function JavaVM.GetStaticCharField(clazz: jclass; fieldID: jfieldID): jchar;",
        "JavaVM_GetStaticShortField", "Function JavaVM.GetStaticShortField(clazz: jclass; fieldID: jfieldID): jshort;",
        "JavaVM_GetStaticIntField", "Function JavaVM.GetStaticIntField(clazz: jclass; fieldID: jfieldID): jint;",
        "JavaVM_GetStaticFloatField", "Function JavaVM.GetStaticFloatField(clazz: jclass; fieldID: jfieldID): jfloat;",
        "JavaVM_GetStaticDoubleField", "Function JavaVM.GetStaticDoubleField(clazz: jclass; fieldID: jfieldID): jdouble;",
        "JavaVM_SetStaticObjectField", "Procedure JavaVM.SetStaticObjectField(clazz: jclass; fieldID: jfieldID; val: jobject);",
        "JavaVM_SetStaticBooleanField", "Procedure JavaVM.SetStaticBooleanField(clazz: jclass; fieldID: jfieldID; val: jboolean);",
        "JavaVM_SetStaticByteField", "Procedure JavaVM.SetStaticByteField(clazz: jclass; fieldID: jfieldID; val: jbyte);",
        "JavaVM_SetStaticCharField", "Procedure JavaVM.SetStaticCharField(clazz: jclass; fieldID: jfieldID; val: jchar);",
        "JavaVM_SetStaticShortField", "Procedure JavaVM.SetStaticShortField(clazz: jclass; fieldID: jfieldID; val: jshort);",
        "JavaVM_SetStaticIntField", "Procedure JavaVM.SetStaticIntField(clazz: jclass; fieldID: jfieldID; val: jint);",
        "JavaVM_SetStaticFloatField", "Procedure JavaVM.SetStaticFloatField(clazz: jclass; fieldID: jfieldID; val: jfloat);",
        "JavaVM_SetStaticDoubleField", "Procedure JavaVM.SetStaticDoubleField(clazz: jclass; fieldID: jfieldID; val: jdouble);",
        "JavaVM_NewString", "Function JavaVM.NewString(const unicode: string; len: jsize): jstring;",
        "JavaVM_GetStringLength", "Function JavaVM.GetStringLength(const str: jstring): jsize;",
        "JavaVM_GetStringChars", "Function JavaVM.GetStringChars(const str: jstring; isCopy: ^jboolean): ^jchar;",
        "JavaVM_ReleaseStringChars", "Procedure JavaVM.ReleaseStringChars(const str: jstring; const chars: ^jchar);",
        "JavaVM_NewStringUTF", "Function JavaVM.NewStringUTF(const utf: string; len: jsize): jstring;",
        "JavaVM_GetStringLength", "Function JavaVM.GetStringUTFLength(const str: jstring): jsize;",
        "JavaVM_GetStringChars", "Function JavaVM.GetStringUTFChars(const str: jstring; isCopy: ^jboolean): ^jchar;",
        "JavaVM_ReleaseStringChars", "Procedure JavaVM.ReleaseStringUTFChars(const str: jstring; const chars: ^jchar);",
        "JavaVM_GetArrayLength", "Function JavaVM.GetArrayLength(arr: jarray): jsize;",
        "JavaVM_NewObjectArray", "Function JavaVM.NewObjectArray(len: jsize; clazz: jclass; init: jobject): jobjectArray;",
        "JavaVM_GetObjectArrayElement", "Function JavaVM.GetObjectArrayElement(arr: jobjectArray; index: jsize): jobject;",
        "JavaVM_SetObjectArrayElement", "Procedure JavaVM.SetObjectArrayElement(arr: jobjectArray; index: jsize; val: jobject);",
        "JavaVM_NewBooleanArray", "Function JavaVM.NewBooleanArray(len: jsize): jbooleanArray;",
        "JavaVM_NewByteArray", "Function JavaVM.NewByteArray(len: jsize): jbyteArray;",
        "JavaVM_NewCharArray", "Function JavaVM.NewCharArray(len: jsize): jcharArray;",
        "JavaVM_NewShortArray", "Function JavaVM.NewShortArray(len: jsize): jshortArray;",
        "JavaVM_NewIntArray", "Function JavaVM.NewIntArray(len: jsize): jintArray;",
        "JavaVM_NewLongArray", "Function JavaVM.NewLongArray(len: jsize): jlongArray;",
        "JavaVM_NewFloatArray", "Function JavaVM.NewFloatArray(len: jsize): jfloatArray;",
        "JavaVM_NewDoubleArray", "Function JavaVM.NewDoubleArray(len: jsize): jdoubleArray;",
        "JavaVM_GetBooleanArrayElements", "Function JavaVM.GetBooleanArrayElements(arr: jbooleanArray; isCopy: jboolean): ^jboolean;",
        "JavaVM_GetByteArrayElements", "Function JavaVM.GetByteArrayElements(arr: jbyteArray; isCopy: jboolean): ^jbyte;",
        "JavaVM_GetCharArrayElements", "Function JavaVM.GetCharArrayElements(arr: jcharArray; isCopy: jboolean): ^jchar;",
        "JavaVM_GetShortArrayElements", "Function JavaVM.GetShortArrayElements(arr: jshortArray; isCopy: jboolean): ^jshort;",
        "JavaVM_GetIntArrayElements", "Function JavaVM.GetIntArrayElements(arr: jintArray; isCopy: jboolean): ^jint;",
        "JavaVM_GetLongArrayElements", "Function JavaVM.GetLongArrayElements(arr: jlongArray; isCopy: jboolean): ^jlong;",
        "JavaVM_GetFloatArrayElements", "Function JavaVM.GetFloatArrayElements(arr: jfloatArray; isCopy: jboolean): ^jfloat;",
        "JavaVM_GetDoubleArrayElements", "Function JavaVM.GetDoubleArrayElements(arr: jdoubleArray; isCopy: jboolean): ^jdouble;",
        "JavaVM_ReleaseBooleanArrayElements", "Procedure JavaVM.ReleaseBooleanArrayElements(arr: jbooleanArray; elems: ^jboolean; mode: jint);",
        "JavaVM_ReleaseByteArrayElements", "Procedure JavaVM.ReleaseByteArrayElements(arr: jbyteArray; elems: ^jbyte; mode: jint);",
        "JavaVM_ReleaseCharArrayElements", "Procedure JavaVM.ReleaseCharArrayElements(arr: jcharArray; elems: ^jchar; mode: jint);",
        "JavaVM_ReleaseShortArrayElements", "Procedure JavaVM.ReleaseShortArrayElements(arr: jshortArray; elems: ^jshort; mode: jint);",
        "JavaVM_ReleaseIntArrayElements", "Procedure JavaVM.ReleaseIntArrayElements(arr: jintArray; elems: ^jint; mode: jint);",
        "JavaVM_ReleaseLongArrayElements", "Procedure JavaVM.ReleaseLongArrayElements(arr: jlongArray; elems: ^jlong; mode: jint);",
        "JavaVM_ReleaseFloatArrayElements", "Procedure JavaVM.ReleaseFloatArrayElements(arr: jfloatArray; elems: ^jfloat; mode: jint);",
        "JavaVM_ReleaseDoubleArrayElements", "Procedure JavaVM.ReleaseDoubleArrayElements(arr: jdoubleArray; elems: ^jdouble; mode: jint);",
        "JavaVM_GetBooleanArrayRegion", "Procedure JavaVM.GetBooleanArrayRegion(arr: jbooleanArray; start, len: jsize; buf: ^jboolean);",
        "JavaVM_GetByteArrayRegion", "Procedure JavaVM.GetByteArrayRegion(arr: jbyteArray; start, len: jsize; buf: ^jbyte);",
        "JavaVM_GetCharArrayRegion", "Procedure JavaVM.GetCharArrayRegion(arr: jcharArray; start, len: jsize; buf: ^jchar);",
        "JavaVM_GetShortArrayRegion", "Procedure JavaVM.GetShortArrayRegion(arr: jshortArray; start, len: jsize; buf: ^jshort);",
        "JavaVM_GetIntArrayRegion", "Procedure JavaVM.GetIntArrayRegion(arr: jintArray; start, len: jsize; buf: ^jint);",
        "JavaVM_GetLongArrayRegion", "Procedure JavaVM.GetLongArrayRegion(arr: jlongArray; start, len: jsize; buf: ^jlong);",
        "JavaVM_GetFloatArrayRegion", "Procedure JavaVM.GetFloatArrayRegion(arr: jfloatArray; start, len: jsize; buf: ^jfloat);",
        "JavaVM_GetDoubleArrayRegion", "Procedure JavaVM.GetDoubleArrayRegion(arr: jdoubleArray; start, len: jsize; buf: ^jboolean);",
        "JavaVM_SetBooleanArrayRegion", "Procedure JavaVM.SetBooleanArrayRegion(arr: jbooleanArray; start, len: jsize; buf: ^jboolean);",
        "JavaVM_SetByteArrayRegion", "Procedure JavaVM.SetByteArrayRegion(arr: jbyteArray; start, len: jsize; buf: ^jbyte);",
        "JavaVM_SetCharArrayRegion", "Procedure JavaVM.SetCharArrayRegion(arr: jcharArray; start, len: jsize; buf: ^jchar);",
        "JavaVM_SetShortArrayRegion", "Procedure JavaVM.SetShortArrayRegion(arr: jshortArray; start, len: jsize; buf: ^jshort);",
        "JavaVM_SetIntArrayRegion", "Procedure JavaVM.SetIntArrayRegion(arr: jintArray; start, len: jsize; buf: ^jint);",
        "JavaVM_SetLongArrayRegion", "Procedure JavaVM.SetLongArrayRegion(arr: jlongArray; start, len: jsize; buf: ^jlong);",
        "JavaVM_SetFloatArrayRegion", "Procedure JavaVM.SetFloatArrayRegion(arr: jfloatArray; start, len: jsize; buf: ^jfloat);",
        "JavaVM_SetDoubleArrayRegion", "Procedure JavaVM.SetDoubleArrayRegion(arr: jdoubleArray; start, len: jsize; buf: ^jboolean);",
        "JavaVM_RegisterNatives", "Function JavaVM.RegisterNatives(clazz: jclass; const methods: ^JNINativeMethod; nMethods: jint): jint",
        "JavaVM_UnregisterNatives", "Function JavaVM.UnregisterNatives(clazz: jclass): jint;",
        "JavaVM_MonitorEnter", "Function JavaVM.MonitorEnter(obj: jobject): jint;",
        "JavaVM_MonitorExit", "Function JavaVM.MonitorExit(obj: jobject): jint;",

        "JavaVM_GetStringRegion", "Procedure JavaVM.GetStringRegion(const str: jstring; start, len: jsize; const buf: ^jchar);",
        "JavaVM_GetStringUTFRegion", "Procedure JavaVM.GetStringUTFRegion(const str: jstring; start, len: jsize; const buf: ^jchar);",
        "JavaVM_GetPrimitiveArrayCritical", "Function JavaVM.GetPrimitiveArrayCritical(arr: jarray; isCopy: ^jboolean): Pointer;",
        "JavaVM_ReleasePrimitiveArrayCritical", "Procedure JavaVM.ReleasePrimitiveArrayCritical(arr: jarray; const carr: Pointer; mode: jint);",
        "JavaVM_GetStringCritical", "Function JavaVM.GetStringCritical(str: jstring; isCopy: ^jboolean): ^jchar;",
        "JavaVM_ReleaseStringCritical", "Procedure JavaVM.ReleaseStringCritical(str: jstring; cstring: ^jchar);",
        "JavaVM_NewWeakGlobalRef", "Function JavaVM.NewWeakGlobalRef(obj: jobject): jweak;",
        "JavaVM_DeleteWeakGlobalRef", "Procedure JavaVM.DeleteWeakGlobalRef(ref: jweak);",

        "JavaVM_ExceptionCheck", "Function JavaVM.ExceptionCheck(): jboolean;",
        "JavaVM_NewDirectByteBuffer", "Function JavaVM.NewDirectByteBuffer(address: pointer; capacity: jlong): jobject;",
        "JavaVM_GetDirectBufferAddress", "Function JavaVM.GetDirectBufferAddress(buf: jobject): Pointer;",
        "JavaVM_GetDirectBufferCapacity", "Function JavaVM.GetDirectBufferCapacity(buf: jobject): jlong;",
        "JavaVM_GetObjectRefType", "Function JavaVM.GetObjectRefType(obj: jobject): jobjectRefType;"
    };




    const int ABI_VERSION = 2;
    const int PascalTypeCount = sizeof(PascalTypes) / (sizeof(PascalTypes[0]) * 2);
    const int PascalFunctionCount = sizeof(PascalFunctions) / (sizeof(PascalFunctions[0]) * 2);
    void* (*SimbaAllocator)(int size) = NULL;



    int32_t pascal_length(void* arr)
    {
        return (*((int32_t*)arr) - 1) + 1;
    }

    void* allocate_memory(int32_t size, int32_t element_size, void* (*SimbaAllocator)(int size))
    {
        int32_t new_size = size * element_size;
        new_size += (sizeof(int32_t) * 2);

        void* ptr = SimbaAllocator(new_size);
        *((int*)ptr) = 1; //reference count.
        ptr = ((int*)ptr) + 1;
        *((int*)ptr) = size - 1; //size.
        ptr = ((int*)ptr) + 1;
        return ptr;
    }



    void setMemoryAllocator(void* (*mallocator)(int size))
    {
        SimbaAllocator = mallocator;
    }

    bool JavaVM_Init(Jvm* &ptr)
    {
        const char* args[] = {"-Djava.compiler=NONE", "-Djava.class.path=."};
        return JavaVM_InitEx(ptr, 2, args);
    }

    bool JavaVM_InitEx(Jvm* &ptr, int argc, const char* argv[])
    {
        bool result = false;
        if (!ptr && argc > 0)
        {
            ptr = new Jvm();
            JavaVMInitArgs jvm_args;
            JavaVMOption* options = new JavaVMOption[argc];

            for (int i = 0; i < argc; ++i)
            {
                options[i].optionString = const_cast<char*>(argv[i]);
            }

            JNI_GetDefaultJavaVMInitArgs(&jvm_args);

            jvm_args.version = JNI_VERSION_1_8;
            jvm_args.nOptions = 2;
            jvm_args.options = options;
            jvm_args.ignoreUnrecognized = false;

            result = true;

            jint num_vms = 0;
            const jint max_vms = 5;
            JavaVM* vms[max_vms] = {0};
            if (JNI_GetCreatedJavaVMs(vms, max_vms, &num_vms) == JNI_OK)
            {
                for (int i = 0; i < num_vms; ++i)
                {
                    if (vms[i] != NULL)
                    {
                        ptr->vm = vms[i];
                        ptr->vm->AttachCurrentThread(reinterpret_cast<void**>(&ptr->env), NULL);
                        delete[] options;
                        return result;
                    }
                }
            }

            if (JNI_CreateJavaVM(&ptr->vm, reinterpret_cast<void**>(&ptr->env), &jvm_args) != JNI_OK)
            {
                result = false;
                ptr->vm = NULL;
                ptr->env = NULL;

                delete ptr;
                ptr = NULL;
            }
            delete[] options;
        }
        return result;
    }

    void JavaVM_Free(Jvm* &ptr)
    {
        if (ptr && ptr->vm)
        {
            ptr->vm->DetachCurrentThread();
            //ptr->vm->DestroyJavaVM();
        }

        delete ptr;
        ptr = nullptr;
    }

    jint JavaVM_GetVersion(Jvm* &ptr)
    {
        return ptr->env->GetVersion();
    }

    jclass JavaVM_DefineClass(Jvm* &ptr, const char *name, jobject loader, const jbyte *buf, jsize len)
    {
        return ptr->env->DefineClass(name, loader, buf, len);
    }

    jclass JavaVM_FindClass(Jvm* &ptr, const char *name)
    {
        return ptr->env->FindClass(name);
    }

    jmethodID JavaVM_FromReflectedMethod(Jvm* &ptr, jobject method)
    {
        return ptr->env->FromReflectedMethod(method);
    }

    jfieldID JavaVM_FromReflectedField(Jvm* &ptr, jobject field)
    {
        return ptr->env->FromReflectedField(field);
    }

    jobject JavaVM_ToReflectedMethod(Jvm* &ptr, jclass cls, jmethodID methodID, jboolean isStatic)
    {
        return ptr->env->ToReflectedMethod(cls, methodID, isStatic);
    }

    jclass JavaVM_GetSuperclass(Jvm* &ptr, jclass sub)
    {
        return ptr->env->GetSuperclass(sub);
    }
    jboolean JavaVM_IsAssignableFrom(Jvm* &ptr, jclass sub, jclass sup)
    {
        return ptr->env->IsAssignableFrom(sub, sup);
    }

    jobject JavaVM_ToReflectedField(Jvm* &ptr, jclass cls, jfieldID fieldID, jboolean isStatic)
    {
        return ptr->env->ToReflectedField(cls, fieldID, isStatic);
    }

    jint JavaVM_Throw(Jvm* &ptr, jthrowable obj)
    {
        return ptr->env->Throw(obj);
    }

    jint JavaVM_ThrowNew(Jvm* &ptr, jclass clazz, const char *msg)
    {
        return ptr->env->ThrowNew(clazz, msg);
    }

    jthrowable JavaVM_ExceptionOccurred(Jvm* &ptr)
    {
        return ptr->env->ExceptionOccurred();
    }

    void JavaVM_ExceptionDescribe(Jvm* &ptr)
    {
        ptr->env->ExceptionDescribe();
    }

    void JavaVM_ExceptionClear(Jvm* &ptr)
    {
        ptr->env->ExceptionClear();
    }

    void JavaVM_FatalError(Jvm* &ptr, const char *msg)
    {
        ptr->env->FatalError(msg);
    }

    jint JavaVM_PushLocalFrame(Jvm* &ptr, jint capacity)
    {
        return ptr->env->PushLocalFrame(capacity);
    }

    jobject JavaVM_PopLocalFrame(Jvm* &ptr, jobject result)
    {
        return ptr->env->PopLocalFrame(result);
    }

    jobject JavaVM_NewGlobalRef(Jvm* &ptr, jobject lobj)
    {
        return ptr->env->NewGlobalRef(lobj);
    }

    void JavaVM_DeleteGlobalRef(Jvm* &ptr, jobject gref)
    {
        ptr->env->DeleteGlobalRef(gref);
    }

    void JavaVM_DeleteLocalRef(Jvm* &ptr, jobject obj)
    {
        ptr->env->DeleteLocalRef(obj);
    }

    jboolean JavaVM_IsSameObject(Jvm* &ptr, jobject obj1, jobject obj2)
    {
        return ptr->env->IsSameObject(obj1, obj2);
    }

    jobject JavaVM_NewLocalRef(Jvm* &ptr, jobject ref)
    {
        return ptr->env->NewLocalRef(ref);
    }

    jint JavaVM_EnsureLocalCapacity(Jvm* &ptr, jint capacity)
    {
        return ptr->env->EnsureLocalCapacity(capacity);
    }

    jobject JavaVM_AllocObject(Jvm* &ptr, jclass clazz)
    {
        return ptr->env->AllocObject(clazz);
    }

    jobject JavaVM_NewObjectA(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->NewObjectA(clazz, methodID, args);
    }

    jclass JavaVM_GetObjectClass(Jvm* &ptr, jobject obj)
    {
        return ptr->env->GetObjectClass(obj);
    }

    jboolean JavaVM_IsInstanceOf(Jvm* &ptr, jobject obj, jclass clazz)
    {
        return ptr->env->IsInstanceOf(obj, clazz);
    }

    jmethodID JavaVM_GetMethodID(Jvm* &ptr, jclass clazz, const char *name, const char *sig)
    {
        return ptr->env->GetMethodID(clazz, name, sig);
    }

    jobject JavaVM_CallObjectMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallObjectMethodA(obj, methodID, args);
    }

    jboolean JavaVM_CallBooleanMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallBooleanMethodA(obj, methodID, args);
    }

    jbyte JavaVM_CallByteMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallByteMethodA(obj, methodID, args);
    }

    jchar JavaVM_CallCharMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallCharMethodA(obj, methodID, args);
    }

    jshort JavaVM_CallShortMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallShortMethodA(obj, methodID, args);
    }

    jint JavaVM_CallIntMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallIntMethodA(obj, methodID, args);
    }

    jlong JavaVM_CallLongMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallLongMethodA(obj, methodID, args);
    }

    jfloat JavaVM_CallFloatMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallFloatMethodA(obj, methodID, args);
    }

    jdouble JavaVM_CallDoubleMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallDoubleMethodA(obj, methodID, args);
    }

    void JavaVM_CallVoidMethod(Jvm* &ptr, jobject obj, jmethodID methodID, const jvalue *args)
    {
        ptr->env->CallVoidMethodA(obj, methodID, args);
    }

    jobject JavaVM_CallNonvirtualObjectMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualObjectMethodA(obj, clazz, methodID, args);
    }

    jboolean JavaVM_CallNonvirtualBooleanMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualBooleanMethodA(obj, clazz, methodID, args);
    }

    jbyte JavaVM_CallNonvirtualByteMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualByteMethodA(obj, clazz, methodID, args);
    }

    jchar JavaVM_CallNonvirtualCharMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualCharMethodA(obj, clazz, methodID, args);
    }

    jshort JavaVM_CallNonvirtualShortMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualShortMethodA(obj, clazz, methodID, args);
    }

    jint JavaVM_CallNonvirtualIntMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualIntMethodA(obj, clazz, methodID, args);
    }

    jlong JavaVM_CallNonvirtualLongMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualLongMethodA(obj, clazz, methodID, args);
    }

    jfloat JavaVM_CallNonvirtualFloatMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualFloatMethodA(obj, clazz, methodID, args);
    }

    jdouble JavaVM_CallNonvirtualDoubleMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallNonvirtualDoubleMethodA(obj, clazz, methodID, args);
    }

    void JavaVM_CallNonvirtualVoidMethod(Jvm* &ptr, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        ptr->env->CallNonvirtualVoidMethodA(obj, clazz, methodID, args);
    }

    jfieldID JavaVM_GetFieldID(Jvm* &ptr, jclass clazz, const char *name, const char *sig)
    {
        return ptr->env->GetFieldID(clazz, name, sig);
    }

    jobject JavaVM_GetObjectField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetObjectField(obj, fieldID);
    }

    jboolean JavaVM_GetBooleanField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetBooleanField(obj, fieldID);
    }

    jbyte JavaVM_GetByteField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetByteField(obj, fieldID);
    }

    jchar JavaVM_GetCharField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetCharField(obj, fieldID);
    }

    jshort JavaVM_GetShortField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetShortField(obj, fieldID);
    }

    jint JavaVM_GetIntField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetIntField(obj, fieldID);
    }

    jlong JavaVM_GetLongField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetLongField(obj, fieldID);
    }

    jfloat JavaVM_GetFloatField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetFloatField(obj, fieldID);
    }

    jdouble JavaVM_GetDoubleField(Jvm* &ptr, jobject obj, jfieldID fieldID)
    {
        return ptr->env->GetDoubleField(obj, fieldID);
    }

    void JavaVM_SetObjectField(Jvm* &ptr, jobject obj, jfieldID fieldID, jobject val)
    {
        ptr->env->SetObjectField(obj, fieldID, val);
    }

    void JavaVM_SetBooleanField(Jvm* &ptr, jobject obj, jfieldID fieldID, jboolean val)
    {
        ptr->env->SetBooleanField(obj, fieldID, val);
    }

    void JavaVM_SetByteField(Jvm* &ptr, jobject obj, jfieldID fieldID, jbyte val)
    {
        ptr->env->SetByteField(obj, fieldID, val);
    }

    void JavaVM_SetCharField(Jvm* &ptr, jobject obj, jfieldID fieldID, jchar val)
    {
        ptr->env->SetCharField(obj, fieldID, val);
    }

    void JavaVM_SetShortField(Jvm* &ptr, jobject obj, jfieldID fieldID, jshort val)
    {
        ptr->env->SetShortField(obj, fieldID, val);
    }

    void JavaVM_SetIntField(Jvm* &ptr, jobject obj, jfieldID fieldID, jint val)
    {
        ptr->env->SetIntField(obj, fieldID, val);
    }

    void JavaVM_SetLongField(Jvm* &ptr, jobject obj, jfieldID fieldID, jlong val)
    {
        ptr->env->SetLongField(obj, fieldID, val);
    }

    void JavaVM_SetFloatField(Jvm* &ptr, jobject obj, jfieldID fieldID, jfloat val)
    {
        ptr->env->SetFloatField(obj, fieldID, val);
    }

    void JavaVM_SetDoubleField(Jvm* &ptr, jobject obj, jfieldID fieldID, jdouble val)
    {
        ptr->env->SetDoubleField(obj, fieldID, val);
    }

    jmethodID JavaVM_GetStaticMethodID(Jvm* &ptr, jclass clazz, const char *name, const char *sig)
    {
        return ptr->env->GetStaticMethodID(clazz, name, sig);
    }

    jobject JavaVM_CallStaticObjectMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticObjectMethodA(clazz, methodID, args);
    }

    jboolean JavaVM_CallStaticBooleanMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticBooleanMethodA(clazz, methodID, args);
    }

    jbyte JavaVM_CallStaticByteMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticByteMethodA(clazz, methodID, args);
    }

    jchar JavaVM_CallStaticCharMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticCharMethodA(clazz, methodID, args);
    }

    jshort JavaVM_CallStaticShortMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticShortMethodA(clazz, methodID, args);
    }

    jint JavaVM_CallStaticIntMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticIntMethodA(clazz, methodID, args);
    }

    jlong JavaVM_CallStaticLongMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticLongMethodA(clazz, methodID, args);
    }

    jfloat JavaVM_CallStaticFloatMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticFloatMethodA(clazz, methodID, args);
    }

    jdouble JavaVM_CallStaticDoubleMethod(Jvm* &ptr, jclass clazz, jmethodID methodID, const jvalue *args)
    {
        return ptr->env->CallStaticDoubleMethodA(clazz, methodID, args);
    }

    void JavaVM_CallStaticVoidMethod(Jvm* &ptr, jclass cls, jmethodID methodID, const jvalue *args)
    {
        ptr->env->CallStaticVoidMethodA(cls, methodID, args);
    }

    jfieldID JavaVM_GetStaticFieldID(Jvm* &ptr, jclass clazz, const char *name, const char *sig)
    {
        return ptr->env->GetStaticFieldID(clazz, name, sig);
    }

    jobject JavaVM_GetStaticObjectField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticObjectField(clazz, fieldID);
    }

    jboolean JavaVM_GetStaticBooleanField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticBooleanField(clazz, fieldID);
    }

    jbyte JavaVM_GetStaticByteField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticByteField(clazz, fieldID);
    }

    jchar JavaVM_GetStaticCharField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticCharField(clazz, fieldID);
    }

    jshort JavaVM_GetStaticShortField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticShortField(clazz, fieldID);
    }

    jint JavaVM_GetStaticIntField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticIntField(clazz, fieldID);
    }

    jlong JavaVM_GetStaticLongField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticLongField(clazz, fieldID);
    }

    jfloat JavaVM_GetStaticFloatField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticFloatField(clazz, fieldID);
    }

    jdouble JavaVM_GetStaticDoubleField(Jvm* &ptr, jclass clazz, jfieldID fieldID)
    {
        return ptr->env->GetStaticDoubleField(clazz, fieldID);
    }

    void JavaVM_SetStaticObjectField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jobject value)
    {
        ptr->env->SetStaticObjectField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticBooleanField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jboolean value)
    {
        ptr->env->SetStaticBooleanField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticByteField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jbyte value)
    {
        ptr->env->SetStaticByteField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticCharField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jchar value)
    {
        ptr->env->SetStaticCharField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticShortField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jshort value)
    {
        ptr->env->SetStaticShortField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticIntField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jint value)
    {
        ptr->env->SetStaticIntField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticLongField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jlong value)
    {
        ptr->env->SetStaticLongField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticFloatField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jfloat value)
    {
        ptr->env->SetStaticFloatField(clazz, fieldID, value);
    }

    void JavaVM_SetStaticDoubleField(Jvm* &ptr, jclass clazz, jfieldID fieldID, jdouble value)
    {
        ptr->env->SetStaticDoubleField(clazz, fieldID, value);
    }

    jstring JavaVM_NewString(Jvm* &ptr, const jchar *unicode, jsize len)
    {
        return ptr->env->NewString(unicode, len);
    }

    jsize JavaVM_GetStringLength(Jvm* &ptr, jstring str)
    {
        return ptr->env->GetStringLength(str);
    }

    const jchar *JavaVM_GetStringChars(Jvm* &ptr, jstring str, jboolean *isCopy)
    {
        return ptr->env->GetStringChars(str, isCopy);
    }

    void JavaVM_ReleaseStringChars(Jvm* &ptr, jstring str, const jchar *chars)
    {
        ptr->env->ReleaseStringChars(str, chars);
    }

    jstring JavaVM_NewStringUTF(Jvm* &ptr, const char *utf)
    {
        return ptr->env->NewStringUTF(utf);
    }

    jsize JavaVM_GetStringUTFLength(Jvm* &ptr, jstring str)
    {
        return ptr->env->GetStringUTFLength(str);
    }

    const char* JavaVM_GetStringUTFChars(Jvm* &ptr, jstring str, jboolean *isCopy)
    {
        return ptr->env->GetStringUTFChars(str, isCopy);
    }

    void JavaVM_ReleaseStringUTFChars(Jvm* &ptr, jstring str, const char* chars)
    {
        ptr->env->ReleaseStringUTFChars(str, chars);
    }


    jsize JavaVM_GetArrayLength(Jvm* &ptr, jarray array)
    {
        return ptr->env->GetArrayLength(array);
    }

    jobjectArray JavaVM_NewObjectArray(Jvm* &ptr, jsize len, jclass clazz, jobject init)
    {
        return ptr->env->NewObjectArray(len, clazz, init);
    }

    jobject JavaVM_GetObjectArrayElement(Jvm* &ptr, jobjectArray array, jsize index)
    {
        return ptr->env->GetObjectArrayElement(array, index);
    }

    void JavaVM_SetObjectArrayElement(Jvm* &ptr, jobjectArray array, jsize index, jobject val)
    {
        ptr->env->SetObjectArrayElement(array, index, val);
    }

    jbooleanArray JavaVM_NewBooleanArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewBooleanArray(len);
    }

    jbyteArray JavaVM_NewByteArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewByteArray(len);
    }

    jcharArray JavaVM_NewCharArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewCharArray(len);
    }

    jshortArray JavaVM_NewShortArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewShortArray(len);
    }

    jintArray JavaVM_NewIntArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewIntArray(len);
    }

    jlongArray JavaVM_NewLongArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewLongArray(len);
    }

    jfloatArray JavaVM_NewFloatArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewFloatArray(len);
    }

    jdoubleArray JavaVM_NewDoubleArray(Jvm* &ptr, jsize len)
    {
        return ptr->env->NewDoubleArray(len);
    }

    jboolean* JavaVM_GetBooleanArrayElements(Jvm* &ptr, jbooleanArray array, jboolean *isCopy)
    {
        return ptr->env->GetBooleanArrayElements(array, isCopy);
    }

    jbyte* JavaVM_GetByteArrayElements(Jvm* &ptr, jbyteArray array, jboolean *isCopy)
    {
        return ptr->env->GetByteArrayElements(array, isCopy);
    }

    jchar* JavaVM_GetCharArrayElements(Jvm* &ptr, jcharArray array, jboolean *isCopy)
    {
        return ptr->env->GetCharArrayElements(array, isCopy);
    }

    jshort* JavaVM_GetShortArrayElements(Jvm* &ptr, jshortArray array, jboolean *isCopy)
    {
        return ptr->env->GetShortArrayElements(array, isCopy);
    }

    jint* JavaVM_GetIntArrayElements(Jvm* &ptr, jintArray array, jboolean *isCopy)
    {
        return ptr->env->GetIntArrayElements(array, isCopy);
    }

    jlong* JavaVM_GetLongArrayElements(Jvm* &ptr, jlongArray array, jboolean *isCopy)
    {
        return ptr->env->GetLongArrayElements(array, isCopy);
    }

    jfloat* JavaVM_GetFloatArrayElements(Jvm* &ptr, jfloatArray array, jboolean *isCopy)
    {
        return ptr->env->GetFloatArrayElements(array, isCopy);
    }

    jdouble* JavaVM_GetDoubleArrayElements(Jvm* &ptr, jdoubleArray array, jboolean *isCopy)
    {
        return ptr->env->GetDoubleArrayElements(array, isCopy);
    }

    void JavaVM_ReleaseBooleanArrayElements(Jvm* &ptr, jbooleanArray array, jboolean *elems, jint mode)
    {
        ptr->env->ReleaseBooleanArrayElements(array, elems, mode);
    }

    void JavaVM_ReleaseByteArrayElements(Jvm* &ptr, jbyteArray array, jbyte *elems, jint mode)
    {
        ptr->env->ReleaseByteArrayElements(array, elems, mode);
    }

    void JavaVM_ReleaseCharArrayElements(Jvm* &ptr, jcharArray array, jchar *elems, jint mode)
    {
        ptr->env->ReleaseCharArrayElements(array, elems, mode);
    }

    void JavaVM_ReleaseShortArrayElements(Jvm* &ptr, jshortArray array, jshort *elems, jint mode)
    {
        ptr->env->ReleaseShortArrayElements(array, elems, mode);
    }

    void JavaVM_ReleaseIntArrayElements(Jvm* &ptr, jintArray array, jint *elems, jint mode)
    {
        ptr->env->ReleaseIntArrayElements(array, elems, mode);
    }

    void JavaVM_ReleaseLongArrayElements(Jvm* &ptr, jlongArray array, jlong *elems, jint mode)
    {
        ptr->env->ReleaseLongArrayElements(array, elems, mode);
    }

    void JavaVM_ReleaseFloatArrayElements(Jvm* &ptr, jfloatArray array, jfloat *elems, jint mode)
    {
        ptr->env->ReleaseFloatArrayElements(array, elems, mode);
    }

    void JavaVM_ReleaseDoubleArrayElements(Jvm* &ptr, jdoubleArray array, jdouble *elems, jint mode)
    {
        ptr->env->ReleaseDoubleArrayElements(array, elems, mode);
    }

    void JavaVM_GetBooleanArrayRegion(Jvm* &ptr, jbooleanArray array, jsize start, jsize len, jboolean *buf)
    {
        ptr->env->GetBooleanArrayRegion(array, start, len, buf);
    }

    void JavaVM_GetByteArrayRegion(Jvm* &ptr, jbyteArray array, jsize start, jsize len, jbyte *buf)
    {
        ptr->env->GetByteArrayRegion(array, start, len, buf);
    }

    void JavaVM_GetCharArrayRegion(Jvm* &ptr, jcharArray array, jsize start, jsize len, jchar *buf)
    {
        ptr->env->GetCharArrayRegion(array, start, len, buf);
    }

    void JavaVM_GetShortArrayRegion(Jvm* &ptr, jshortArray array, jsize start, jsize len, jshort *buf)
    {
        ptr->env->GetShortArrayRegion(array, start, len, buf);
    }

    void JavaVM_GetIntArrayRegion(Jvm* &ptr, jintArray array, jsize start, jsize len, jint *buf)
    {
        ptr->env->GetIntArrayRegion(array, start, len, buf);
    }

    void JavaVM_GetLongArrayRegion(Jvm* &ptr, jlongArray array, jsize start, jsize len, jlong *buf)
    {
        ptr->env->GetLongArrayRegion(array, start, len, buf);
    }

    void JavaVM_GetFloatArrayRegion(Jvm* &ptr, jfloatArray array, jsize start, jsize len, jfloat *buf)
    {
        ptr->env->GetFloatArrayRegion(array, start, len, buf);
    }

    void JavaVM_GetDoubleArrayRegion(Jvm* &ptr, jdoubleArray array, jsize start, jsize len, jdouble *buf)
    {
        ptr->env->GetDoubleArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetBooleanArrayRegion(Jvm* &ptr, jbooleanArray array, jsize start, jsize len, const jboolean *buf)
    {
        ptr->env->SetBooleanArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetByteArrayRegion(Jvm* &ptr, jbyteArray array, jsize start, jsize len, const jbyte *buf)
    {
        ptr->env->SetByteArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetCharArrayRegion(Jvm* &ptr, jcharArray array, jsize start, jsize len, const jchar *buf)
    {
        ptr->env->SetCharArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetShortArrayRegion(Jvm* &ptr, jshortArray array, jsize start, jsize len, const jshort *buf)
    {
        ptr->env->SetShortArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetIntArrayRegion(Jvm* &ptr, jintArray array, jsize start, jsize len, const jint *buf)
    {
        ptr->env->SetIntArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetLongArrayRegion(Jvm* &ptr, jlongArray array, jsize start, jsize len, const jlong *buf)
    {
        ptr->env->SetLongArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetFloatArrayRegion(Jvm* &ptr, jfloatArray array, jsize start, jsize len, const jfloat *buf)
    {
        ptr->env->SetFloatArrayRegion(array, start, len, buf);
    }

    void JavaVM_SetDoubleArrayRegion(Jvm* &ptr, jdoubleArray array, jsize start, jsize len, const jdouble *buf)
    {
        ptr->env->SetDoubleArrayRegion(array, start, len, buf);
    }

    jint JavaVM_RegisterNatives(Jvm* &ptr, jclass clazz, const JNINativeMethod *methods, jint nMethods)
    {
        return ptr->env->RegisterNatives(clazz, methods, nMethods);
    }

    jint JavaVM_UnregisterNatives(Jvm* &ptr, jclass clazz)
    {
        return ptr->env->UnregisterNatives(clazz);
    }

    jint JavaVM_MonitorEnter(Jvm* &ptr, jobject obj)
    {
        return ptr->env->MonitorEnter(obj);
    }

    jint JavaVM_MonitorExit(Jvm* &ptr, jobject obj)
    {
        return ptr->env->MonitorExit(obj);
    }

    jint JavaVM_GetJavaVM(Jvm* &ptr, JavaVM **vm)
    {
        return ptr->env->GetJavaVM(vm);
    }

    void JavaVM_GetStringRegion(Jvm* &ptr, jstring str, jsize start, jsize len, jchar *buf)
    {
        ptr->env->GetStringRegion(str, start, len, buf);
    }

    void JavaVM_GetStringUTFRegion(Jvm* &ptr, jstring str, jsize start, jsize len, char *buf)
    {
        ptr->env->GetStringUTFRegion(str, start, len, buf);
    }

    void* JavaVM_GetPrimitiveArrayCritical(Jvm* &ptr, jarray array, jboolean *isCopy)
    {
        return ptr->env->GetPrimitiveArrayCritical(array, isCopy);
    }

    void JavaVM_ReleasePrimitiveArrayCritical(Jvm* &ptr, jarray array, void *carray, jint mode)
    {
        ptr->env->ReleasePrimitiveArrayCritical(array, carray, mode);
    }

    const jchar* JavaVM_GetStringCritical(Jvm* &ptr, jstring string, jboolean *isCopy)
    {
        return ptr->env->GetStringCritical(string, isCopy);
    }

    void JavaVM_ReleaseStringCritical(Jvm* &ptr, jstring string, const jchar *cstring)
    {
        ptr->env->ReleaseStringCritical(string, cstring);
    }

    jweak JavaVM_NewWeakGlobalRef(Jvm* &ptr, jobject obj)
    {
        return ptr->env->NewWeakGlobalRef(obj);
    }

    void JavaVM_DeleteWeakGlobalRef(Jvm* &ptr, jweak ref)
    {
        ptr->env->DeleteWeakGlobalRef(ref);
    }

    jboolean JavaVM_ExceptionCheck(Jvm* &ptr)
    {
        return ptr->env->ExceptionCheck();
    }

    jobject JavaVM_NewDirectByteBuffer(Jvm* &ptr, void* address, jlong capacity)
    {
        return ptr->env->NewDirectByteBuffer(address, capacity);
    }

    void* JavaVM_GetDirectBufferAddress(Jvm* &ptr, jobject buf)
    {
        return ptr->env->GetDirectBufferAddress(buf);
    }

    jlong JavaVM_GetDirectBufferCapacity(Jvm* &ptr, jobject buf)
    {
        return ptr->env->GetDirectBufferCapacity(buf);
    }

    jobjectRefType JavaVM_GetObjectRefType(Jvm* &ptr, jobject obj)
    {
        return ptr->env->GetObjectRefType(obj);
    }


    main.cxx:
    C++ Code:
    #if defined _WIN32 || defined _WIN64
    #include <windows.h>
    #else
    #include <dlfcn.h>
    #endif

    #ifdef _MSC
    #define _CRT_SECURE_NO_WARNINGS
    #endif

    #if defined _WIN32 || defined _WIN64
    #define EXPORT_FUNC __declspec(dllexport)
    HMODULE module = NULL;
    #else
    #define EXPORT_FUNC
    #define __stdcall
    #endif

    #include <cstdint>
    #include "Exports.hxx"


    /**********************************************************************************************************/


    void onLoad() {}
    void onUnload() {}



    #if defined _WIN32 || defined _WIN64

    #if defined __cplusplus
    extern "C"
    {
    #endif


        EXPORT_FUNC bool __stdcall DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
        {
            switch(fdwReason)
            {
                case DLL_PROCESS_ATTACH:
                    DisableThreadLibraryCalls(hInstDLL);
                    module = hInstDLL;
                    onLoad();
                    break;

                case DLL_PROCESS_DETACH:
                    onUnload();
                    break;
            }
            return true;
        }


    #if defined __cplusplus
    }
    #endif


    #else

    void load() __attribute__((constructor))
    {
        onLoad();
    }

    void unload() __attribute__((destructor))
    {
        onUnload();
    }

    #endif




    /********************************************************************************************************************/


    #ifdef __cplusplus
    extern "C"
    {
    #endif


    EXPORT_FUNC int GetPluginABIVersion();

    EXPORT_FUNC int GetTypeCount();
    EXPORT_FUNC int GetFunctionCount();

    EXPORT_FUNC int GetTypeInfo(int Index, char** Type, char** Definition);
    EXPORT_FUNC int GetFunctionInfo(int Index, void** Address, char** Definition);


    #ifdef __cplusplus
    }
    #endif


    int GetPluginABIVersion()
    {
        return ABI_VERSION;
    }

    int GetTypeCount()
    {
        return PascalTypeCount;
    }

    int GetFunctionCount()
    {
        return PascalFunctionCount;
    }

    int GetTypeInfo(int Index, char** Type, char** Definition)
    {
        if (Index < GetTypeCount())
        {
            strcpy(*Type, PascalTypes[Index * 2 + 0]);
            strcpy(*Definition, PascalTypes[Index * 2 + 1]);
            return Index;
        }
        return -1;
    }

    int GetFunctionInfo(int Index, void** Address, char** Definition)
    {
        if(Index < GetFunctionCount())
        {
            #if defined _WIN32 || defined _WIN64
            *Address = (void*)GetProcAddress(module, PascalFunctions[Index * 2]);
            #else
            *Address = (void*)dlsym(RTLD_DEFAULT, PascalFunctions[Index * 2]);
            #endif
            strcpy(*Definition, PascalFunctions[Index * 2 + 1]);
            return Index;
        }
        return -1;
    }
    Last edited by Brandon; 02-23-2015 at 10:58 AM.
    I am Ggzz..
    Hackintosher

  2. #2
    Join Date
    Dec 2011
    Location
    East Coast, USA
    Posts
    4,231
    Mentioned
    112 Post(s)
    Quoted
    1869 Post(s)

    Default

    Wow, this is way over my head but really cool ... is this the first step towards reflection for RS3?
    GitLab projects | Simba 1.4 | Find me on IRC or Discord | ScapeRune scripts | Come play bot ScapeRune!

    <BenLand100> we're just in the transitional phase where society reclassifies guns as Badâ„¢ before everyone gets laser pistols

  3. #3
    Join Date
    Aug 2007
    Location
    Colorado
    Posts
    7,421
    Mentioned
    268 Post(s)
    Quoted
    1442 Post(s)

    Default

    This is quite impressive Brandon, nicely done!

    Current projects:
    [ AeroGuardians (GotR minigame), Motherlode Miner, Blast furnace ]

    "I won't fall in your gravity. Open your eyes,
    you're the Earth and I'm the sky..."


  4. #4
    Join Date
    Dec 2010
    Posts
    483
    Mentioned
    30 Post(s)
    Quoted
    328 Post(s)

    Default

    Quote Originally Posted by KeepBotting View Post
    Wow, this is way over my head but really cool ... is this the first step towards reflection for RS3?
    Unfortunately no.

    The issue with reflection for RS3 include:
    • Not enough developers know anything about the new RT engine
    • ~100 GamePacks are distributed with every update, done by location IP (I believe?) and running the jar you shouldn't be is easily detectable


    There are a few other minor problems, but nothing that can't be overcome.

    Here is how we will get RS3 reflection:

    Simba will need to download a gamepack from the rs website. This gamepack will then have to be identified in some way (I'd opt for a checksum hash). After that point, simba will have to query an update server, and receive the correct "hooks" (terrible name when speaking strictly about reflection btw) for that specific gamepack.

    This means several things:
    • Someone will have to make their updater download every possible gamepack for that update, and create a hook file for each instance
    • A new reflection include will have to be written to do the math on Simba's side (not to mention wrappers for all sorts of objects)
    • A better solution than downloading a gamepack before every run will have to be found


    Some steps in the right direction:

    Most GamePacks for each revision can be found here.

    Note that what you are actually interested in is the inner pack.

    EDIT:

    I realized I wasn't clear. Simba will only download a gamepack to determine the actual pack assigned to them. SMART will still run off the web jar and not the local one, but the web jar will be the same as one downloaded, therefore it can be used to determine the assigned pack only.

  5. #5
    Join Date
    Feb 2011
    Location
    The Future.
    Posts
    5,600
    Mentioned
    396 Post(s)
    Quoted
    1598 Post(s)

    Default

    The alternative is to make a public updater and have everyone run that on their machine. That's what I've been testing and I've been using this plugin for testing directly in Simba.

    So far I only have around 10 or 12 classes hooked. They're all as easy to hook as in OSRS.. It's just time consuming.
    I am Ggzz..
    Hackintosher

  6. #6
    Join Date
    Sep 2008
    Location
    Not here.
    Posts
    5,422
    Mentioned
    13 Post(s)
    Quoted
    242 Post(s)

    Default

    It's cool in concept. For any real application it gets slow/tricky. You might as well just interface the jni for a specific jar, that way you have control over what the user does with it(this is good coding practice).

  7. #7
    Join Date
    Apr 2013
    Posts
    35
    Mentioned
    0 Post(s)
    Quoted
    6 Post(s)

    Default

    This is pretty cool, Nice

  8. #8
    Join Date
    Apr 2015
    Posts
    1
    Mentioned
    0 Post(s)
    Quoted
    0 Post(s)

    Default

    thanks for the information....

Thread Information

Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •