From 0213172bc5390654307bd23885f3943547ea7185 Mon Sep 17 00:00:00 2001 From: Rik Veenboer Date: Sat, 19 Feb 2011 15:10:15 +0000 Subject: [PATCH] --- cpp/nativecall/Debug/IntCall.asm | 1766 +++++++++++++++++ cpp/nativecall/Debug/IntCall.obj | Bin 0 -> 27787 bytes cpp/nativecall/Debug/NativeCall.asm | 1492 ++++++++++++++ cpp/nativecall/Debug/NativeCall.dll | Bin 0 -> 233590 bytes cpp/nativecall/Debug/NativeCall.obj | Bin 0 -> 29095 bytes cpp/nativecall/Debug/RCa01372 | Bin 0 -> 4904 bytes cpp/nativecall/Debug/RCa01444 | Bin 0 -> 4904 bytes cpp/nativecall/Debug/RCa01468 | Bin 0 -> 4904 bytes cpp/nativecall/Debug/VoidCall.asm | 1743 ++++++++++++++++ cpp/nativecall/Debug/VoidCall.obj | Bin 0 -> 27719 bytes cpp/nativecall/IntCall.cpp | 236 +++ cpp/nativecall/NativeCall.cpp | 234 +++ cpp/nativecall/NativeCall.dsp | 132 ++ cpp/nativecall/NativeCall.dsw | 29 + cpp/nativecall/Release/IntCall.asm | 943 +++++++++ cpp/nativecall/Release/IntCall.obj | Bin 0 -> 3896 bytes cpp/nativecall/Release/NativeCall.asm | 859 ++++++++ cpp/nativecall/Release/NativeCall.dll | Bin 0 -> 7680 bytes cpp/nativecall/Release/NativeCall.map | 101 + cpp/nativecall/Release/NativeCall.obj | Bin 0 -> 6571 bytes cpp/nativecall/Release/RCa01380 | Bin 0 -> 4904 bytes cpp/nativecall/Release/VoidCall.asm | 919 +++++++++ cpp/nativecall/Release/VoidCall.obj | Bin 0 -> 3885 bytes cpp/nativecall/VoidCall.cpp | 228 +++ cpp/nativecall/com_eaio_nativecall_IntCall.h | 29 + .../com_eaio_nativecall_NativeCall.h | 45 + cpp/nativecall/com_eaio_nativecall_VoidCall.h | 29 + cpp/nativecall/readme.txt | 25 + cpp/nativecall/resource.h | 15 + cpp/nativecall/version.rc | 104 + java/src/com/eaio/nativecall/Holder.java | 133 ++ java/src/com/eaio/nativecall/IntCall.java | 143 ++ java/src/com/eaio/nativecall/NativeCall.java | 355 ++++ java/src/com/eaio/nativecall/Verifier.java | 101 + java/src/com/eaio/nativecall/Verifiers.java | 83 + java/src/com/eaio/nativecall/VoidCall.java | 99 + .../com/eaio/nativecall/Win32Verifier.java | 122 ++ java/src/com/eaio/nativecall/package.html | 15 + 38 files changed, 9980 insertions(+) create mode 100644 cpp/nativecall/Debug/IntCall.asm create mode 100644 cpp/nativecall/Debug/IntCall.obj create mode 100644 cpp/nativecall/Debug/NativeCall.asm create mode 100644 cpp/nativecall/Debug/NativeCall.dll create mode 100644 cpp/nativecall/Debug/NativeCall.obj create mode 100644 cpp/nativecall/Debug/RCa01372 create mode 100644 cpp/nativecall/Debug/RCa01444 create mode 100644 cpp/nativecall/Debug/RCa01468 create mode 100644 cpp/nativecall/Debug/VoidCall.asm create mode 100644 cpp/nativecall/Debug/VoidCall.obj create mode 100644 cpp/nativecall/IntCall.cpp create mode 100644 cpp/nativecall/NativeCall.cpp create mode 100644 cpp/nativecall/NativeCall.dsp create mode 100644 cpp/nativecall/NativeCall.dsw create mode 100644 cpp/nativecall/Release/IntCall.asm create mode 100644 cpp/nativecall/Release/IntCall.obj create mode 100644 cpp/nativecall/Release/NativeCall.asm create mode 100644 cpp/nativecall/Release/NativeCall.dll create mode 100644 cpp/nativecall/Release/NativeCall.map create mode 100644 cpp/nativecall/Release/NativeCall.obj create mode 100644 cpp/nativecall/Release/RCa01380 create mode 100644 cpp/nativecall/Release/VoidCall.asm create mode 100644 cpp/nativecall/Release/VoidCall.obj create mode 100644 cpp/nativecall/VoidCall.cpp create mode 100644 cpp/nativecall/com_eaio_nativecall_IntCall.h create mode 100644 cpp/nativecall/com_eaio_nativecall_NativeCall.h create mode 100644 cpp/nativecall/com_eaio_nativecall_VoidCall.h create mode 100644 cpp/nativecall/readme.txt create mode 100644 cpp/nativecall/resource.h create mode 100644 cpp/nativecall/version.rc create mode 100644 java/src/com/eaio/nativecall/Holder.java create mode 100644 java/src/com/eaio/nativecall/IntCall.java create mode 100644 java/src/com/eaio/nativecall/NativeCall.java create mode 100644 java/src/com/eaio/nativecall/Verifier.java create mode 100644 java/src/com/eaio/nativecall/Verifiers.java create mode 100644 java/src/com/eaio/nativecall/VoidCall.java create mode 100644 java/src/com/eaio/nativecall/Win32Verifier.java create mode 100644 java/src/com/eaio/nativecall/package.html diff --git a/cpp/nativecall/Debug/IntCall.asm b/cpp/nativecall/Debug/IntCall.asm new file mode 100644 index 0000000..3ab588a --- /dev/null +++ b/cpp/nativecall/Debug/IntCall.asm @@ -0,0 +1,1766 @@ + TITLE C:\Documents and Settings\Administrator\My Documents\Software\NativeCall\src\cpp\IntCall.cpp + .386P +include listing.inc +if @Version gt 510 +.model FLAT +else +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +_BSS SEGMENT DWORD USE32 PUBLIC 'BSS' +_BSS ENDS +$$SYMBOLS SEGMENT BYTE USE32 'DEBSYM' +$$SYMBOLS ENDS +$$TYPES SEGMENT BYTE USE32 'DEBTYP' +$$TYPES ENDS +_TLS SEGMENT DWORD USE32 PUBLIC 'TLS' +_TLS ENDS +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ??8@YAHABU_GUID@@0@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_IntCall_executeCall@8 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_IntCall_executeCall0@12 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +FLAT GROUP _DATA, CONST, _BSS + ASSUME CS: FLAT, DS: FLAT, SS: FLAT +endif +PUBLIC ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField +PUBLIC ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField +PUBLIC _Java_com_eaio_nativecall_IntCall_executeCall@8 +EXTRN __imp__GetLastError@0:NEAR +EXTRN ?fieldFunctionHandle@@3PAU_jfieldID@@A:DWORD ; fieldFunctionHandle +EXTRN ?fieldLastErrorCode@@3PAU_jfieldID@@A:DWORD ; fieldLastErrorCode +EXTRN __chkesp:NEAR +; COMDAT _Java_com_eaio_nativecall_IntCall_executeCall@8 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_functionHandle$ = -4 +_outVal$ = -8 +_Java_com_eaio_nativecall_IntCall_executeCall@8 PROC NEAR ; COMDAT + +; 79 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + sub esp, 72 ; 00000048H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-72] + mov ecx, 18 ; 00000012H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 80 : +; 81 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov eax, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField + mov DWORD PTR _functionHandle$[ebp], eax + +; 82 : jint outVal; +; 83 : +; 84 : #ifdef _WINDOWS +; 85 : #ifdef _X86_ +; 86 : +; 87 : __asm { +; 88 : +; 89 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 90 : mov outVal, eax + + mov DWORD PTR _outVal$[ebp], eax + +; 91 : +; 92 : } +; 93 : +; 94 : #endif +; 95 : #endif +; 96 : +; 97 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + mov esi, esp + call DWORD PTR __imp__GetLastError@0 + cmp esi, esp + call __chkesp + push eax + mov edx, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField + +; 98 : +; 99 : return outVal; + + mov eax, DWORD PTR _outVal$[ebp] + +; 100 : +; 101 : } + + pop edi + pop esi + pop ebx + add esp, 72 ; 00000048H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +_Java_com_eaio_nativecall_IntCall_executeCall@8 ENDP +_TEXT ENDS +PUBLIC ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField +PUBLIC ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ; JNIEnv_::SetObjectField +PUBLIC _Java_com_eaio_nativecall_IntCall_executeCall0@12 +PUBLIC ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z ; JNIEnv_::GetArrayLength +PUBLIC ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ; JNIEnv_::GetObjectArrayElement +PUBLIC ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' +PUBLIC ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical +PUBLIC ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ; JNIEnv_::ReleasePrimitiveArrayCritical +PUBLIC ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass +PUBLIC ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z ; JNIEnv_::ThrowNew +PUBLIC ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject +PUBLIC ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf +PUBLIC ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod +PUBLIC ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod +EXTRN ??2@YAPAXI@Z:NEAR ; operator new +EXTRN ??3@YAXPAX@Z:NEAR ; operator delete +EXTRN ?fieldHolderO@@3PAU_jfieldID@@A:DWORD ; fieldHolderO +EXTRN ?classBoolean@@3PAV_jclass@@A:DWORD ; classBoolean +EXTRN ?classInteger@@3PAV_jclass@@A:DWORD ; classInteger +EXTRN ?classByteArray@@3PAV_jclass@@A:DWORD ; classByteArray +EXTRN ?classCharArray@@3PAV_jclass@@A:DWORD ; classCharArray +EXTRN ?classHolder@@3PAV_jclass@@A:DWORD ; classHolder +EXTRN ?methodBooleanValue@@3PAU_jmethodID@@A:DWORD ; methodBooleanValue +EXTRN ?methodIntValue@@3PAU_jmethodID@@A:DWORD ; methodIntValue +EXTRN ?newIntegerInt@@3PAU_jmethodID@@A:DWORD ; newIntegerInt +EXTRN ?newBooleanBoolean@@3PAU_jmethodID@@A:DWORD ; newBooleanBoolean +EXTRN _memset:NEAR +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +; File c:\documents and settings\administrator\my documents\software\nativecall\src\cpp\intcall.cpp +CONST SEGMENT +??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ DB 'java/lang/OutOfMemor' + DB 'yError', 00H ; `string' +CONST ENDS +; COMDAT _Java_com_eaio_nativecall_IntCall_executeCall0@12 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_params$ = 16 +_len$ = -4 +_arrays$ = -8 +_param$ = -12 +_i$ = -16 +_intArg$56817 = -20 +_byteArrayArg$56820 = -24 +_charArrayArg$56826 = -28 +_booleanArg$56832 = -32 +_tempArg$56833 = -36 +_o$56836 = -40 +_intPtr$56838 = -44 +_byteArrayArg$56844 = -48 +_charArrayArg$56850 = -52 +_booleanArg$56856 = -56 +_tempPtr$56857 = -60 +_functionHandle$ = -64 +_outVal$ = -68 +_j$ = -72 +_o$56875 = -76 +_out$56877 = -80 +_out$56887 = -84 +$T56916 = -88 +$T56917 = -92 +$T56918 = -96 +$T56919 = -100 +$T56920 = -104 +$T56921 = -108 +_Java_com_eaio_nativecall_IntCall_executeCall0@12 PROC NEAR ; COMDAT + +; 109 : (JNIEnv *env, jobject obj, jobjectArray params) { + + push ebp + mov ebp, esp + sub esp, 172 ; 000000acH + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-172] + mov ecx, 43 ; 0000002bH + mov eax, -858993460 ; ccccccccH + rep stosd + +; 110 : +; 111 : const int len = env->GetArrayLength(params); + + mov eax, DWORD PTR _params$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z ; JNIEnv_::GetArrayLength + mov DWORD PTR _len$[ebp], eax + +; 112 : +; 113 : int* arrays = NULL; + + mov DWORD PTR _arrays$[ebp], 0 + +; 114 : if (!(arrays = new int[len])) { + + mov ecx, DWORD PTR _len$[ebp] + shl ecx, 2 + push ecx + call ??2@YAPAXI@Z ; operator new + add esp, 4 + mov DWORD PTR $T56916[ebp], eax + mov edx, DWORD PTR $T56916[ebp] + mov DWORD PTR _arrays$[ebp], edx + cmp DWORD PTR _arrays$[ebp], 0 + jne SHORT $L56806 + +; 115 : env->ThrowNew(env->FindClass("java/lang/OutOfMemoryError"), NULL); + + push 0 + push OFFSET FLAT:??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z ; JNIEnv_::ThrowNew + +; 116 : return 0; + + xor eax, eax + jmp $L56801 +$L56806: + +; 118 : memset(arrays, 0, (sizeof(int) * len)); + + mov eax, DWORD PTR _len$[ebp] + shl eax, 2 + push eax + push 0 + mov ecx, DWORD PTR _arrays$[ebp] + push ecx + call _memset + add esp, 12 ; 0000000cH + +; 119 : +; 120 : jobject param; +; 121 : +; 122 : for (int i = len - 1; i >= 0; i--) { + + mov edx, DWORD PTR _len$[ebp] + sub edx, 1 + mov DWORD PTR _i$[ebp], edx + jmp SHORT $L56811 +$L56812: + mov eax, DWORD PTR _i$[ebp] + sub eax, 1 + mov DWORD PTR _i$[ebp], eax +$L56811: + cmp DWORD PTR _i$[ebp], 0 + jl $L56813 + +; 123 : +; 124 : param = env->GetObjectArrayElement(params, i); + + mov ecx, DWORD PTR _i$[ebp] + push ecx + mov edx, DWORD PTR _params$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ; JNIEnv_::GetObjectArrayElement + mov DWORD PTR _param$[ebp], eax + +; 125 : +; 126 : if (param == NULL) { + + cmp DWORD PTR _param$[ebp], 0 + jne SHORT $L56814 + +; 127 : _push(0); + + push 0 + +; 129 : else if (env->IsInstanceOf(param, classInteger)) { + + jmp $L56855 +$L56814: + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56816 + +; 130 : int intArg = env->CallIntMethod(param, methodIntValue); + + mov edx, DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + push ecx + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + add esp, 12 ; 0000000cH + mov DWORD PTR _intArg$56817[ebp], eax + +; 131 : _push(intArg) + + push DWORD PTR _intArg$56817[ebp] + +; 133 : else if (env->IsInstanceOf(param, classByteArray)) { + + jmp $L56855 +$L56816: + mov edx, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56819 + +; 134 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) param, 0); + + push 0 + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _byteArrayArg$56820[ebp], eax + +; 135 : arrays[i] = (int) &byteArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _byteArrayArg$56820[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 136 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$56820[ebp] + +; 138 : else if (env->IsInstanceOf(param, classCharArray)) { + + jmp $L56855 +$L56819: + mov edx, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56825 + +; 139 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 140 : (jarray) param, 0); + + push 0 + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _charArrayArg$56826[ebp], eax + +; 141 : arrays[i] = (int) &charArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _charArrayArg$56826[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 142 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$56826[ebp] + +; 144 : else if (env->IsInstanceOf(param, classBoolean)) { + + jmp $L56855 +$L56825: + mov edx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56831 + +; 145 : jboolean booleanArg = env->CallBooleanMethod(param, methodBooleanValue); + + mov ecx, DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov eax, DWORD PTR _env$[ebp] + push eax + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + add esp, 12 ; 0000000cH + mov BYTE PTR _booleanArg$56832[ebp], al + +; 146 : int tempArg = (booleanArg == JNI_FALSE ? 0 : 1); + + mov ecx, DWORD PTR _booleanArg$56832[ebp] + and ecx, 255 ; 000000ffH + neg ecx + sbb ecx, ecx + neg ecx + mov DWORD PTR _tempArg$56833[ebp], ecx + +; 147 : _push(tempArg) + + push DWORD PTR _tempArg$56833[ebp] + +; 149 : else if (env->IsInstanceOf(param, classHolder)) { + + jmp $L56855 +$L56831: + mov edx, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je $L56855 + +; 150 : +; 151 : /* Holder */ +; 152 : +; 153 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov ecx, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField + mov DWORD PTR _o$56836[ebp], eax + +; 154 : +; 155 : if (env->IsInstanceOf(o, classInteger)) { + + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + mov ecx, DWORD PTR _o$56836[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56837 + +; 156 : int *intPtr = new int; + + push 4 + call ??2@YAPAXI@Z ; operator new + add esp, 4 + mov DWORD PTR $T56917[ebp], eax + mov edx, DWORD PTR $T56917[ebp] + mov DWORD PTR _intPtr$56838[ebp], edx + +; 157 : *intPtr = env->CallIntMethod(o, methodIntValue); + + mov eax, DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push eax + mov ecx, DWORD PTR _o$56836[ebp] + push ecx + mov edx, DWORD PTR _env$[ebp] + push edx + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + add esp, 12 ; 0000000cH + mov ecx, DWORD PTR _intPtr$56838[ebp] + mov DWORD PTR [ecx], eax + +; 158 : arrays[i] = (int) intPtr; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + mov ecx, DWORD PTR _intPtr$56838[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 159 : _push(intPtr); + + push DWORD PTR _intPtr$56838[ebp] + +; 161 : else if (env->IsInstanceOf(o, classByteArray)) { + + jmp $L56855 +$L56837: + mov edx, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push edx + mov eax, DWORD PTR _o$56836[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56843 + +; 162 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) o, 0); + + push 0 + mov ecx, DWORD PTR _o$56836[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _byteArrayArg$56844[ebp], eax + +; 163 : arrays[i] = (int) &byteArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _byteArrayArg$56844[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 164 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$56844[ebp] + +; 166 : else if (env->IsInstanceOf(o, classCharArray)) { + + jmp $L56855 +$L56843: + mov edx, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push edx + mov eax, DWORD PTR _o$56836[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56849 + +; 167 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 168 : (jarray) o, 0); + + push 0 + mov ecx, DWORD PTR _o$56836[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _charArrayArg$56850[ebp], eax + +; 169 : arrays[i] = (int) &charArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _charArrayArg$56850[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 170 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$56850[ebp] + +; 172 : else if (env->IsInstanceOf(o, classBoolean)) { + + jmp SHORT $L56855 +$L56849: + mov edx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push edx + mov eax, DWORD PTR _o$56836[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56855 + +; 173 : jboolean booleanArg = env->CallBooleanMethod(o, methodBooleanValue); + + mov ecx, DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ecx + mov edx, DWORD PTR _o$56836[ebp] + push edx + mov eax, DWORD PTR _env$[ebp] + push eax + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + add esp, 12 ; 0000000cH + mov BYTE PTR _booleanArg$56856[ebp], al + +; 174 : int *tempPtr = new int; + + push 4 + call ??2@YAPAXI@Z ; operator new + add esp, 4 + mov DWORD PTR $T56918[ebp], eax + mov ecx, DWORD PTR $T56918[ebp] + mov DWORD PTR _tempPtr$56857[ebp], ecx + +; 175 : *tempPtr = (booleanArg == JNI_FALSE ? 0 : 1); + + mov edx, DWORD PTR _booleanArg$56856[ebp] + and edx, 255 ; 000000ffH + neg edx + sbb edx, edx + neg edx + mov eax, DWORD PTR _tempPtr$56857[ebp] + mov DWORD PTR [eax], edx + +; 176 : arrays[i] = (int) tempPtr; + + mov ecx, DWORD PTR _i$[ebp] + mov edx, DWORD PTR _arrays$[ebp] + mov eax, DWORD PTR _tempPtr$56857[ebp] + mov DWORD PTR [edx+ecx*4], eax + +; 177 : _push(tempPtr); + + push DWORD PTR _tempPtr$56857[ebp] +$L56855: + +; 183 : +; 184 : } + + jmp $L56812 +$L56813: + +; 185 : +; 186 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov ecx, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField + mov DWORD PTR _functionHandle$[ebp], eax + +; 187 : jint outVal; +; 188 : +; 189 : #ifdef _WINDOWS +; 190 : #ifdef _X86_ +; 191 : +; 192 : __asm { +; 193 : +; 194 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 195 : mov outVal, eax + + mov DWORD PTR _outVal$[ebp], eax + +; 196 : +; 197 : } +; 198 : +; 199 : #endif +; 200 : #endif +; 201 : +; 202 : for (int j = 0; j < len; ++j) { + + mov DWORD PTR _j$[ebp], 0 + jmp SHORT $L56864 +$L56865: + mov eax, DWORD PTR _j$[ebp] + add eax, 1 + mov DWORD PTR _j$[ebp], eax +$L56864: + mov ecx, DWORD PTR _j$[ebp] + cmp ecx, DWORD PTR _len$[ebp] + jge $L56866 + +; 203 : param = env->GetObjectArrayElement(params, j); + + mov edx, DWORD PTR _j$[ebp] + push edx + mov eax, DWORD PTR _params$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ; JNIEnv_::GetObjectArrayElement + mov DWORD PTR _param$[ebp], eax + +; 204 : if (param == NULL) {} + + cmp DWORD PTR _param$[ebp], 0 + jne SHORT $L56867 + +; 205 : else if (env->IsInstanceOf(param, classByteArray) || env->IsInstanceOf(param, classCharArray)) { + + jmp $L56886 +$L56867: + mov ecx, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + jne SHORT $L56870 + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56869 +$L56870: + +; 206 : env->ReleasePrimitiveArrayCritical((jarray) param, (void*) arrays[j], 0); + + push 0 + mov edx, DWORD PTR _j$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + mov ecx, DWORD PTR [eax+edx*4] + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ; JNIEnv_::ReleasePrimitiveArrayCritical + +; 208 : else if (env->IsInstanceOf(param, classHolder)) { + + jmp $L56886 +$L56869: + mov eax, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je $L56886 + +; 209 : +; 210 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov edx, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField + mov DWORD PTR _o$56875[ebp], eax + +; 211 : +; 212 : if (env->IsInstanceOf(o, classInteger)) { + + mov ecx, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push ecx + mov edx, DWORD PTR _o$56875[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56876 + +; 213 : int* out = (int*) arrays[j]; + + mov eax, DWORD PTR _j$[ebp] + mov ecx, DWORD PTR _arrays$[ebp] + mov edx, DWORD PTR [ecx+eax*4] + mov DWORD PTR _out$56877[ebp], edx + +; 214 : env->SetObjectField(param, fieldHolderO, env->NewObject(classInteger, newIntegerInt, *out)); + + mov eax, DWORD PTR _out$56877[ebp] + mov ecx, DWORD PTR [eax] + push ecx + mov edx, DWORD PTR ?newIntegerInt@@3PAU_jmethodID@@A ; newIntegerInt + push edx + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + mov ecx, DWORD PTR _env$[ebp] + push ecx + call ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject + add esp, 16 ; 00000010H + push eax + mov edx, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ; JNIEnv_::SetObjectField + +; 215 : delete out; + + mov ecx, DWORD PTR _out$56877[ebp] + mov DWORD PTR $T56919[ebp], ecx + mov edx, DWORD PTR $T56919[ebp] + push edx + call ??3@YAXPAX@Z ; operator delete + add esp, 4 + +; 217 : else if (env->IsInstanceOf(o, classByteArray) || env->IsInstanceOf(o, classCharArray)) { + + jmp $L56886 +$L56876: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push eax + mov ecx, DWORD PTR _o$56875[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + jne SHORT $L56882 + mov edx, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push edx + mov eax, DWORD PTR _o$56875[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56881 +$L56882: + +; 218 : env->ReleasePrimitiveArrayCritical((jarray) o, (void*) arrays[j], 0); + + push 0 + mov ecx, DWORD PTR _j$[ebp] + mov edx, DWORD PTR _arrays$[ebp] + mov eax, DWORD PTR [edx+ecx*4] + push eax + mov ecx, DWORD PTR _o$56875[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ; JNIEnv_::ReleasePrimitiveArrayCritical + +; 220 : else if (env->IsInstanceOf(o, classBoolean)) { + + jmp SHORT $L56886 +$L56881: + mov edx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push edx + mov eax, DWORD PTR _o$56875[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56886 + +; 221 : int* out = (int*) arrays[j]; + + mov ecx, DWORD PTR _j$[ebp] + mov edx, DWORD PTR _arrays$[ebp] + mov eax, DWORD PTR [edx+ecx*4] + mov DWORD PTR _out$56887[ebp], eax + +; 222 : env->SetObjectField(param, fieldHolderO, env->NewObject(classBoolean, newBooleanBoolean, (*out == 0 ? JNI_FALSE : JNI_TRUE))); + + mov ecx, DWORD PTR _out$56887[ebp] + xor edx, edx + cmp DWORD PTR [ecx], 0 + setne dl + push edx + mov eax, DWORD PTR ?newBooleanBoolean@@3PAU_jmethodID@@A ; newBooleanBoolean + push eax + mov ecx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push ecx + mov edx, DWORD PTR _env$[ebp] + push edx + call ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject + add esp, 16 ; 00000010H + push eax + mov eax, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ; JNIEnv_::SetObjectField + +; 223 : delete out; + + mov edx, DWORD PTR _out$56887[ebp] + mov DWORD PTR $T56920[ebp], edx + mov eax, DWORD PTR $T56920[ebp] + push eax + call ??3@YAXPAX@Z ; operator delete + add esp, 4 +$L56886: + +; 227 : +; 228 : } + + jmp $L56865 +$L56866: + +; 229 : +; 230 : delete [] arrays; + + mov ecx, DWORD PTR _arrays$[ebp] + mov DWORD PTR $T56921[ebp], ecx + mov edx, DWORD PTR $T56921[ebp] + push edx + call ??3@YAXPAX@Z ; operator delete + add esp, 4 + +; 231 : +; 232 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + mov esi, esp + call DWORD PTR __imp__GetLastError@0 + cmp esi, esp + call __chkesp + push eax + mov eax, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField + +; 233 : +; 234 : return outVal; + + mov eax, DWORD PTR _outVal$[ebp] +$L56801: + +; 235 : +; 236 : } + + pop edi + pop esi + pop ebx + add esp, 172 ; 000000acH + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +_Java_com_eaio_nativecall_IntCall_executeCall0@12 ENDP +_TEXT ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT +_this$ = -4 +_name$ = 8 +?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z PROC NEAR ; JNIEnv_::FindClass, COMDAT + +; 759 : jclass FindClass(const char *name) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 760 : return functions->FindClass(this, name); + + mov esi, esp + mov eax, DWORD PTR _name$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+24] + cmp esi, esp + call __chkesp + +; 761 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 4 +?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ENDP ; JNIEnv_::FindClass +_TEXT ENDS +; COMDAT ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z +_TEXT SEGMENT +_this$ = -4 +_clazz$ = 8 +_msg$ = 12 +?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z PROC NEAR ; JNIEnv_::ThrowNew, COMDAT + +; 787 : jint ThrowNew(jclass clazz, const char *msg) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 788 : return functions->ThrowNew(this, clazz, msg); + + mov esi, esp + mov eax, DWORD PTR _msg$[ebp] + push eax + mov ecx, DWORD PTR _clazz$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+56] + cmp esi, esp + call __chkesp + +; 789 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z ENDP ; JNIEnv_::ThrowNew +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_args$ = -4 +_result$ = -8 +_clazz$ = 12 +_methodID$ = 16 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::NewObject, COMDAT + +; 834 : jobject NewObject(jclass clazz, jmethodID methodID, ...) { + + push ebp + mov ebp, esp + sub esp, 72 ; 00000048H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-72] + mov ecx, 18 ; 00000012H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 835 : va_list args; +; 836 : jobject result; +; 837 : va_start(args, methodID); + + lea eax, DWORD PTR _methodID$[ebp+4] + mov DWORD PTR _args$[ebp], eax + +; 838 : result = functions->NewObjectV(this,clazz,methodID,args); + + mov esi, esp + mov ecx, DWORD PTR _args$[ebp] + push ecx + mov edx, DWORD PTR _methodID$[ebp] + push edx + mov eax, DWORD PTR _clazz$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+116] + cmp esi, esp + call __chkesp + mov DWORD PTR _result$[ebp], eax + +; 839 : va_end(args); + + mov DWORD PTR _args$[ebp], 0 + +; 840 : return result; + + mov eax, DWORD PTR _result$[ebp] + +; 841 : } + + pop edi + pop esi + pop ebx + add esp, 72 ; 00000048H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 0 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::NewObject +_TEXT ENDS +; COMDAT ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z +_TEXT SEGMENT +_this$ = -4 +_obj$ = 8 +_clazz$ = 12 +?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z PROC NEAR ; JNIEnv_::IsInstanceOf, COMDAT + +; 854 : jboolean IsInstanceOf(jobject obj, jclass clazz) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 855 : return functions->IsInstanceOf(this,obj,clazz); + + mov esi, esp + mov eax, DWORD PTR _clazz$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+128] + cmp esi, esp + call __chkesp + +; 856 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ENDP ; JNIEnv_::IsInstanceOf +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_args$ = -4 +_result$ = -8 +_obj$ = 12 +_methodID$ = 16 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallBooleanMethod, COMDAT + +; 881 : jmethodID methodID, ...) { + + push ebp + mov ebp, esp + sub esp, 72 ; 00000048H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-72] + mov ecx, 18 ; 00000012H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 882 : va_list args; +; 883 : jboolean result; +; 884 : va_start(args,methodID); + + lea eax, DWORD PTR _methodID$[ebp+4] + mov DWORD PTR _args$[ebp], eax + +; 885 : result = functions->CallBooleanMethodV(this,obj,methodID,args); + + mov esi, esp + mov ecx, DWORD PTR _args$[ebp] + push ecx + mov edx, DWORD PTR _methodID$[ebp] + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+152] + cmp esi, esp + call __chkesp + mov BYTE PTR _result$[ebp], al + +; 886 : va_end(args); + + mov DWORD PTR _args$[ebp], 0 + +; 887 : return result; + + mov al, BYTE PTR _result$[ebp] + +; 888 : } + + pop edi + pop esi + pop ebx + add esp, 72 ; 00000048H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 0 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallBooleanMethod +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_args$ = -4 +_result$ = -8 +_obj$ = 12 +_methodID$ = 16 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallIntMethod, COMDAT + +; 949 : jint CallIntMethod(jobject obj, jmethodID methodID, ...) { + + push ebp + mov ebp, esp + sub esp, 72 ; 00000048H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-72] + mov ecx, 18 ; 00000012H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 950 : va_list args; +; 951 : jint result; +; 952 : va_start(args,methodID); + + lea eax, DWORD PTR _methodID$[ebp+4] + mov DWORD PTR _args$[ebp], eax + +; 953 : result = functions->CallIntMethodV(this,obj,methodID,args); + + mov esi, esp + mov ecx, DWORD PTR _args$[ebp] + push ecx + mov edx, DWORD PTR _methodID$[ebp] + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+200] + cmp esi, esp + call __chkesp + mov DWORD PTR _result$[ebp], eax + +; 954 : va_end(args); + + mov DWORD PTR _args$[ebp], 0 + +; 955 : return result; + + mov eax, DWORD PTR _result$[ebp] + +; 956 : } + + pop edi + pop esi + pop ebx + add esp, 72 ; 00000048H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 0 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallIntMethod +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_this$ = -4 +?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z PROC NEAR ; JNIEnv_::GetObjectField, COMDAT + +; 1248 : jobject GetObjectField(jobject obj, jfieldID fieldID) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1249 : return functions->GetObjectField(this,obj,fieldID); + + mov esi, esp + mov eax, DWORD PTR _fieldID$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+380] + cmp esi, esp + call __chkesp + +; 1250 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ENDP ; JNIEnv_::GetObjectField +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_this$ = -4 +?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z PROC NEAR ; JNIEnv_::GetIntField, COMDAT + +; 1263 : jint GetIntField(jobject obj, jfieldID fieldID) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1264 : return functions->GetIntField(this,obj,fieldID); + + mov esi, esp + mov eax, DWORD PTR _fieldID$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+400] + cmp esi, esp + call __chkesp + +; 1265 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ENDP ; JNIEnv_::GetIntField +_TEXT ENDS +; COMDAT ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_val$ = 16 +_this$ = -4 +?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z PROC NEAR ; JNIEnv_::SetObjectField, COMDAT + +; 1276 : void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1277 : functions->SetObjectField(this,obj,fieldID,val); + + mov esi, esp + mov eax, DWORD PTR _val$[ebp] + push eax + mov ecx, DWORD PTR _fieldID$[ebp] + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+416] + cmp esi, esp + call __chkesp + +; 1278 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ENDP ; JNIEnv_::SetObjectField +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_val$ = 16 +_this$ = -4 +?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z PROC NEAR ; JNIEnv_::SetIntField, COMDAT + +; 1296 : jint val) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1297 : functions->SetIntField(this,obj,fieldID,val); + + mov esi, esp + mov eax, DWORD PTR _val$[ebp] + push eax + mov ecx, DWORD PTR _fieldID$[ebp] + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+436] + cmp esi, esp + call __chkesp + +; 1298 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ENDP ; JNIEnv_::SetIntField +_TEXT ENDS +; COMDAT ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z PROC NEAR ; JNIEnv_::GetArrayLength, COMDAT + +; 1589 : jsize GetArrayLength(jarray array) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1590 : return functions->GetArrayLength(this,array); + + mov esi, esp + mov eax, DWORD PTR _array$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+684] + cmp esi, esp + call __chkesp + +; 1591 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 4 +?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z ENDP ; JNIEnv_::GetArrayLength +_TEXT ENDS +; COMDAT ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +_index$ = 12 +?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z PROC NEAR ; JNIEnv_::GetObjectArrayElement, COMDAT + +; 1597 : jobject GetObjectArrayElement(jobjectArray array, jsize index) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1598 : return functions->GetObjectArrayElement(this,array,index); + + mov esi, esp + mov eax, DWORD PTR _index$[ebp] + push eax + mov ecx, DWORD PTR _array$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+692] + cmp esi, esp + call __chkesp + +; 1599 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ENDP ; JNIEnv_::GetObjectArrayElement +_TEXT ENDS +; COMDAT ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +_isCopy$ = 12 +?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z PROC NEAR ; JNIEnv_::GetPrimitiveArrayCritical, COMDAT + +; 1788 : void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1789 : return functions->GetPrimitiveArrayCritical(this,array,isCopy); + + mov esi, esp + mov eax, DWORD PTR _isCopy$[ebp] + push eax + mov ecx, DWORD PTR _array$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+888] + cmp esi, esp + call __chkesp + +; 1790 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ENDP ; JNIEnv_::GetPrimitiveArrayCritical +_TEXT ENDS +; COMDAT ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +_carray$ = 12 +_mode$ = 16 +?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z PROC NEAR ; JNIEnv_::ReleasePrimitiveArrayCritical, COMDAT + +; 1791 : void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1792 : functions->ReleasePrimitiveArrayCritical(this,array,carray,mode); + + mov esi, esp + mov eax, DWORD PTR _mode$[ebp] + push eax + mov ecx, DWORD PTR _carray$[ebp] + push ecx + mov edx, DWORD PTR _array$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+892] + cmp esi, esp + call __chkesp + +; 1793 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ENDP ; JNIEnv_::ReleasePrimitiveArrayCritical +_TEXT ENDS +END diff --git a/cpp/nativecall/Debug/IntCall.obj b/cpp/nativecall/Debug/IntCall.obj new file mode 100644 index 0000000000000000000000000000000000000000..f33470ab04097ceee39134613ba1da012943d022 GIT binary patch literal 27787 zcmc(I3wT_`m1e11YRRpqW%>P}F@_0CEQ}2pOo(;WeOqeWkL!L&G7((2rM4|0sfE!z1LeA)ADd2Z?7OJIuyp2yuv$FbN3>!(>Um%)}6~!2?;Cjb||5dhq^# z)xEcGx6}&u!nfC7m+DrXbLyN^=bSoKxBEI;wNB&$U7?d{A*!l`yxIpRas!1Ma_UZq zU!d|xjeTeR^|y%j!Q8H?J?m0-&-*VB;$uD`YBs8tW%$!AS~}Ycx%~wj2!BWL`8U91 zHwp0-d}{G8&|>T?r*{N!KS%$)7b|2B{&cs@ruR5_dk`>twg~Z&D}^vbMA4fV%oef= zm*q-)uH0I@XRV`ULr3|z(_SI^0QY>Sf?a_>bB!B8`|pB6w1D%0DEzWsoC4xd->sl?yofNO!We@cbpswD4D z^t}L>&Z~sz!KV_vZvpNm^k2LU65lVU@RRf0Zc?gaV@5&0_$^w zLxt?v;6Q$?Ff=xmL&N^@{6t}kc~$m?tT~V$HFMdayg8OF4Be0$$c~Jdk+DLMe{=hD z15m8S!8QzADi#7(Rg(0y(in%Mer9YG(m>SKE6($4VE0D?+z}TM2er<4cXl!V* zFp(|fC;DSI1{}ElRDO41Uv?tbAD3K`qyEW>f&PK<@%|8(s(y>-_WZ8lqt%OAxZu@@ z1`K)Wd8%xW4Gm1>CqXFiuH^ZFO&izm8Y%>W7X~l5Adna@42=%m1TF%>{OI`5NN!?a z-=KKASrr2#q-jj#_e^9*17VCa*wf z4r`MrvK-Hur?+uF`@v;6`HoT_f2XJyjkJAyU@rvOff)+t->KoGss`Ut>WD2}R|nP) z%xPfrT5u#DjAlYQlrV>B&Wjlf2m8+)TT4e>*l8oMzE2=xyzM^i1RjJUF+RBK?H@qJ zw;Kj7-Ox_@LYz3dRCroGzlia)DV5H2nwfY^OQyQD=yI#0O0>uh>9Q$3*`p^HTU{Q} zAiFG#byl-itSrYc;|a4nsi!j0Gza{H8qi24`gWKg985*7)|XiwRiasSbm{5NOgOA3 zmsmX>(WrW?0asY~E=M+S2f33fF()EfpyvXhgY`TR&O zJ2qDr)|%X&+{DTftR{tZV@XXi@-RNOrC$>1-U!?Xy_LpEV_Y3(;qhwf@jP?w3>C5KWt*L_Cd2PU@U4 zHdl#-XpSa&^%VYSX+0j?5kTKxw{b$2CdUWj`NGidp#dz=`LXnk0iul$*Z|%+0V4SUn~mx@+34OkHb^5UqcvjX9Ahw>*p(f)j@Ea+ z6sH+bY-KVqk}Krw9#}bgQn|4~yJw|^;}NasN#+J}NTTe{HgvXuV3nxvgUU?hh<2;T zY7IssdK@0+Z8^0VyP-mMPtph`qB@edl-8xMLr3irAy%7RdR$LNf+muJP$b@ECKH)- zB(9r=7D=uER3o4knZZOXW`;F5t(gdiQ+hhpjJ|JzbRGKQX}vGK1PxE4q1lW@LQzxt zeMnCQms>9!VG7S1sLh1nNFBVJsb&{I(dyts`rqpQA+hZpw|DN>abDTc%&5j4X|T?eztOfbC~eGAaH#DuQQ)Q)&s z>oX%Ea1jYd^dz}`4y0BX6}eqyQCK`D0rvhA2rMp&D`zmRbw>468+!i|y^WZwn4X50 z1QW^7VzfSh)+Ph-%rqi~j^rv8JO|C3zg6>1-?;#yj@HbtqE>+Y4Th)>MZ3~^%%C4G zM4K0=el3~Qc9@ZPII#vzCjhq8?2ARxE=@<`X=p)`FO+ix5+8%^~dNYBRsAd>?h{pX402i6zXadW~VEiz_PW=xb5|)i&^Y zG@p&ds9H-WV$>FIYI=j+T5_#*w=$&%Gs#GLhjh(k#7HNSGAbq$QS$O7taJ<0k(eHi zrAZ#hU`z>`Wx0WV3*tny7&(YQ)`Ibor*tk^I;mP6h^t;SBGx^9uSlm$IdD-s1@d zydVq+4wc?v=qVCxrQE}lLpS9(;TrC0hX?ahyGGIeGH)_q{EVGvL zaepqTuPuo~P8Jq*EjyI-VoHjc4{BJ%jF6VrDBLeWpqk2{dF27Jz(gvrf2d#Q4YQHI`*2_`rKy884dMC_@L;}F_85vqSS>}vaV>WaeZVu255q)fGlt!9Lcd_wz z(3`U6WQN=RI9;j(qcy?QRN^ZWRVqx{3-S@0`Z%fcW+ggPpxze6Y-*tprrbz%>w4ON z!*an`kIrVZq`8+AF&aWp1R=*XIZa!XjTiP#M+!cm7LvI z7Q4H7zqNQDA%9rzOZn3nKb{3Q3#oZ`{OFZ)0{CisEZUqe6iFG85GVA{F&hhTu#!Xs z*P_(OOK7Rb6h{+XG$u)b9FRhUJor-4bbf*7n^ZUF1mF_r*ML8pDX1|qYE(%_=_>X38dwU(8z2n^&FKZ z?!@Tf0ql%ump_O88hWu1+M%8c^G1-DX&N=ArGwp$15tTXkYYhBX05d}0h(RYY^$TQ z)^>NnlQlWv(wC!JyekrNv?0SHG{PC)3SJt`VH_ypk(u-ca`=9FP9%tgS1k_GpwGjI zN^!v*oE_d{c7i)d2alXYBjN3gO`{(D0HJQ}z)3yQ4*W73Pj_eH+c+iFq#RL8BIoiP z+&3Fx-HgO|4ktA+=ODdgcB+h7xsojeKMg%vGNNIN$2EwMM+nJ<&sMx+&E>0MFEft- z*l2O$nH9K6=MhdIvWZ}KBC(CGb`~1f0D4)};A$NS>evB9;?5LmjE^e;(5isv1CA*J89*`c8dBrN6M_KI-Qf$oP@`#v%z0Nxd>W`-~vcAt?!?m_3m6 z6Gog`SQrBi$#NO0=WfYbg}7IG5pAnV(hu(YT!{yx1_{-GkaFFpIgX55;b@u~!x~4| z9h5nbbX|@{qSfzimwa5`l)!flN~Gou=wCtcf+X;o{{y%=_E<&cbt z$(T&O2>u0!jZmkGFeDx|s18O2#^q{`S+%q&YnR0Cz=IQjvR~O^dHgF1nu(V0GT^ZAfyjXK^k8w5!|MyISy4*i#?pZe$u9DT_)v$Y1G-# zl;-mfAnTWt7L2AMA!`3N;MAC1nMjBLKeqs^w1ohiXiPh1nY#E1?#gu`%}g$U&dH^> z$&eH1XqRNH5eKJTS}c=>;RL%W6*XBiWg@HOs7z@W&zaFO;brQ-gyc&y zXPNoa1i7Zw?HefI_{}U(M~?xXM@m7B3!)YE+3_uQxb}{ePbW8+18g3+{h)@v2r#7~ zF6Nw;6PQSUaX&&QVhE$1!)>UUgTQHurMfy3eYS}b@jf*B<5>7*N+Wl;ZSgd%Vc-UpziS}Ri~ zIQxByDN67LCBQzN3^6RgXb}^rP-iN9Lm%$a|fg=F1?61|LuJ%`_R7 zZYZ6S0V4wZW=Baec_2*|cqrUp9R!>70tW9jU||)UB4LB#CNJ=gheELui8^*H-*+xbwNR8a}6sG_Og(|%R zyzuQF&rg~%DVDpKDRXi!9(@y+Sx`-?8#xr0hBrwaZo<{n-s^o5Z27vur`n`^0=M^a-)Des#5y02+u@n5T$8M`Gng7q ze+sy!G8}@a!y(7(rOYYQIvY?7Q6gr0&3M`keb~8OFV*)Q5LSm7wiPfn<&F;L;US%y zTIWcpmySi2>nIqH!#QpHL7CI0#*$~noB^7ip9!6EO*Xwt22p3jOSYJp~KKnC09%2udwa#hWcO(}WqHCsxVSPYXd>Jokt z+{QdC9H-)aXh)`BJkn%i7<3v;wH1|l7uh2l&3YfQCV5OHR~pWwJhg~Q2O$`?{Q$$Z z3OiSB%a~NsfMhtrep=;vH1awe_~MD5Ss>aj7aDVTqH%UiwAW$hl%L4%$+@)TXo!G3 zO}hYqOCey%ifS3$pP~O;^an~3QtJ_h`!tNguLWR(``C{{wqT|a6M~2d3^X{B;c*_9 zSE(N!h%socoF`^FTQQh8Q_i9lasc`l2A~}>0&^{1HP?b?A9Dr(v>YQY=bXm6aL&n< zHIa;5txgfcafS%0xfUl|oO4dX)8HEi&p0)vZm+~0k~w@;2Va>Xcm@r%{FX^iOdcx# z0{06{gnXSV1GV3ZA?3zZeSt)#MHIf7!k1_l3y~|^Cv}<6S$;;lZU9ajb71?x$@YEP zwe*(^{Dse*769@rw~_Mk7@mNr2N3G{8J8fAumFh}rpelxR0Fdf!QT!M^x7)4sg)U< z*>uv0xiXYdSR)clQ$Jiz>g*`OY41b>rk%$e&Pf7Q+@SVUDqxV2lT@76iDilA$(g5X zE-asUjdLQ;jScSLImGK60`{SYLd^Aov`7X9_-Ht3FF7=-$PE`_s^JB2)6m6@ zjdf^4PI$Ij&SLR!04EM9E#}NHeFdk_iYID@IeT41Eigkvl{_9c1SkCze}TpP5eLaR|L7h82oS z&_^%`mms=^E8FKP)*@3Q*BVBv;qqAzx3)cq2J#cM`9K40GQf~6K1?uW;`9`HYuLMk zoj-D5Bix=miQ6UigU(ExbLn2YzwbcHb4yO8FC&vM3fzI)8oAS@sXYN$x$an-Hl6}d z(R9`7VQiMDLgvaiP>_i-*`Z6&wxLw|4ku+HmU`$ZgRd>5GIDQADgjbqYQ~w73wbPv z2gk_-wi7B9z=5Xi!DNoP9UjtHZvPm@ZR8hMo?_bWH!DS^#_t1=JowYp z$$(?i`#AAxO>-^ic(|`N^yHdWSItPzApT7dl0jVVjJD}J@I)0!KaY^HL~|&D*F&z5 z&U3d&h#G=rB7Kr+FeSxqLikOpQ^qAn(r!xX3L(L;JA`l!pk^(p#i+k;fC!wScn-vY zeZ8`u6yc88Qu2Wch2^Bw%AEPqi@E+j1ni}@&Dh@WI#Q&SG|+FbsR&24t`s%FWv-g@ zLl->=3MzB6-HWck%(baBai!lgo|e0U45t*TMp_bi=B}(}cwa7i9koUa@zJN$LB)Rs zjT+O4h2s>TGg=2{kq13gDxv+`aJnCt>!(8?8f4I-aZ?94ttmMbX8Wf>ieIF1o_gqg z@zYojmIkvyruJKBNO+r(PtinqQ2f#veY^i|ehLU)+IO zyKKALs`rNP#Szplk!?>}HNW@`YMW%+Z>^eNoJ4J-Y{M@=WX&&@qjsTe zTW!_+ViRf`WZPz|<`-$yE|zV5R?RQ2M{T`qo3d(taXV@k$hNzznqOpQUODhecdDoN z_L~nq${9WM6s|vh{R^lHVYA+9(s+l?7{mz>cX z0Iy(Y^b_W_?>lg$`-)d2%*^kud7@4%2NHGb6X&7)GCpl$GfMs##V6j2a$~LhBzEXV!HQ>RW*(M`Kc zzK*vLT_>zAUw(?;Pm@2|03>;?7wfE=oU>bAIfz?M+qcs|dX&>@&D@OM;>-i)?1%aZ z^og0+$?rbz+5Qsi2aZ%v>tCJ8e04f=;=s)(#MD{CVy^;H)92uCI(%$%4UqMd-#zLv zhC$_oO`>5YbMnByR841IdwIc({@Q_;s-{ui{F-RK?Z0_A-fP=uGA&8lBBu4@2W~zt zrfP@9vD?va+t+c&zRo=b7CwBqu-37s%Uz2_pkqQI`->RQ@=j;!FlO5-+C?kT{Inke9l(lbF-A#Ib2IY^r z4@_sCbwOw9k~Uj2v1g~Nl!&ZSN6#L689X{le$Fw65+xT0oz{P5>*!~az|W3-ZGHl4 zIZJK=PuT>Xk_4W5d1Rj94M!W#m1+1%x7eSbiG6-Lc4Q{=Gq3+@Mn5v$ z0_&W~oM5&3W2dH$9J}H_PMvayHn@!T@TttW3hZprs!=a2S?;XeM^(irC5K z+n?v;WDbE3x7R6KuQ~Sk+*4=iacZSKB}Id^RlFJ+${d2>&NSSqOv#$|W5b|X5wH2y zZ5(p8e@yF-I08Q62xyPi1G(VaGi|p_XC9u>AD*e(Zqcwua{Lft&Za&Sdw4o_-%RE{ z+pMaOeGmGwksm3y@okw<1(*9scPARv z=#OCuyyXbvv}+Y?kZa#h(AXy4!!B9NpxlCwPwHPv~%s+hMA=JoOoA^i6n5X!}3l7}Bp~n2kCp?I^pO$cb)D+K4QL}hKP3hn= z)D-t&)D-u7QRBMq6H}-ujN4FC+&_q#;{Lxoy+3h!e~+5t{ue>HKnTsSnd_Zg{U#D@QF)NQ@tIi<>VL<)D#Cjs3{I|s3{IU;M6{Xn#%9) zKuu+EA4g5)cV9s5u%yQyRjc0fagVJ#J}SSfmR3vqT(PxlTNa@?7y_l;;U9{qGWgMEP#909Ms5)}g#mY(}|3BvD=@u0^>~WKmu$ z{sQGC;vSTjiqE0kEbd2nx%eK+E5x%X-y@Eqyi)uY^_2m_T`rxD(~I;)^Iv@gT~b;&&*s;y+Lh2=4!KVl&D;B876V zFi{SPyHO5{2T+cPqbNtk36y!U1oJU2)}p*#T#a%fSSk%G-)I~p__2MGrD;6oA zJapK@U4a`q05DoMuBCu}3DDgAHaOpa)h6b|q19VBF9L@K(%_u8&Vj>7MvuVNigA8z zaaCK$jgA9+G1`uzEr5Q%^OeY1BXd;x4=$?dIbcw6RruO#Q2|$?myU&t3V4=7fjug~ zC``ek5;y_WUBXf?M=WNgUMz0QIcAQ= z;c!t2j{s%161Jn4o{EbG_^?ISi@jkvJ#KpGuomdSGEjo^6F@(stJ+Jl<`e%`Yx>+O{}tgH9XQc*V=7oVNR%wx^u7 zpE+$yFbQgm6;{nJu5jA6I&Hh1wqd7Do_B<>ao&FW&5u305IV57%{!)JCufdx!-lOg zGVYTzo>Rs$>x@GlW`ta6T(w+G)q=GZL{yE5o2pmIgv}!^D~o**tDouIQbr(oRkd2* z$JnwZJcQp$@#l05a3S<|;6p1Y2Dkw3nqd(PNj%`FF6!Nb~I;CIC)YN z&YE@LGoJ$FDGn8YJMUPtE7ZFDWnoT2;!>7oYhtWb6O8pz0z}-nAOkTcNdkg z&{0B~Uu=%&_MN5<7>Q-{2hAFM!TF|}?DH3D#XCAFqfr2(l1HT!)+(QZ-LALc2nA*# zO#-JG>WmB8siS!mEY09h?1wsY44jnAI{5k?lS`!2qoNHX#2gO}}Rz zP4^Tvy`)6bk+H)62QAB#wba)sq0%yIXX5K0K>BcczRrzvsjpvIrbEN(r>}pssKcd> z4!d#%6)nU3ZT$bEw=?r&2<1=iYvnKHBO%-0$*a;2YiFXLJ5O6bJiI8?&z5=gb9+%g zZEpR*#NKJ;kWr-^*4~10c+84ZHk@E1Jz=gkv+&g2pPxrT4cJ}VVGnP*vH~DaENlg7 zsCfWY8t&3oKYQ;kDyV2ccn{AzYe0;L99YIfe1Xq4DDtj!#@d5wy}3D(|%CdzjM zcRezXHtKM+W$U1rm+|=2)&^bCgQKicS2L`B_Wo;88*ALLNV%HSi9V9!+px}1DLnI0 zO0iQknoAA#UAg_Xn#i(J6KiLprv2D)Rx+Bo)xsFI7ffsY} z#bi=b!3op{vLk1xs-pey7>4Vc{0i#OWH3K|qpd6Qt#rlOThP^<5&Q%5=xgo>&Xa3f zUn+t}%k<@rMv0=n&U5sY%;AkSleu?TXM7Cc8<1|uEfnpW7FRurckI|oq%cZ}toh+1 zJeFM|2Jt>p#A#s;Z0R2?c?;a6{T8@v$y?w?Zwxqa{d{?wd<$IhU3Jb|;N%PT`t7$Q zweQBe)i4gV^yVoX68qlv*OVddbA!;%_dbi2Tckn0OE}qF`!KmoTC|r&`EU5sNlfyxj9e zX}q2zC>2-4s=?jyA9dYZ#9+-mUxe^__(Xwky1mJB!(laFpTA-^y}#`Gq;+2-HAc>f z$@k>)Y)oB$Z&&bFaq_CuVrxtu^;oS6W{uQ|YEmuloz?QbSuKAttA&ZIeJMJJXSE!i z)#6p45)m^vnj1xQu*k?6biMu8hjy=rkK}m$Fa2v@wdGVTrRCWcWn!r+A9ATnQg+z} z=R(=Ws09&|e{I{~*_MQHY=hb_V!dKvsXuPpkXGg4yNFj*1&#*i!0}ufXrg{J&rD=AC6&mM^na`mz_kJZ`;pl6{l?L%T-#h^zQg$o}E6q4vF{ zba-c4`l%DpPZc#l4mv~X&=J<_(ik~Z8hhQsQr>B6jD90w9F37y5$g?SF3^maS$qfe z0^EB&A4F+`)Jctf;o4T)35bHr?M;5%dp+ct8uR{kb5`MB+ce!w*wX8x7HPkfl$;Zj zZ)?s;K)0l%tR!7Tp>XYyrCU-7<48(cMXbdZmP9I%v>r`f&mAajN&QmN_x=2Sx0|Bh zEopVUcc-l9F>`@;%ZM64EUxDJx0&=$4oAL|amN zl7w+2C9NV>q@tvafb)6|p|mA!kdnUnjgM1&*X5S93GH5wfs%9jhwuE=bqfF1E5_Hl zP^{`7Ez(U=QgTjAzTuiDXr#J z+LAU&N!Pr(PAxYMnp@HqiM3N=`NWGCrGKjMe=zJ>?jSgo|74BcA|)l~JMrPWw{Md$ z?l~o8CF%7R)*TAQTJ<=m62_5qr`=LTKyC(#ms?WiTUftP+LE?NNx%MBG+M-9%`GX@ zN3UlmO6HIEY+ib^!au9|wX(GmAY#ZGy;Vv|&UfO&w}O8fe@o|-l$E4^Yhisx!MG%q zFeQ=}u^y`^=_1hadcK9ymb6t$`cHrN_+~kTQ@ABNj*k{-1Zsjn&+OHz`OFpi|8Rm6J1!jecO5os}+yq-^> zv?Xnml795oL7v&WF1Msh&|dV@A735bukdfv{SUcNtmo78zER63`m ztR#Ka;`whCj7w4pQzB^*>t8EMx)gN0o_kQ*k}i>w9)39SH93S+xFuyi?q$H0bJ}>< zhL0)y_v^1RxRqTitq*cUvv!bL7 zAYKox$d+`Olr;FiZ`0%uPT`i6*-BB;3(q#OSP_5K(H|+s94uCPtt$x>^?VVfE$Ip=X{zh5=ZU?mBo;#! z{j~js?}Zh9)2@h3k&JtI_23+=|kcbd{8J_2C8vE7#?oQ|_~hetO{hi!nLGe|}>511=P+`j{o@ z8Yw9`r=RkT{lAwGZb?a5NqVKl^DzbEl2pPtl9E;tYimVG&jOs+^I4R(q-&(4N8UL6 zgdD;t+>!>+T9ovfkMsXbApR?xcfaZ&I2Dg&Q2{9_IVX4gzXXm;7`LPWv{-&>@%--! z#wDqQDUq~@^=3s$&juZ@=YEv7qyZ`EUH+vi=%GhlZb{dospzNQ{^TGgiukK`IhR$e5d|M*c!QJuJi}(%DtrwMl1$65= zP3wS)H$uhGaD*y$zUb6p9mjTbY}fG8h@zs5&JY3ZF9VgpT{Q=w^Ys@uB*p_pd>;ev zr0eJ?!J=6f^?fyla)159O+;6G%|(SA@>sLvdk=10OQs_3tWk*$CCB8OVoFezl=GmL zKErn7&f<6@gm?QP83#HB4%0PDaOW7;v2Eg&KKU#`g$I@B+dbq43wO>j=R>^8VpcxW zP*224237pZ6ZVb{3pP=F4WaeCs05{qO^0VWL`R1`;@po0$|xz;t>Fz#CkOLBS}4IU J!|vnI{}=y08ma&Q literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Debug/NativeCall.asm b/cpp/nativecall/Debug/NativeCall.asm new file mode 100644 index 0000000..e8e2af8 --- /dev/null +++ b/cpp/nativecall/Debug/NativeCall.asm @@ -0,0 +1,1492 @@ + TITLE C:\Documents and Settings\Administrator\My Documents\Software\NativeCall\src\cpp\NativeCall.cpp + .386P +include listing.inc +if @Version gt 510 +.model FLAT +else +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +_BSS SEGMENT DWORD USE32 PUBLIC 'BSS' +_BSS ENDS +$$SYMBOLS SEGMENT BYTE USE32 'DEBSYM' +$$SYMBOLS ENDS +$$TYPES SEGMENT BYTE USE32 'DEBTYP' +$$TYPES ENDS +_TLS SEGMENT DWORD USE32 PUBLIC 'TLS' +_TLS ENDS +; COMDAT ??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_08JJOG@function?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_06CODG@module?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_01FLOP@I?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0P@LKIL@functionHandle?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0N@EFAA@moduleHandle?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0O@OMHL@lastErrorCode?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_01PGHN@o?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0BB@LLFN@java?1lang?1String?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_02LOEJ@?$FLB?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_02BENO@?$FLC?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_03KJOK@?$CI?$CJZ?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_0N@KEBP@booleanValue?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_03PPCD@?$CI?$CJI?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_08JCMA@intValue?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_04ECLF@?$CII?$CJV?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_06KILP@?$DMinit?$DO?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ??_C@_04JFOE@?$CIZ?$CJV?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewStringUTF@JNIEnv_@@QAEPAV_jstring@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ??8@YAHABU_GUID@@0@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_NativeCall_initIDs@8 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_NativeCall_initHandles@8 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_NativeCall_getLastError@8 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_NativeCall_destroy@8 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +FLAT GROUP _DATA, CONST, _BSS + ASSUME CS: FLAT, DS: FLAT, SS: FLAT +endif +PUBLIC ?fieldFunction@@3PAU_jfieldID@@A ; fieldFunction +PUBLIC ?fieldModule@@3PAU_jfieldID@@A ; fieldModule +PUBLIC ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle +PUBLIC ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle +PUBLIC ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode +PUBLIC ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO +PUBLIC ?classBoolean@@3PAV_jclass@@A ; classBoolean +PUBLIC ?classInteger@@3PAV_jclass@@A ; classInteger +PUBLIC ?classString@@3PAV_jclass@@A ; classString +PUBLIC ?classByteArray@@3PAV_jclass@@A ; classByteArray +PUBLIC ?classCharArray@@3PAV_jclass@@A ; classCharArray +PUBLIC ?classHolder@@3PAV_jclass@@A ; classHolder +PUBLIC ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue +PUBLIC ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue +PUBLIC ?newIntegerInt@@3PAU_jmethodID@@A ; newIntegerInt +PUBLIC ?newBooleanBoolean@@3PAU_jmethodID@@A ; newBooleanBoolean +_BSS SEGMENT +?fieldFunction@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldFunction +?fieldModule@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldModule +?fieldFunctionHandle@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldFunctionHandle +?fieldModuleHandle@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldModuleHandle +?fieldLastErrorCode@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldLastErrorCode +?fieldHolderO@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldHolderO +?classBoolean@@3PAV_jclass@@A DD 01H DUP (?) ; classBoolean +?classInteger@@3PAV_jclass@@A DD 01H DUP (?) ; classInteger +?classString@@3PAV_jclass@@A DD 01H DUP (?) ; classString +?classByteArray@@3PAV_jclass@@A DD 01H DUP (?) ; classByteArray +?classCharArray@@3PAV_jclass@@A DD 01H DUP (?) ; classCharArray +?classHolder@@3PAV_jclass@@A DD 01H DUP (?) ; classHolder +?methodBooleanValue@@3PAU_jmethodID@@A DD 01H DUP (?) ; methodBooleanValue +?methodIntValue@@3PAU_jmethodID@@A DD 01H DUP (?) ; methodIntValue +?newIntegerInt@@3PAU_jmethodID@@A DD 01H DUP (?) ; newIntegerInt +?newBooleanBoolean@@3PAU_jmethodID@@A DD 01H DUP (?) ; newBooleanBoolean +_BSS ENDS +PUBLIC ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetFieldID +PUBLIC _Java_com_eaio_nativecall_NativeCall_initIDs@8 +PUBLIC ??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ ; `string' +PUBLIC ??_C@_08JJOG@function?$AA@ ; `string' +PUBLIC ??_C@_06CODG@module?$AA@ ; `string' +PUBLIC ??_C@_01FLOP@I?$AA@ ; `string' +PUBLIC ??_C@_0P@LKIL@functionHandle?$AA@ ; `string' +PUBLIC ??_C@_0N@EFAA@moduleHandle?$AA@ ; `string' +PUBLIC ??_C@_0O@OMHL@lastErrorCode?$AA@ ; `string' +PUBLIC ??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ ; `string' +PUBLIC ??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ ; `string' +PUBLIC ??_C@_01PGHN@o?$AA@ ; `string' +PUBLIC ??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ ; `string' +PUBLIC ??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ ; `string' +PUBLIC ??_C@_0BB@LLFN@java?1lang?1String?$AA@ ; `string' +PUBLIC ??_C@_02LOEJ@?$FLB?$AA@ ; `string' +PUBLIC ??_C@_02BENO@?$FLC?$AA@ ; `string' +PUBLIC ??_C@_03KJOK@?$CI?$CJZ?$AA@ ; `string' +PUBLIC ??_C@_0N@KEBP@booleanValue?$AA@ ; `string' +PUBLIC ??_C@_03PPCD@?$CI?$CJI?$AA@ ; `string' +PUBLIC ??_C@_08JCMA@intValue?$AA@ ; `string' +PUBLIC ??_C@_04ECLF@?$CII?$CJV?$AA@ ; `string' +PUBLIC ??_C@_06KILP@?$DMinit?$DO?$AA@ ; `string' +PUBLIC ??_C@_04JFOE@?$CIZ?$CJV?$AA@ ; `string' +PUBLIC ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass +PUBLIC ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ; JNIEnv_::NewGlobalRef +PUBLIC ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetMethodID +EXTRN __chkesp:NEAR +; COMDAT ??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ +; File c:\documents and settings\administrator\my documents\software\nativecall\src\cpp\nativecall.cpp +CONST SEGMENT +??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ DB 'Ljava/lang/String;', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_08JJOG@function?$AA@ +CONST SEGMENT +??_C@_08JJOG@function?$AA@ DB 'function', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_06CODG@module?$AA@ +CONST SEGMENT +??_C@_06CODG@module?$AA@ DB 'module', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_01FLOP@I?$AA@ +CONST SEGMENT +??_C@_01FLOP@I?$AA@ DB 'I', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0P@LKIL@functionHandle?$AA@ +CONST SEGMENT +??_C@_0P@LKIL@functionHandle?$AA@ DB 'functionHandle', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0N@EFAA@moduleHandle?$AA@ +CONST SEGMENT +??_C@_0N@EFAA@moduleHandle?$AA@ DB 'moduleHandle', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0O@OMHL@lastErrorCode?$AA@ +CONST SEGMENT +??_C@_0O@OMHL@lastErrorCode?$AA@ DB 'lastErrorCode', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ +CONST SEGMENT +??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ DB 'com/eaio/nativecall' + DB '/Holder', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ +CONST SEGMENT +??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ DB 'Ljava/lang/Object;', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_01PGHN@o?$AA@ +CONST SEGMENT +??_C@_01PGHN@o?$AA@ DB 'o', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ +CONST SEGMENT +??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ DB 'java/lang/Boolean', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ +CONST SEGMENT +??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ DB 'java/lang/Integer', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0BB@LLFN@java?1lang?1String?$AA@ +CONST SEGMENT +??_C@_0BB@LLFN@java?1lang?1String?$AA@ DB 'java/lang/String', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_02LOEJ@?$FLB?$AA@ +CONST SEGMENT +??_C@_02LOEJ@?$FLB?$AA@ DB '[B', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_02BENO@?$FLC?$AA@ +CONST SEGMENT +??_C@_02BENO@?$FLC?$AA@ DB '[C', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_03KJOK@?$CI?$CJZ?$AA@ +CONST SEGMENT +??_C@_03KJOK@?$CI?$CJZ?$AA@ DB '()Z', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_0N@KEBP@booleanValue?$AA@ +CONST SEGMENT +??_C@_0N@KEBP@booleanValue?$AA@ DB 'booleanValue', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_03PPCD@?$CI?$CJI?$AA@ +CONST SEGMENT +??_C@_03PPCD@?$CI?$CJI?$AA@ DB '()I', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_08JCMA@intValue?$AA@ +CONST SEGMENT +??_C@_08JCMA@intValue?$AA@ DB 'intValue', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_04ECLF@?$CII?$CJV?$AA@ +CONST SEGMENT +??_C@_04ECLF@?$CII?$CJV?$AA@ DB '(I)V', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_06KILP@?$DMinit?$DO?$AA@ +CONST SEGMENT +??_C@_06KILP@?$DMinit?$DO?$AA@ DB '', 00H ; `string' +CONST ENDS +; COMDAT ??_C@_04JFOE@?$CIZ?$CJV?$AA@ +CONST SEGMENT +??_C@_04JFOE@?$CIZ?$CJV?$AA@ DB '(Z)V', 00H ; `string' +CONST ENDS +; COMDAT _Java_com_eaio_nativecall_NativeCall_initIDs@8 +_TEXT SEGMENT +_env$ = 8 +_cls$ = 12 +_Java_com_eaio_nativecall_NativeCall_initIDs@8 PROC NEAR ; COMDAT + +; 71 : (JNIEnv *env, jclass cls) { + + push ebp + mov ebp, esp + sub esp, 64 ; 00000040H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-64] + mov ecx, 16 ; 00000010H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 72 : +; 73 : // NativeCall fields +; 74 : +; 75 : fieldFunction = env->GetFieldID(cls, "function", "Ljava/lang/String;"); + + push OFFSET FLAT:??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ ; `string' + push OFFSET FLAT:??_C@_08JJOG@function?$AA@ ; `string' + mov eax, DWORD PTR _cls$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetFieldID + mov DWORD PTR ?fieldFunction@@3PAU_jfieldID@@A, eax ; fieldFunction + +; 76 : fieldModule = env->GetFieldID(cls, "module", "Ljava/lang/String;"); + + push OFFSET FLAT:??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ ; `string' + push OFFSET FLAT:??_C@_06CODG@module?$AA@ ; `string' + mov ecx, DWORD PTR _cls$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetFieldID + mov DWORD PTR ?fieldModule@@3PAU_jfieldID@@A, eax ; fieldModule + +; 77 : +; 78 : fieldFunctionHandle = env->GetFieldID(cls, "functionHandle", "I"); + + push OFFSET FLAT:??_C@_01FLOP@I?$AA@ ; `string' + push OFFSET FLAT:??_C@_0P@LKIL@functionHandle?$AA@ ; `string' + mov edx, DWORD PTR _cls$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetFieldID + mov DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A, eax ; fieldFunctionHandle + +; 79 : fieldModuleHandle = env-> GetFieldID(cls, "moduleHandle", "I"); + + push OFFSET FLAT:??_C@_01FLOP@I?$AA@ ; `string' + push OFFSET FLAT:??_C@_0N@EFAA@moduleHandle?$AA@ ; `string' + mov eax, DWORD PTR _cls$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetFieldID + mov DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A, eax ; fieldModuleHandle + +; 80 : +; 81 : fieldLastErrorCode = env->GetFieldID(cls, "lastErrorCode", "I"); + + push OFFSET FLAT:??_C@_01FLOP@I?$AA@ ; `string' + push OFFSET FLAT:??_C@_0O@OMHL@lastErrorCode?$AA@ ; `string' + mov ecx, DWORD PTR _cls$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetFieldID + mov DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A, eax ; fieldLastErrorCode + +; 82 : +; 83 : // Holder fields +; 84 : +; 85 : classHolder = (jclass) env->NewGlobalRef(env->FindClass("com/eaio/nativecall/Holder")); + + push OFFSET FLAT:??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ; JNIEnv_::NewGlobalRef + mov DWORD PTR ?classHolder@@3PAV_jclass@@A, eax ; classHolder + +; 86 : fieldHolderO = env->GetFieldID(classHolder, "o", "Ljava/lang/Object;"); + + push OFFSET FLAT:??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ ; `string' + push OFFSET FLAT:??_C@_01PGHN@o?$AA@ ; `string' + mov edx, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetFieldID + mov DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A, eax ; fieldHolderO + +; 87 : +; 88 : // Other classes +; 89 : +; 90 : classBoolean = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Boolean")); + + push OFFSET FLAT:??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ; JNIEnv_::NewGlobalRef + mov DWORD PTR ?classBoolean@@3PAV_jclass@@A, eax ; classBoolean + +; 91 : /*classByte = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Byte")); +; 92 : classCharacter = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Character")); +; 93 : classShort = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Short"));*/ +; 94 : classInteger = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Integer")); + + push OFFSET FLAT:??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ; JNIEnv_::NewGlobalRef + mov DWORD PTR ?classInteger@@3PAV_jclass@@A, eax ; classInteger + +; 95 : /*classLong = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Long")); +; 96 : classFloat = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Float")); +; 97 : classDouble = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Double"));*/ +; 98 : classString = (jclass) env->NewGlobalRef(env->FindClass("java/lang/String")); + + push OFFSET FLAT:??_C@_0BB@LLFN@java?1lang?1String?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ; JNIEnv_::NewGlobalRef + mov DWORD PTR ?classString@@3PAV_jclass@@A, eax ; classString + +; 99 : classByteArray = (jclass) env->NewGlobalRef(env->FindClass("[B")); + + push OFFSET FLAT:??_C@_02LOEJ@?$FLB?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ; JNIEnv_::NewGlobalRef + mov DWORD PTR ?classByteArray@@3PAV_jclass@@A, eax ; classByteArray + +; 100 : classCharArray = (jclass) env->NewGlobalRef(env->FindClass("[C")); + + push OFFSET FLAT:??_C@_02BENO@?$FLC?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ; JNIEnv_::NewGlobalRef + mov DWORD PTR ?classCharArray@@3PAV_jclass@@A, eax ; classCharArray + +; 101 : /*classIntArray = (jclass) env->NewGlobalRef(env->FindClass("[I"));*/ +; 102 : +; 103 : // Wrapper class methods +; 104 : +; 105 : methodBooleanValue = env->GetMethodID(classBoolean, +; 106 : "booleanValue", "()Z"); + + push OFFSET FLAT:??_C@_03KJOK@?$CI?$CJZ?$AA@ ; `string' + push OFFSET FLAT:??_C@_0N@KEBP@booleanValue?$AA@ ; `string' + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetMethodID + mov DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A, eax ; methodBooleanValue + +; 107 : /*methodByteValue = env->GetMethodID(classByte, +; 108 : "byteValue", "()B"); +; 109 : methodCharValue = env->GetMethodID(classCharacter, +; 110 : "charValue", "()C"); +; 111 : methodShortValue = env->GetMethodID(classShort, +; 112 : "shortValue", "()S");*/ +; 113 : methodIntValue = env->GetMethodID(classInteger, +; 114 : "intValue", "()I"); + + push OFFSET FLAT:??_C@_03PPCD@?$CI?$CJI?$AA@ ; `string' + push OFFSET FLAT:??_C@_08JCMA@intValue?$AA@ ; `string' + mov ecx, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetMethodID + mov DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A, eax ; methodIntValue + +; 115 : /*methodLongValue = env->GetMethodID(classLong, +; 116 : "longValue", "()J"); +; 117 : methodFloatValue = env->GetMethodID(classFloat, +; 118 : "floatValue", "()F"); +; 119 : methodDoubleValue = env->GetMethodID(classDouble, +; 120 : "doubleValue", "()D");*/ +; 121 : +; 122 : // Constructors +; 123 : +; 124 : newIntegerInt = env->GetMethodID(classInteger, "", "(I)V"); + + push OFFSET FLAT:??_C@_04ECLF@?$CII?$CJV?$AA@ ; `string' + push OFFSET FLAT:??_C@_06KILP@?$DMinit?$DO?$AA@ ; `string' + mov edx, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetMethodID + mov DWORD PTR ?newIntegerInt@@3PAU_jmethodID@@A, eax ; newIntegerInt + +; 125 : newBooleanBoolean = env->GetMethodID(classBoolean, "", "(Z)V"); + + push OFFSET FLAT:??_C@_04JFOE@?$CIZ?$CJV?$AA@ ; `string' + push OFFSET FLAT:??_C@_06KILP@?$DMinit?$DO?$AA@ ; `string' + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z ; JNIEnv_::GetMethodID + mov DWORD PTR ?newBooleanBoolean@@3PAU_jmethodID@@A, eax ; newBooleanBoolean + +; 126 : +; 127 : } + + pop edi + pop esi + pop ebx + add esp, 64 ; 00000040H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +_Java_com_eaio_nativecall_NativeCall_initIDs@8 ENDP +_TEXT ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT +_this$ = -4 +_name$ = 8 +?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z PROC NEAR ; JNIEnv_::FindClass, COMDAT + +; 759 : jclass FindClass(const char *name) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 760 : return functions->FindClass(this, name); + + mov esi, esp + mov eax, DWORD PTR _name$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+24] + cmp esi, esp + call __chkesp + +; 761 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 4 +?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ENDP ; JNIEnv_::FindClass +_TEXT ENDS +PUBLIC ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField +PUBLIC ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField +PUBLIC _Java_com_eaio_nativecall_NativeCall_initHandles@8 +PUBLIC ?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z ; JNIEnv_::GetStringUTFChars +PUBLIC ?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z ; JNIEnv_::ReleaseStringUTFChars +EXTRN __imp__LoadLibraryA@4:NEAR +EXTRN __imp__GetLastError@0:NEAR +EXTRN __imp__FreeLibrary@4:NEAR +EXTRN __imp__GetProcAddress@8:NEAR +; COMDAT _Java_com_eaio_nativecall_NativeCall_initHandles@8 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_out$ = -4 +_moduleNameS$ = -8 +_functionNameS$ = -12 +_moduleName$ = -16 +_functionName$ = -20 +_mod$ = -24 +_addr$56841 = -28 +_Java_com_eaio_nativecall_NativeCall_initHandles@8 PROC NEAR ; COMDAT + +; 135 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + sub esp, 92 ; 0000005cH + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-92] + mov ecx, 23 ; 00000017H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 136 : +; 137 : bool out = JNI_TRUE; + + mov BYTE PTR _out$[ebp], 1 + +; 138 : +; 139 : jstring moduleNameS = (jstring) env->GetObjectField(obj, fieldModule); + + mov eax, DWORD PTR ?fieldModule@@3PAU_jfieldID@@A ; fieldModule + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField + mov DWORD PTR _moduleNameS$[ebp], eax + +; 140 : jstring functionNameS = (jstring) env->GetObjectField(obj, fieldFunction); + + mov edx, DWORD PTR ?fieldFunction@@3PAU_jfieldID@@A ; fieldFunction + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField + mov DWORD PTR _functionNameS$[ebp], eax + +; 141 : +; 142 : const char* moduleName = env->GetStringUTFChars(moduleNameS, 0); + + push 0 + mov ecx, DWORD PTR _moduleNameS$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z ; JNIEnv_::GetStringUTFChars + mov DWORD PTR _moduleName$[ebp], eax + +; 143 : const char* functionName = env->GetStringUTFChars(functionNameS, 0); + + push 0 + mov edx, DWORD PTR _functionNameS$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z ; JNIEnv_::GetStringUTFChars + mov DWORD PTR _functionName$[ebp], eax + +; 144 : +; 145 : #ifdef _WINDOWS +; 146 : +; 147 : HMODULE mod = LoadLibrary(moduleName); + + mov esi, esp + mov eax, DWORD PTR _moduleName$[ebp] + push eax + call DWORD PTR __imp__LoadLibraryA@4 + cmp esi, esp + call __chkesp + mov DWORD PTR _mod$[ebp], eax + +; 148 : +; 149 : if (mod == NULL) { + + cmp DWORD PTR _mod$[ebp], 0 + jne SHORT $L56839 + +; 150 : /* no such module or DllMain returned FALSE */ +; 151 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + mov esi, esp + call DWORD PTR __imp__GetLastError@0 + cmp esi, esp + call __chkesp + push eax + mov ecx, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField + +; 152 : out = JNI_FALSE; + + mov BYTE PTR _out$[ebp], 0 + +; 154 : else { + + jmp $L56843 +$L56839: + +; 155 : FARPROC addr = GetProcAddress(mod, functionName); + + mov esi, esp + mov eax, DWORD PTR _functionName$[ebp] + push eax + mov ecx, DWORD PTR _mod$[ebp] + push ecx + call DWORD PTR __imp__GetProcAddress@8 + cmp esi, esp + call __chkesp + mov DWORD PTR _addr$56841[ebp], eax + +; 156 : if (addr == NULL) { + + cmp DWORD PTR _addr$56841[ebp], 0 + jne SHORT $L56842 + +; 157 : /* function not found */ +; 158 : FreeLibrary(mod); + + mov esi, esp + mov edx, DWORD PTR _mod$[ebp] + push edx + call DWORD PTR __imp__FreeLibrary@4 + cmp esi, esp + call __chkesp + +; 159 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + mov esi, esp + call DWORD PTR __imp__GetLastError@0 + cmp esi, esp + call __chkesp + push eax + mov eax, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField + +; 160 : out = JNI_FALSE; + + mov BYTE PTR _out$[ebp], 0 + +; 162 : else { + + jmp SHORT $L56843 +$L56842: + +; 163 : /* all ok */ +; 164 : env->SetIntField(obj, fieldModuleHandle, (jint) mod); + + mov edx, DWORD PTR _mod$[ebp] + push edx + mov eax, DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField + +; 165 : env->SetIntField(obj, fieldFunctionHandle, (jint) addr); + + mov edx, DWORD PTR _addr$56841[ebp] + push edx + mov eax, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField +$L56843: + +; 168 : +; 169 : #endif +; 170 : +; 171 : env->ReleaseStringUTFChars(moduleNameS, moduleName); + + mov edx, DWORD PTR _moduleName$[ebp] + push edx + mov eax, DWORD PTR _moduleNameS$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z ; JNIEnv_::ReleaseStringUTFChars + +; 172 : env->ReleaseStringUTFChars(functionNameS, functionName); + + mov ecx, DWORD PTR _functionName$[ebp] + push ecx + mov edx, DWORD PTR _functionNameS$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z ; JNIEnv_::ReleaseStringUTFChars + +; 173 : +; 174 : return out; + + mov al, BYTE PTR _out$[ebp] + +; 175 : +; 176 : } + + pop edi + pop esi + pop ebx + add esp, 92 ; 0000005cH + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +_Java_com_eaio_nativecall_NativeCall_initHandles@8 ENDP +_TEXT ENDS +PUBLIC ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField +PUBLIC _Java_com_eaio_nativecall_NativeCall_getLastError@8 +PUBLIC ?NewStringUTF@JNIEnv_@@QAEPAV_jstring@@PBD@Z ; JNIEnv_::NewStringUTF +EXTRN __imp__FormatMessageA@28:NEAR +EXTRN __imp__LocalFree@4:NEAR +; COMDAT _Java_com_eaio_nativecall_NativeCall_getLastError@8 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_lastError$ = -4 +_out$ = -8 +_msgBufPtr$ = -12 +_Java_com_eaio_nativecall_NativeCall_getLastError@8 PROC NEAR ; COMDAT + +; 184 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + sub esp, 76 ; 0000004cH + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-76] + mov ecx, 19 ; 00000013H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 185 : +; 186 : jint lastError = env->GetIntField(obj, fieldLastErrorCode); + + mov eax, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField + mov DWORD PTR _lastError$[ebp], eax + +; 187 : +; 188 : if (lastError == 0) return NULL; + + cmp DWORD PTR _lastError$[ebp], 0 + jne SHORT $L56851 + xor eax, eax + jmp SHORT $L56849 +$L56851: + +; 189 : +; 190 : jstring out = NULL; + + mov DWORD PTR _out$[ebp], 0 + +; 191 : +; 192 : #ifdef _WINDOWS +; 193 : +; 194 : LPVOID msgBufPtr = NULL; + + mov DWORD PTR _msgBufPtr$[ebp], 0 + +; 195 : FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | +; 196 : FORMAT_MESSAGE_FROM_SYSTEM, NULL, lastError, 0, +; 197 : (LPSTR) &msgBufPtr, 0, NULL); + + mov esi, esp + push 0 + push 0 + lea edx, DWORD PTR _msgBufPtr$[ebp] + push edx + push 0 + mov eax, DWORD PTR _lastError$[ebp] + push eax + push 0 + push 4352 ; 00001100H + call DWORD PTR __imp__FormatMessageA@28 + cmp esi, esp + call __chkesp + +; 198 : +; 199 : out = env->NewStringUTF((char*) msgBufPtr); + + mov ecx, DWORD PTR _msgBufPtr$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?NewStringUTF@JNIEnv_@@QAEPAV_jstring@@PBD@Z ; JNIEnv_::NewStringUTF + mov DWORD PTR _out$[ebp], eax + +; 200 : +; 201 : LocalFree(msgBufPtr); + + mov esi, esp + mov edx, DWORD PTR _msgBufPtr$[ebp] + push edx + call DWORD PTR __imp__LocalFree@4 + cmp esi, esp + call __chkesp + +; 202 : +; 203 : #endif +; 204 : +; 205 : return out; + + mov eax, DWORD PTR _out$[ebp] +$L56849: + +; 206 : +; 207 : } + + pop edi + pop esi + pop ebx + add esp, 76 ; 0000004cH + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +_Java_com_eaio_nativecall_NativeCall_getLastError@8 ENDP +_TEXT ENDS +PUBLIC _Java_com_eaio_nativecall_NativeCall_destroy@8 +; COMDAT _Java_com_eaio_nativecall_NativeCall_destroy@8 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_module$ = -4 +_Java_com_eaio_nativecall_NativeCall_destroy@8 PROC NEAR ; COMDAT + +; 215 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 216 : +; 217 : jint module = env->GetIntField(obj, fieldModuleHandle); + + mov eax, DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField + mov DWORD PTR _module$[ebp], eax + +; 218 : +; 219 : if (module == 0) return; + + cmp DWORD PTR _module$[ebp], 0 + jne SHORT $L56861 + jmp SHORT $L56859 +$L56861: + +; 220 : +; 221 : #ifdef _WINDOWS +; 222 : +; 223 : if (FreeLibrary((HMODULE) module) == 0) { + + mov esi, esp + mov edx, DWORD PTR _module$[ebp] + push edx + call DWORD PTR __imp__FreeLibrary@4 + cmp esi, esp + call __chkesp + test eax, eax + jne SHORT $L56863 + +; 224 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + mov esi, esp + call DWORD PTR __imp__GetLastError@0 + cmp esi, esp + call __chkesp + push eax + mov eax, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField +$L56863: + +; 226 : +; 227 : #endif +; 228 : +; 229 : env->SetIntField(obj, fieldModuleHandle, 0); + + push 0 + mov edx, DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField + +; 230 : env->SetIntField(obj, fieldFunctionHandle, 0); + + push 0 + mov ecx, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField +$L56859: + +; 231 : +; 232 : return; +; 233 : +; 234 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +_Java_com_eaio_nativecall_NativeCall_destroy@8 ENDP +_TEXT ENDS +; COMDAT ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z +_TEXT SEGMENT +_this$ = -4 +_lobj$ = 8 +?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z PROC NEAR ; JNIEnv_::NewGlobalRef, COMDAT + +; 810 : jobject NewGlobalRef(jobject lobj) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 811 : return functions->NewGlobalRef(this,lobj); + + mov esi, esp + mov eax, DWORD PTR _lobj$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+84] + cmp esi, esp + call __chkesp + +; 812 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 4 +?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z ENDP ; JNIEnv_::NewGlobalRef +_TEXT ENDS +; COMDAT ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z +_TEXT SEGMENT +_this$ = -4 +_clazz$ = 8 +_name$ = 12 +_sig$ = 16 +?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z PROC NEAR ; JNIEnv_::GetMethodID, COMDAT + +; 859 : const char *sig) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 860 : return functions->GetMethodID(this,clazz,name,sig); + + mov esi, esp + mov eax, DWORD PTR _sig$[ebp] + push eax + mov ecx, DWORD PTR _name$[ebp] + push ecx + mov edx, DWORD PTR _clazz$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+132] + cmp esi, esp + call __chkesp + +; 861 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z ENDP ; JNIEnv_::GetMethodID +_TEXT ENDS +; COMDAT ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z +_TEXT SEGMENT +_clazz$ = 8 +_name$ = 12 +_sig$ = 16 +_this$ = -4 +?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z PROC NEAR ; JNIEnv_::GetFieldID, COMDAT + +; 1244 : const char *sig) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1245 : return functions->GetFieldID(this,clazz,name,sig); + + mov esi, esp + mov eax, DWORD PTR _sig$[ebp] + push eax + mov ecx, DWORD PTR _name$[ebp] + push ecx + mov edx, DWORD PTR _clazz$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+376] + cmp esi, esp + call __chkesp + +; 1246 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z ENDP ; JNIEnv_::GetFieldID +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_this$ = -4 +?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z PROC NEAR ; JNIEnv_::GetObjectField, COMDAT + +; 1248 : jobject GetObjectField(jobject obj, jfieldID fieldID) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1249 : return functions->GetObjectField(this,obj,fieldID); + + mov esi, esp + mov eax, DWORD PTR _fieldID$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+380] + cmp esi, esp + call __chkesp + +; 1250 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ENDP ; JNIEnv_::GetObjectField +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_this$ = -4 +?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z PROC NEAR ; JNIEnv_::GetIntField, COMDAT + +; 1263 : jint GetIntField(jobject obj, jfieldID fieldID) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1264 : return functions->GetIntField(this,obj,fieldID); + + mov esi, esp + mov eax, DWORD PTR _fieldID$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+400] + cmp esi, esp + call __chkesp + +; 1265 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ENDP ; JNIEnv_::GetIntField +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_val$ = 16 +_this$ = -4 +?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z PROC NEAR ; JNIEnv_::SetIntField, COMDAT + +; 1296 : jint val) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1297 : functions->SetIntField(this,obj,fieldID,val); + + mov esi, esp + mov eax, DWORD PTR _val$[ebp] + push eax + mov ecx, DWORD PTR _fieldID$[ebp] + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+436] + cmp esi, esp + call __chkesp + +; 1298 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ENDP ; JNIEnv_::SetIntField +_TEXT ENDS +; COMDAT ?NewStringUTF@JNIEnv_@@QAEPAV_jstring@@PBD@Z +_TEXT SEGMENT +_this$ = -4 +_utf$ = 8 +?NewStringUTF@JNIEnv_@@QAEPAV_jstring@@PBD@Z PROC NEAR ; JNIEnv_::NewStringUTF, COMDAT + +; 1576 : jstring NewStringUTF(const char *utf) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1577 : return functions->NewStringUTF(this,utf); + + mov esi, esp + mov eax, DWORD PTR _utf$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+668] + cmp esi, esp + call __chkesp + +; 1578 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 4 +?NewStringUTF@JNIEnv_@@QAEPAV_jstring@@PBD@Z ENDP ; JNIEnv_::NewStringUTF +_TEXT ENDS +; COMDAT ?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z +_TEXT SEGMENT +_this$ = -4 +_str$ = 8 +_isCopy$ = 12 +?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z PROC NEAR ; JNIEnv_::GetStringUTFChars, COMDAT + +; 1582 : const char* GetStringUTFChars(jstring str, jboolean *isCopy) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1583 : return functions->GetStringUTFChars(this,str,isCopy); + + mov esi, esp + mov eax, DWORD PTR _isCopy$[ebp] + push eax + mov ecx, DWORD PTR _str$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+676] + cmp esi, esp + call __chkesp + +; 1584 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z ENDP ; JNIEnv_::GetStringUTFChars +_TEXT ENDS +; COMDAT ?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z +_TEXT SEGMENT +_this$ = -4 +_str$ = 8 +_chars$ = 12 +?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z PROC NEAR ; JNIEnv_::ReleaseStringUTFChars, COMDAT + +; 1585 : void ReleaseStringUTFChars(jstring str, const char* chars) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1586 : functions->ReleaseStringUTFChars(this,str,chars); + + mov esi, esp + mov eax, DWORD PTR _chars$[ebp] + push eax + mov ecx, DWORD PTR _str$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+680] + cmp esi, esp + call __chkesp + +; 1587 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z ENDP ; JNIEnv_::ReleaseStringUTFChars +_TEXT ENDS +END diff --git a/cpp/nativecall/Debug/NativeCall.dll b/cpp/nativecall/Debug/NativeCall.dll new file mode 100644 index 0000000000000000000000000000000000000000..fa9a51bc69e3b468616b44c5e899db787f4feb58 GIT binary patch literal 233590 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 literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Debug/NativeCall.obj b/cpp/nativecall/Debug/NativeCall.obj new file mode 100644 index 0000000000000000000000000000000000000000..670355fb04820c2dab5fb44da26ca75b150c523d GIT binary patch literal 29095 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%0Aq)z;n08J|7k6Xy@j?~;c_e|jdV{U=2}CBMOcJA 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 T6B#C3nDgxeAE6S`-`4*HPrdtB literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Debug/RCa01372 b/cpp/nativecall/Debug/RCa01372 new file mode 100644 index 0000000000000000000000000000000000000000..eb8e4b17d0d11871dd188167c7a6fac99cce7dcc GIT binary patch literal 4904 zcmds)U2hsk6o$`rrT&KvzDXq41%D)I?`*#078}c8(nyhzgTY3{V8PNRQh$7(cV;KM z3yYIFxggaFc6MgY*E{c=IkRIE8{5=|7FoqgR<&R49Z$_>Hn64LGcvW<7K~rhy5ZfS zFXoZlEhCzL%*eg#8PgNnoY^rt=5F-NJ|efSQ<5EKjhOp45_2@G@7zg`?JvHov?o03 zUod0fS_6CFQJ?0_85yHzYI|-*$$qpSY$q3+dVc0PW9EQaGi1DFc{X%^s!ywVb`wk{nXmlw@a(jTcdq$EqhB(hyOD>p{GSVcq0t9?+M<8cVtcCT}6E4 z*6p77W3UnqU84Sj|5Ku_5~uK})4$Je9p9i`?;VF_enqZ9_(LLByc!iW2QAx&qCE1k zEy2z+=BZrC?;g*>?Tk1?t+(IHOZcI^c*pm1x4YAx2|HNWyeMGEB0(>k6JIBNW4IC7 zvjkP2GjGs-Yz-Lb_g{y-cEwJt!ofavTRgJ!4^OmFvWt#O_%4Y$@-H$L!y5MOjpO)1 z!oL8e!kstSLd4TiReAC`kZWJcMebv7#d-mNt6> z`^bz_N$1d%JB029x{;LJxmKcejSsU-{>V!Q4{OZK*5>}M5VRECHX`h)()V|e$lWB~ zyHj$GA8EcSwwK=x!Hzf@IhJZo)Glw-)WYLiJeW8H9ebFPtorqUxt@Ik-^n^ ziN@bR;|{qgPXsGgS0^O=6mQ)q- z+WHk~+~j3m(^C*mPrP6bhX3N(WYR_!7l|6Nyku{a2{CSa;{Ux!n`NYzmNUP$f)XCd@KIPE}x9I$7`+uuJ hzwXYg>gscM=Cp#Xz_9P*F1%^?Ovy|!F@FgQ{sr%EaLfPz literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Debug/RCa01444 b/cpp/nativecall/Debug/RCa01444 new file mode 100644 index 0000000000000000000000000000000000000000..eb8e4b17d0d11871dd188167c7a6fac99cce7dcc GIT binary patch literal 4904 zcmds)U2hsk6o$`rrT&KvzDXq41%D)I?`*#078}c8(nyhzgTY3{V8PNRQh$7(cV;KM z3yYIFxggaFc6MgY*E{c=IkRIE8{5=|7FoqgR<&R49Z$_>Hn64LGcvW<7K~rhy5ZfS zFXoZlEhCzL%*eg#8PgNnoY^rt=5F-NJ|efSQ<5EKjhOp45_2@G@7zg`?JvHov?o03 zUod0fS_6CFQJ?0_85yHzYI|-*$$qpSY$q3+dVc0PW9EQaGi1DFc{X%^s!ywVb`wk{nXmlw@a(jTcdq$EqhB(hyOD>p{GSVcq0t9?+M<8cVtcCT}6E4 z*6p77W3UnqU84Sj|5Ku_5~uK})4$Je9p9i`?;VF_enqZ9_(LLByc!iW2QAx&qCE1k zEy2z+=BZrC?;g*>?Tk1?t+(IHOZcI^c*pm1x4YAx2|HNWyeMGEB0(>k6JIBNW4IC7 zvjkP2GjGs-Yz-Lb_g{y-cEwJt!ofavTRgJ!4^OmFvWt#O_%4Y$@-H$L!y5MOjpO)1 z!oL8e!kstSLd4TiReAC`kZWJcMebv7#d-mNt6> z`^bz_N$1d%JB029x{;LJxmKcejSsU-{>V!Q4{OZK*5>}M5VRECHX`h)()V|e$lWB~ zyHj$GA8EcSwwK=x!Hzf@IhJZo)Glw-)WYLiJeW8H9ebFPtorqUxt@Ik-^n^ ziN@bR;|{qgPXsGgS0^O=6mQ)q- z+WHk~+~j3m(^C*mPrP6bhX3N(WYR_!7l|6Nyku{a2{CSa;{Ux!n`NYzmNUP$f)XCd@KIPE}x9I$7`+uuJ hzwXYg>gscM=Cp#Xz_9P*F1%^?Ovy|!F@FgQ{sr%EaLfPz literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Debug/RCa01468 b/cpp/nativecall/Debug/RCa01468 new file mode 100644 index 0000000000000000000000000000000000000000..eb8e4b17d0d11871dd188167c7a6fac99cce7dcc GIT binary patch literal 4904 zcmds)U2hsk6o$`rrT&KvzDXq41%D)I?`*#078}c8(nyhzgTY3{V8PNRQh$7(cV;KM z3yYIFxggaFc6MgY*E{c=IkRIE8{5=|7FoqgR<&R49Z$_>Hn64LGcvW<7K~rhy5ZfS zFXoZlEhCzL%*eg#8PgNnoY^rt=5F-NJ|efSQ<5EKjhOp45_2@G@7zg`?JvHov?o03 zUod0fS_6CFQJ?0_85yHzYI|-*$$qpSY$q3+dVc0PW9EQaGi1DFc{X%^s!ywVb`wk{nXmlw@a(jTcdq$EqhB(hyOD>p{GSVcq0t9?+M<8cVtcCT}6E4 z*6p77W3UnqU84Sj|5Ku_5~uK})4$Je9p9i`?;VF_enqZ9_(LLByc!iW2QAx&qCE1k zEy2z+=BZrC?;g*>?Tk1?t+(IHOZcI^c*pm1x4YAx2|HNWyeMGEB0(>k6JIBNW4IC7 zvjkP2GjGs-Yz-Lb_g{y-cEwJt!ofavTRgJ!4^OmFvWt#O_%4Y$@-H$L!y5MOjpO)1 z!oL8e!kstSLd4TiReAC`kZWJcMebv7#d-mNt6> z`^bz_N$1d%JB029x{;LJxmKcejSsU-{>V!Q4{OZK*5>}M5VRECHX`h)()V|e$lWB~ zyHj$GA8EcSwwK=x!Hzf@IhJZo)Glw-)WYLiJeW8H9ebFPtorqUxt@Ik-^n^ ziN@bR;|{qgPXsGgS0^O=6mQ)q- z+WHk~+~j3m(^C*mPrP6bhX3N(WYR_!7l|6Nyku{a2{CSa;{Ux!n`NYzmNUP$f)XCd@KIPE}x9I$7`+uuJ hzwXYg>gscM=Cp#Xz_9P*F1%^?Ovy|!F@FgQ{sr%EaLfPz literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Debug/VoidCall.asm b/cpp/nativecall/Debug/VoidCall.asm new file mode 100644 index 0000000..de20049 --- /dev/null +++ b/cpp/nativecall/Debug/VoidCall.asm @@ -0,0 +1,1743 @@ + TITLE C:\Documents and Settings\Administrator\My Documents\Software\NativeCall\src\cpp\VoidCall.cpp + .386P +include listing.inc +if @Version gt 510 +.model FLAT +else +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +_BSS SEGMENT DWORD USE32 PUBLIC 'BSS' +_BSS ENDS +$$SYMBOLS SEGMENT BYTE USE32 'DEBSYM' +$$SYMBOLS ENDS +$$TYPES SEGMENT BYTE USE32 'DEBTYP' +$$TYPES ENDS +_TLS SEGMENT DWORD USE32 PUBLIC 'TLS' +_TLS ENDS +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ??8@YAHABU_GUID@@0@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_VoidCall_executeCall@8 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT _Java_com_eaio_nativecall_VoidCall_executeCall0@12 +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +FLAT GROUP _DATA, CONST, _BSS + ASSUME CS: FLAT, DS: FLAT, SS: FLAT +endif +PUBLIC ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField +PUBLIC ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField +PUBLIC _Java_com_eaio_nativecall_VoidCall_executeCall@8 +EXTRN __imp__GetLastError@0:NEAR +EXTRN ?fieldFunctionHandle@@3PAU_jfieldID@@A:DWORD ; fieldFunctionHandle +EXTRN ?fieldLastErrorCode@@3PAU_jfieldID@@A:DWORD ; fieldLastErrorCode +EXTRN __chkesp:NEAR +; COMDAT _Java_com_eaio_nativecall_VoidCall_executeCall@8 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_functionHandle$ = -4 +_Java_com_eaio_nativecall_VoidCall_executeCall@8 PROC NEAR ; COMDAT + +; 79 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 80 : +; 81 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov eax, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField + mov DWORD PTR _functionHandle$[ebp], eax + +; 82 : +; 83 : #ifdef _WINDOWS +; 84 : #ifdef _X86_ +; 85 : +; 86 : __asm { +; 87 : +; 88 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 89 : +; 90 : } +; 91 : +; 92 : #endif +; 93 : #endif +; 94 : +; 95 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + mov esi, esp + call DWORD PTR __imp__GetLastError@0 + cmp esi, esp + call __chkesp + push eax + mov edx, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField + +; 96 : +; 97 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +_Java_com_eaio_nativecall_VoidCall_executeCall@8 ENDP +_TEXT ENDS +PUBLIC ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField +PUBLIC ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ; JNIEnv_::SetObjectField +PUBLIC _Java_com_eaio_nativecall_VoidCall_executeCall0@12 +PUBLIC ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z ; JNIEnv_::GetArrayLength +PUBLIC ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ; JNIEnv_::GetObjectArrayElement +PUBLIC ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' +PUBLIC ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical +PUBLIC ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ; JNIEnv_::ReleasePrimitiveArrayCritical +PUBLIC ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass +PUBLIC ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z ; JNIEnv_::ThrowNew +PUBLIC ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject +PUBLIC ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf +PUBLIC ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod +PUBLIC ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod +EXTRN ??2@YAPAXI@Z:NEAR ; operator new +EXTRN ??3@YAXPAX@Z:NEAR ; operator delete +EXTRN ?fieldHolderO@@3PAU_jfieldID@@A:DWORD ; fieldHolderO +EXTRN ?classBoolean@@3PAV_jclass@@A:DWORD ; classBoolean +EXTRN ?classInteger@@3PAV_jclass@@A:DWORD ; classInteger +EXTRN ?classByteArray@@3PAV_jclass@@A:DWORD ; classByteArray +EXTRN ?classCharArray@@3PAV_jclass@@A:DWORD ; classCharArray +EXTRN ?classHolder@@3PAV_jclass@@A:DWORD ; classHolder +EXTRN ?methodBooleanValue@@3PAU_jmethodID@@A:DWORD ; methodBooleanValue +EXTRN ?methodIntValue@@3PAU_jmethodID@@A:DWORD ; methodIntValue +EXTRN ?newIntegerInt@@3PAU_jmethodID@@A:DWORD ; newIntegerInt +EXTRN ?newBooleanBoolean@@3PAU_jmethodID@@A:DWORD ; newBooleanBoolean +EXTRN _memset:NEAR +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +; File c:\documents and settings\administrator\my documents\software\nativecall\src\cpp\voidcall.cpp +CONST SEGMENT +??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ DB 'java/lang/OutOfMemor' + DB 'yError', 00H ; `string' +CONST ENDS +; COMDAT _Java_com_eaio_nativecall_VoidCall_executeCall0@12 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_params$ = 16 +_len$ = -4 +_arrays$ = -8 +_param$ = -12 +_i$ = -16 +_intArg$56816 = -20 +_byteArrayArg$56819 = -24 +_charArrayArg$56825 = -28 +_booleanArg$56831 = -32 +_tempArg$56832 = -36 +_o$56835 = -40 +_intPtr$56837 = -44 +_byteArrayArg$56843 = -48 +_charArrayArg$56849 = -52 +_booleanArg$56855 = -56 +_tempPtr$56856 = -60 +_functionHandle$ = -64 +_j$ = -68 +_o$56873 = -72 +_out$56875 = -76 +_out$56885 = -80 +$T56914 = -84 +$T56915 = -88 +$T56916 = -92 +$T56917 = -96 +$T56918 = -100 +$T56919 = -104 +_Java_com_eaio_nativecall_VoidCall_executeCall0@12 PROC NEAR ; COMDAT + +; 105 : (JNIEnv *env, jobject obj, jobjectArray params) { + + push ebp + mov ebp, esp + sub esp, 168 ; 000000a8H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-168] + mov ecx, 42 ; 0000002aH + mov eax, -858993460 ; ccccccccH + rep stosd + +; 106 : +; 107 : const int len = env->GetArrayLength(params); + + mov eax, DWORD PTR _params$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z ; JNIEnv_::GetArrayLength + mov DWORD PTR _len$[ebp], eax + +; 108 : +; 109 : int* arrays = NULL; + + mov DWORD PTR _arrays$[ebp], 0 + +; 110 : if (!(arrays = new int[len])) { + + mov ecx, DWORD PTR _len$[ebp] + shl ecx, 2 + push ecx + call ??2@YAPAXI@Z ; operator new + add esp, 4 + mov DWORD PTR $T56914[ebp], eax + mov edx, DWORD PTR $T56914[ebp] + mov DWORD PTR _arrays$[ebp], edx + cmp DWORD PTR _arrays$[ebp], 0 + jne SHORT $L56805 + +; 111 : env->ThrowNew(env->FindClass("java/lang/OutOfMemoryError"), NULL); + + push 0 + push OFFSET FLAT:??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' + mov ecx, DWORD PTR _env$[ebp] + call ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ; JNIEnv_::FindClass + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z ; JNIEnv_::ThrowNew + +; 112 : return; + + jmp $L56800 +$L56805: + +; 114 : memset(arrays, 0, (sizeof(int) * len)); + + mov eax, DWORD PTR _len$[ebp] + shl eax, 2 + push eax + push 0 + mov ecx, DWORD PTR _arrays$[ebp] + push ecx + call _memset + add esp, 12 ; 0000000cH + +; 115 : +; 116 : jobject param; +; 117 : +; 118 : for (int i = len - 1; i >= 0; i--) { + + mov edx, DWORD PTR _len$[ebp] + sub edx, 1 + mov DWORD PTR _i$[ebp], edx + jmp SHORT $L56810 +$L56811: + mov eax, DWORD PTR _i$[ebp] + sub eax, 1 + mov DWORD PTR _i$[ebp], eax +$L56810: + cmp DWORD PTR _i$[ebp], 0 + jl $L56812 + +; 119 : +; 120 : param = env->GetObjectArrayElement(params, i); + + mov ecx, DWORD PTR _i$[ebp] + push ecx + mov edx, DWORD PTR _params$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ; JNIEnv_::GetObjectArrayElement + mov DWORD PTR _param$[ebp], eax + +; 121 : +; 122 : if (param == NULL) { + + cmp DWORD PTR _param$[ebp], 0 + jne SHORT $L56813 + +; 123 : _push(0); + + push 0 + +; 125 : else if (env->IsInstanceOf(param, classInteger)) { + + jmp $L56854 +$L56813: + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56815 + +; 126 : int intArg = env->CallIntMethod(param, methodIntValue); + + mov edx, DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + push ecx + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + add esp, 12 ; 0000000cH + mov DWORD PTR _intArg$56816[ebp], eax + +; 127 : _push(intArg) + + push DWORD PTR _intArg$56816[ebp] + +; 129 : else if (env->IsInstanceOf(param, classByteArray)) { + + jmp $L56854 +$L56815: + mov edx, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56818 + +; 130 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) param, 0); + + push 0 + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _byteArrayArg$56819[ebp], eax + +; 131 : arrays[i] = (int) &byteArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _byteArrayArg$56819[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 132 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$56819[ebp] + +; 134 : else if (env->IsInstanceOf(param, classCharArray)) { + + jmp $L56854 +$L56818: + mov edx, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56824 + +; 135 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 136 : (jarray) param, 0); + + push 0 + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _charArrayArg$56825[ebp], eax + +; 137 : arrays[i] = (int) &charArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _charArrayArg$56825[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 138 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$56825[ebp] + +; 140 : else if (env->IsInstanceOf(param, classBoolean)) { + + jmp $L56854 +$L56824: + mov edx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56830 + +; 141 : jboolean booleanArg = env->CallBooleanMethod(param, methodBooleanValue); + + mov ecx, DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov eax, DWORD PTR _env$[ebp] + push eax + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + add esp, 12 ; 0000000cH + mov BYTE PTR _booleanArg$56831[ebp], al + +; 142 : int tempArg = (booleanArg == JNI_FALSE ? 0 : 1); + + mov ecx, DWORD PTR _booleanArg$56831[ebp] + and ecx, 255 ; 000000ffH + neg ecx + sbb ecx, ecx + neg ecx + mov DWORD PTR _tempArg$56832[ebp], ecx + +; 143 : _push(tempArg) + + push DWORD PTR _tempArg$56832[ebp] + +; 145 : else if (env->IsInstanceOf(param, classHolder)) { + + jmp $L56854 +$L56830: + mov edx, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je $L56854 + +; 146 : +; 147 : /* Holder */ +; 148 : +; 149 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov ecx, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField + mov DWORD PTR _o$56835[ebp], eax + +; 150 : +; 151 : if (env->IsInstanceOf(o, classInteger)) { + + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + mov ecx, DWORD PTR _o$56835[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56836 + +; 152 : int *intPtr = new int; + + push 4 + call ??2@YAPAXI@Z ; operator new + add esp, 4 + mov DWORD PTR $T56915[ebp], eax + mov edx, DWORD PTR $T56915[ebp] + mov DWORD PTR _intPtr$56837[ebp], edx + +; 153 : *intPtr = env->CallIntMethod(o, methodIntValue); + + mov eax, DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push eax + mov ecx, DWORD PTR _o$56835[ebp] + push ecx + mov edx, DWORD PTR _env$[ebp] + push edx + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + add esp, 12 ; 0000000cH + mov ecx, DWORD PTR _intPtr$56837[ebp] + mov DWORD PTR [ecx], eax + +; 154 : arrays[i] = (int) intPtr; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + mov ecx, DWORD PTR _intPtr$56837[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 155 : _push(intPtr); + + push DWORD PTR _intPtr$56837[ebp] + +; 157 : else if (env->IsInstanceOf(o, classByteArray)) { + + jmp $L56854 +$L56836: + mov edx, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push edx + mov eax, DWORD PTR _o$56835[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56842 + +; 158 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) o, 0); + + push 0 + mov ecx, DWORD PTR _o$56835[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _byteArrayArg$56843[ebp], eax + +; 159 : arrays[i] = (int) &byteArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _byteArrayArg$56843[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 160 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$56843[ebp] + +; 162 : else if (env->IsInstanceOf(o, classCharArray)) { + + jmp $L56854 +$L56842: + mov edx, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push edx + mov eax, DWORD PTR _o$56835[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56848 + +; 163 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 164 : (jarray) o, 0); + + push 0 + mov ecx, DWORD PTR _o$56835[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ; JNIEnv_::GetPrimitiveArrayCritical + mov DWORD PTR _charArrayArg$56849[ebp], eax + +; 165 : arrays[i] = (int) &charArrayArg; + + mov edx, DWORD PTR _i$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + lea ecx, DWORD PTR _charArrayArg$56849[ebp] + mov DWORD PTR [eax+edx*4], ecx + +; 166 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$56849[ebp] + +; 168 : else if (env->IsInstanceOf(o, classBoolean)) { + + jmp SHORT $L56854 +$L56848: + mov edx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push edx + mov eax, DWORD PTR _o$56835[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56854 + +; 169 : jboolean booleanArg = env->CallBooleanMethod(o, methodBooleanValue); + + mov ecx, DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ecx + mov edx, DWORD PTR _o$56835[ebp] + push edx + mov eax, DWORD PTR _env$[ebp] + push eax + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + add esp, 12 ; 0000000cH + mov BYTE PTR _booleanArg$56855[ebp], al + +; 170 : int *tempPtr = new int; + + push 4 + call ??2@YAPAXI@Z ; operator new + add esp, 4 + mov DWORD PTR $T56916[ebp], eax + mov ecx, DWORD PTR $T56916[ebp] + mov DWORD PTR _tempPtr$56856[ebp], ecx + +; 171 : *tempPtr = (booleanArg == JNI_FALSE ? 0 : 1); + + mov edx, DWORD PTR _booleanArg$56855[ebp] + and edx, 255 ; 000000ffH + neg edx + sbb edx, edx + neg edx + mov eax, DWORD PTR _tempPtr$56856[ebp] + mov DWORD PTR [eax], edx + +; 172 : arrays[i] = (int) tempPtr; + + mov ecx, DWORD PTR _i$[ebp] + mov edx, DWORD PTR _arrays$[ebp] + mov eax, DWORD PTR _tempPtr$56856[ebp] + mov DWORD PTR [edx+ecx*4], eax + +; 173 : _push(tempPtr); + + push DWORD PTR _tempPtr$56856[ebp] +$L56854: + +; 179 : +; 180 : } + + jmp $L56811 +$L56812: + +; 181 : +; 182 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov ecx, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ; JNIEnv_::GetIntField + mov DWORD PTR _functionHandle$[ebp], eax + +; 183 : +; 184 : #ifdef _WINDOWS +; 185 : #ifdef _X86_ +; 186 : +; 187 : __asm { +; 188 : +; 189 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 190 : +; 191 : } +; 192 : +; 193 : #endif +; 194 : #endif +; 195 : +; 196 : for (int j = 0; j < len; ++j) { + + mov DWORD PTR _j$[ebp], 0 + jmp SHORT $L56862 +$L56863: + mov eax, DWORD PTR _j$[ebp] + add eax, 1 + mov DWORD PTR _j$[ebp], eax +$L56862: + mov ecx, DWORD PTR _j$[ebp] + cmp ecx, DWORD PTR _len$[ebp] + jge $L56864 + +; 197 : param = env->GetObjectArrayElement(params, j); + + mov edx, DWORD PTR _j$[ebp] + push edx + mov eax, DWORD PTR _params$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ; JNIEnv_::GetObjectArrayElement + mov DWORD PTR _param$[ebp], eax + +; 198 : if (param == NULL) {} + + cmp DWORD PTR _param$[ebp], 0 + jne SHORT $L56865 + +; 199 : else if (env->IsInstanceOf(param, classByteArray) || env->IsInstanceOf(param, classCharArray)) { + + jmp $L56884 +$L56865: + mov ecx, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + jne SHORT $L56868 + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56867 +$L56868: + +; 200 : env->ReleasePrimitiveArrayCritical((jarray) param, (void*) arrays[j], 0); + + push 0 + mov edx, DWORD PTR _j$[ebp] + mov eax, DWORD PTR _arrays$[ebp] + mov ecx, DWORD PTR [eax+edx*4] + push ecx + mov edx, DWORD PTR _param$[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ; JNIEnv_::ReleasePrimitiveArrayCritical + +; 202 : else if (env->IsInstanceOf(param, classHolder)) { + + jmp $L56884 +$L56867: + mov eax, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je $L56884 + +; 203 : +; 204 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov edx, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ; JNIEnv_::GetObjectField + mov DWORD PTR _o$56873[ebp], eax + +; 205 : +; 206 : if (env->IsInstanceOf(o, classInteger)) { + + mov ecx, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push ecx + mov edx, DWORD PTR _o$56873[ebp] + push edx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56874 + +; 207 : int* out = (int*) arrays[j]; + + mov eax, DWORD PTR _j$[ebp] + mov ecx, DWORD PTR _arrays$[ebp] + mov edx, DWORD PTR [ecx+eax*4] + mov DWORD PTR _out$56875[ebp], edx + +; 208 : env->SetObjectField(param, fieldHolderO, env->NewObject(classInteger, newIntegerInt, *out)); + + mov eax, DWORD PTR _out$56875[ebp] + mov ecx, DWORD PTR [eax] + push ecx + mov edx, DWORD PTR ?newIntegerInt@@3PAU_jmethodID@@A ; newIntegerInt + push edx + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + mov ecx, DWORD PTR _env$[ebp] + push ecx + call ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject + add esp, 16 ; 00000010H + push eax + mov edx, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push edx + mov eax, DWORD PTR _param$[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ; JNIEnv_::SetObjectField + +; 209 : delete out; + + mov ecx, DWORD PTR _out$56875[ebp] + mov DWORD PTR $T56917[ebp], ecx + mov edx, DWORD PTR $T56917[ebp] + push edx + call ??3@YAXPAX@Z ; operator delete + add esp, 4 + +; 211 : else if (env->IsInstanceOf(o, classByteArray) || env->IsInstanceOf(o, classCharArray)) { + + jmp $L56884 +$L56874: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + push eax + mov ecx, DWORD PTR _o$56873[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + jne SHORT $L56880 + mov edx, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + push edx + mov eax, DWORD PTR _o$56873[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56879 +$L56880: + +; 212 : env->ReleasePrimitiveArrayCritical((jarray) o, (void*) arrays[j], 0); + + push 0 + mov ecx, DWORD PTR _j$[ebp] + mov edx, DWORD PTR _arrays$[ebp] + mov eax, DWORD PTR [edx+ecx*4] + push eax + mov ecx, DWORD PTR _o$56873[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ; JNIEnv_::ReleasePrimitiveArrayCritical + +; 214 : else if (env->IsInstanceOf(o, classBoolean)) { + + jmp SHORT $L56884 +$L56879: + mov edx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push edx + mov eax, DWORD PTR _o$56873[ebp] + push eax + mov ecx, DWORD PTR _env$[ebp] + call ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ; JNIEnv_::IsInstanceOf + and eax, 255 ; 000000ffH + test eax, eax + je SHORT $L56884 + +; 215 : int* out = (int*) arrays[j]; + + mov ecx, DWORD PTR _j$[ebp] + mov edx, DWORD PTR _arrays$[ebp] + mov eax, DWORD PTR [edx+ecx*4] + mov DWORD PTR _out$56885[ebp], eax + +; 216 : env->SetObjectField(param, fieldHolderO, env->NewObject(classBoolean, newBooleanBoolean, (*out == 0 ? JNI_FALSE : JNI_TRUE))); + + mov ecx, DWORD PTR _out$56885[ebp] + xor edx, edx + cmp DWORD PTR [ecx], 0 + setne dl + push edx + mov eax, DWORD PTR ?newBooleanBoolean@@3PAU_jmethodID@@A ; newBooleanBoolean + push eax + mov ecx, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push ecx + mov edx, DWORD PTR _env$[ebp] + push edx + call ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject + add esp, 16 ; 00000010H + push eax + mov eax, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push eax + mov ecx, DWORD PTR _param$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ; JNIEnv_::SetObjectField + +; 217 : delete out; + + mov edx, DWORD PTR _out$56885[ebp] + mov DWORD PTR $T56918[ebp], edx + mov eax, DWORD PTR $T56918[ebp] + push eax + call ??3@YAXPAX@Z ; operator delete + add esp, 4 +$L56884: + +; 221 : +; 222 : } + + jmp $L56863 +$L56864: + +; 223 : +; 224 : delete [] arrays; + + mov ecx, DWORD PTR _arrays$[ebp] + mov DWORD PTR $T56919[ebp], ecx + mov edx, DWORD PTR $T56919[ebp] + push edx + call ??3@YAXPAX@Z ; operator delete + add esp, 4 + +; 225 : +; 226 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + mov esi, esp + call DWORD PTR __imp__GetLastError@0 + cmp esi, esp + call __chkesp + push eax + mov eax, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov ecx, DWORD PTR _env$[ebp] + call ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ; JNIEnv_::SetIntField +$L56800: + +; 227 : +; 228 : } + + pop edi + pop esi + pop ebx + add esp, 168 ; 000000a8H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +_Java_com_eaio_nativecall_VoidCall_executeCall0@12 ENDP +_TEXT ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT +_this$ = -4 +_name$ = 8 +?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z PROC NEAR ; JNIEnv_::FindClass, COMDAT + +; 759 : jclass FindClass(const char *name) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 760 : return functions->FindClass(this, name); + + mov esi, esp + mov eax, DWORD PTR _name$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+24] + cmp esi, esp + call __chkesp + +; 761 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 4 +?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z ENDP ; JNIEnv_::FindClass +_TEXT ENDS +; COMDAT ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z +_TEXT SEGMENT +_this$ = -4 +_clazz$ = 8 +_msg$ = 12 +?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z PROC NEAR ; JNIEnv_::ThrowNew, COMDAT + +; 787 : jint ThrowNew(jclass clazz, const char *msg) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 788 : return functions->ThrowNew(this, clazz, msg); + + mov esi, esp + mov eax, DWORD PTR _msg$[ebp] + push eax + mov ecx, DWORD PTR _clazz$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+56] + cmp esi, esp + call __chkesp + +; 789 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z ENDP ; JNIEnv_::ThrowNew +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_args$ = -4 +_result$ = -8 +_clazz$ = 12 +_methodID$ = 16 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::NewObject, COMDAT + +; 834 : jobject NewObject(jclass clazz, jmethodID methodID, ...) { + + push ebp + mov ebp, esp + sub esp, 72 ; 00000048H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-72] + mov ecx, 18 ; 00000012H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 835 : va_list args; +; 836 : jobject result; +; 837 : va_start(args, methodID); + + lea eax, DWORD PTR _methodID$[ebp+4] + mov DWORD PTR _args$[ebp], eax + +; 838 : result = functions->NewObjectV(this,clazz,methodID,args); + + mov esi, esp + mov ecx, DWORD PTR _args$[ebp] + push ecx + mov edx, DWORD PTR _methodID$[ebp] + push edx + mov eax, DWORD PTR _clazz$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+116] + cmp esi, esp + call __chkesp + mov DWORD PTR _result$[ebp], eax + +; 839 : va_end(args); + + mov DWORD PTR _args$[ebp], 0 + +; 840 : return result; + + mov eax, DWORD PTR _result$[ebp] + +; 841 : } + + pop edi + pop esi + pop ebx + add esp, 72 ; 00000048H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 0 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::NewObject +_TEXT ENDS +; COMDAT ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z +_TEXT SEGMENT +_this$ = -4 +_obj$ = 8 +_clazz$ = 12 +?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z PROC NEAR ; JNIEnv_::IsInstanceOf, COMDAT + +; 854 : jboolean IsInstanceOf(jobject obj, jclass clazz) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 855 : return functions->IsInstanceOf(this,obj,clazz); + + mov esi, esp + mov eax, DWORD PTR _clazz$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+128] + cmp esi, esp + call __chkesp + +; 856 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z ENDP ; JNIEnv_::IsInstanceOf +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_args$ = -4 +_result$ = -8 +_obj$ = 12 +_methodID$ = 16 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallBooleanMethod, COMDAT + +; 881 : jmethodID methodID, ...) { + + push ebp + mov ebp, esp + sub esp, 72 ; 00000048H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-72] + mov ecx, 18 ; 00000012H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 882 : va_list args; +; 883 : jboolean result; +; 884 : va_start(args,methodID); + + lea eax, DWORD PTR _methodID$[ebp+4] + mov DWORD PTR _args$[ebp], eax + +; 885 : result = functions->CallBooleanMethodV(this,obj,methodID,args); + + mov esi, esp + mov ecx, DWORD PTR _args$[ebp] + push ecx + mov edx, DWORD PTR _methodID$[ebp] + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+152] + cmp esi, esp + call __chkesp + mov BYTE PTR _result$[ebp], al + +; 886 : va_end(args); + + mov DWORD PTR _args$[ebp], 0 + +; 887 : return result; + + mov al, BYTE PTR _result$[ebp] + +; 888 : } + + pop edi + pop esi + pop ebx + add esp, 72 ; 00000048H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 0 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallBooleanMethod +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_args$ = -4 +_result$ = -8 +_obj$ = 12 +_methodID$ = 16 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallIntMethod, COMDAT + +; 949 : jint CallIntMethod(jobject obj, jmethodID methodID, ...) { + + push ebp + mov ebp, esp + sub esp, 72 ; 00000048H + push ebx + push esi + push edi + lea edi, DWORD PTR [ebp-72] + mov ecx, 18 ; 00000012H + mov eax, -858993460 ; ccccccccH + rep stosd + +; 950 : va_list args; +; 951 : jint result; +; 952 : va_start(args,methodID); + + lea eax, DWORD PTR _methodID$[ebp+4] + mov DWORD PTR _args$[ebp], eax + +; 953 : result = functions->CallIntMethodV(this,obj,methodID,args); + + mov esi, esp + mov ecx, DWORD PTR _args$[ebp] + push ecx + mov edx, DWORD PTR _methodID$[ebp] + push edx + mov eax, DWORD PTR _obj$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+200] + cmp esi, esp + call __chkesp + mov DWORD PTR _result$[ebp], eax + +; 954 : va_end(args); + + mov DWORD PTR _args$[ebp], 0 + +; 955 : return result; + + mov eax, DWORD PTR _result$[ebp] + +; 956 : } + + pop edi + pop esi + pop ebx + add esp, 72 ; 00000048H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 0 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallIntMethod +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_this$ = -4 +?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z PROC NEAR ; JNIEnv_::GetObjectField, COMDAT + +; 1248 : jobject GetObjectField(jobject obj, jfieldID fieldID) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1249 : return functions->GetObjectField(this,obj,fieldID); + + mov esi, esp + mov eax, DWORD PTR _fieldID$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+380] + cmp esi, esp + call __chkesp + +; 1250 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z ENDP ; JNIEnv_::GetObjectField +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_this$ = -4 +?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z PROC NEAR ; JNIEnv_::GetIntField, COMDAT + +; 1263 : jint GetIntField(jobject obj, jfieldID fieldID) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1264 : return functions->GetIntField(this,obj,fieldID); + + mov esi, esp + mov eax, DWORD PTR _fieldID$[ebp] + push eax + mov ecx, DWORD PTR _obj$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+400] + cmp esi, esp + call __chkesp + +; 1265 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z ENDP ; JNIEnv_::GetIntField +_TEXT ENDS +; COMDAT ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_val$ = 16 +_this$ = -4 +?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z PROC NEAR ; JNIEnv_::SetObjectField, COMDAT + +; 1276 : void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1277 : functions->SetObjectField(this,obj,fieldID,val); + + mov esi, esp + mov eax, DWORD PTR _val$[ebp] + push eax + mov ecx, DWORD PTR _fieldID$[ebp] + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+416] + cmp esi, esp + call __chkesp + +; 1278 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z ENDP ; JNIEnv_::SetObjectField +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT +_obj$ = 8 +_fieldID$ = 12 +_val$ = 16 +_this$ = -4 +?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z PROC NEAR ; JNIEnv_::SetIntField, COMDAT + +; 1296 : jint val) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1297 : functions->SetIntField(this,obj,fieldID,val); + + mov esi, esp + mov eax, DWORD PTR _val$[ebp] + push eax + mov ecx, DWORD PTR _fieldID$[ebp] + push ecx + mov edx, DWORD PTR _obj$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+436] + cmp esi, esp + call __chkesp + +; 1298 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z ENDP ; JNIEnv_::SetIntField +_TEXT ENDS +; COMDAT ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z PROC NEAR ; JNIEnv_::GetArrayLength, COMDAT + +; 1589 : jsize GetArrayLength(jarray array) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1590 : return functions->GetArrayLength(this,array); + + mov esi, esp + mov eax, DWORD PTR _array$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + mov eax, DWORD PTR [edx] + call DWORD PTR [eax+684] + cmp esi, esp + call __chkesp + +; 1591 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 4 +?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z ENDP ; JNIEnv_::GetArrayLength +_TEXT ENDS +; COMDAT ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +_index$ = 12 +?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z PROC NEAR ; JNIEnv_::GetObjectArrayElement, COMDAT + +; 1597 : jobject GetObjectArrayElement(jobjectArray array, jsize index) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1598 : return functions->GetObjectArrayElement(this,array,index); + + mov esi, esp + mov eax, DWORD PTR _index$[ebp] + push eax + mov ecx, DWORD PTR _array$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+692] + cmp esi, esp + call __chkesp + +; 1599 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z ENDP ; JNIEnv_::GetObjectArrayElement +_TEXT ENDS +; COMDAT ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +_isCopy$ = 12 +?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z PROC NEAR ; JNIEnv_::GetPrimitiveArrayCritical, COMDAT + +; 1788 : void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1789 : return functions->GetPrimitiveArrayCritical(this,array,isCopy); + + mov esi, esp + mov eax, DWORD PTR _isCopy$[ebp] + push eax + mov ecx, DWORD PTR _array$[ebp] + push ecx + mov edx, DWORD PTR _this$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + mov ecx, DWORD PTR [eax] + call DWORD PTR [ecx+888] + cmp esi, esp + call __chkesp + +; 1790 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 8 +?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z ENDP ; JNIEnv_::GetPrimitiveArrayCritical +_TEXT ENDS +; COMDAT ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z +_TEXT SEGMENT +_this$ = -4 +_array$ = 8 +_carray$ = 12 +_mode$ = 16 +?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z PROC NEAR ; JNIEnv_::ReleasePrimitiveArrayCritical, COMDAT + +; 1791 : void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) { + + push ebp + mov ebp, esp + sub esp, 68 ; 00000044H + push ebx + push esi + push edi + push ecx + lea edi, DWORD PTR [ebp-68] + mov ecx, 17 ; 00000011H + mov eax, -858993460 ; ccccccccH + rep stosd + pop ecx + mov DWORD PTR _this$[ebp], ecx + +; 1792 : functions->ReleasePrimitiveArrayCritical(this,array,carray,mode); + + mov esi, esp + mov eax, DWORD PTR _mode$[ebp] + push eax + mov ecx, DWORD PTR _carray$[ebp] + push ecx + mov edx, DWORD PTR _array$[ebp] + push edx + mov eax, DWORD PTR _this$[ebp] + push eax + mov ecx, DWORD PTR _this$[ebp] + mov edx, DWORD PTR [ecx] + call DWORD PTR [edx+892] + cmp esi, esp + call __chkesp + +; 1793 : } + + pop edi + pop esi + pop ebx + add esp, 68 ; 00000044H + cmp ebp, esp + call __chkesp + mov esp, ebp + pop ebp + ret 12 ; 0000000cH +?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z ENDP ; JNIEnv_::ReleasePrimitiveArrayCritical +_TEXT ENDS +END diff --git a/cpp/nativecall/Debug/VoidCall.obj b/cpp/nativecall/Debug/VoidCall.obj new file mode 100644 index 0000000000000000000000000000000000000000..9ba9ad6ab225cebca6ee6e1ca05658f4b29b33b9 GIT binary patch literal 27719 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 Yl4ji+J{d5`!MqO_%J8RQ@8r<`7lL*D^#A|> literal 0 HcmV?d00001 diff --git a/cpp/nativecall/IntCall.cpp b/cpp/nativecall/IntCall.cpp new file mode 100644 index 0000000..131e267 --- /dev/null +++ b/cpp/nativecall/IntCall.cpp @@ -0,0 +1,236 @@ +/* + * IntCall.cpp + * + * Created on 11.09.2004. + * + * $Id: IntCall.cpp,v 1.3 2006/04/19 20:54:55 grnull Exp $ + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#include +#include "com_eaio_nativecall_IntCall.h" + +#ifdef _WINDOWS +#include +#include +#endif + +#ifdef _WINDOWS +#ifdef _X86_ + +#define _push(x) __asm { push x }; + +#endif +#endif + +// NativeCall fields + +extern jfieldID fieldFunction, fieldModule, fieldFunctionHandle, + fieldModuleHandle, fieldLastErrorCode; + +// Holder fields + +extern jfieldID fieldHolderO; + +// Classes + +extern jclass classBoolean,/* classByte, classCharacter, classShort,*/ + classInteger, /* classLong, classFloat, classDouble,*/ classString, + classByteArray, classCharArray, /*classIntArray,*/ classHolder; + +// Wrapper class methods + +extern jmethodID methodBooleanValue,/* methodByteValue, methodCharValue, +methodShortValue,*/ methodIntValue/*, methodLongValue, methodFloatValue, +methodDoubleValue*/; + +// Constructors + +extern jmethodID newIntegerInt, newBooleanBoolean; + +/* + * Class: com_eaio_nativecall_IntCall + * Method: executeCall + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_com_eaio_nativecall_IntCall_executeCall +(JNIEnv *env, jobject obj) { + + jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + jint outVal; + +#ifdef _WINDOWS +#ifdef _X86_ + + __asm { + + call functionHandle + mov outVal, eax + + } + +#endif +#endif + + env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + return outVal; + +} + +/* + * Class: com_eaio_nativecall_IntCall + * Method: executeCall0 + * Signature: ([Ljava/lang/Object;)I + */ +JNIEXPORT jint JNICALL Java_com_eaio_nativecall_IntCall_executeCall0 +(JNIEnv *env, jobject obj, jobjectArray params) { + + const int len = env->GetArrayLength(params); + + int* arrays = NULL; + if (!(arrays = new int[len])) { + env->ThrowNew(env->FindClass("java/lang/OutOfMemoryError"), NULL); + return 0; + } + memset(arrays, 0, (sizeof(int) * len)); + + jobject param; + + for (int i = len - 1; i >= 0; i--) { + + param = env->GetObjectArrayElement(params, i); + + if (param == NULL) { + _push(0); + } + else if (env->IsInstanceOf(param, classInteger)) { + int intArg = env->CallIntMethod(param, methodIntValue); + _push(intArg) + } + else if (env->IsInstanceOf(param, classByteArray)) { + char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) param, 0); + arrays[i] = (int) &byteArrayArg; + _push(byteArrayArg) + } + else if (env->IsInstanceOf(param, classCharArray)) { + unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( + (jarray) param, 0); + arrays[i] = (int) &charArrayArg; + _push(charArrayArg) + } + else if (env->IsInstanceOf(param, classBoolean)) { + jboolean booleanArg = env->CallBooleanMethod(param, methodBooleanValue); + int tempArg = (booleanArg == JNI_FALSE ? 0 : 1); + _push(tempArg) + } + else if (env->IsInstanceOf(param, classHolder)) { + + /* Holder */ + + jobject o = env->GetObjectField(param, fieldHolderO); + + if (env->IsInstanceOf(o, classInteger)) { + int *intPtr = new int; + *intPtr = env->CallIntMethod(o, methodIntValue); + arrays[i] = (int) intPtr; + _push(intPtr); + } + else if (env->IsInstanceOf(o, classByteArray)) { + char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) o, 0); + arrays[i] = (int) &byteArrayArg; + _push(byteArrayArg) + } + else if (env->IsInstanceOf(o, classCharArray)) { + unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( + (jarray) o, 0); + arrays[i] = (int) &charArrayArg; + _push(charArrayArg) + } + else if (env->IsInstanceOf(o, classBoolean)) { + jboolean booleanArg = env->CallBooleanMethod(o, methodBooleanValue); + int *tempPtr = new int; + *tempPtr = (booleanArg == JNI_FALSE ? 0 : 1); + arrays[i] = (int) tempPtr; + _push(tempPtr); + } + + /* end Holder */ + + } + + } + + jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + jint outVal; + +#ifdef _WINDOWS +#ifdef _X86_ + + __asm { + + call functionHandle + mov outVal, eax + + } + +#endif +#endif + + for (int j = 0; j < len; ++j) { + param = env->GetObjectArrayElement(params, j); + if (param == NULL) {} + else if (env->IsInstanceOf(param, classByteArray) || env->IsInstanceOf(param, classCharArray)) { + env->ReleasePrimitiveArrayCritical((jarray) param, (void*) arrays[j], 0); + } + else if (env->IsInstanceOf(param, classHolder)) { + + jobject o = env->GetObjectField(param, fieldHolderO); + + if (env->IsInstanceOf(o, classInteger)) { + int* out = (int*) arrays[j]; + env->SetObjectField(param, fieldHolderO, env->NewObject(classInteger, newIntegerInt, *out)); + delete out; + } + else if (env->IsInstanceOf(o, classByteArray) || env->IsInstanceOf(o, classCharArray)) { + env->ReleasePrimitiveArrayCritical((jarray) o, (void*) arrays[j], 0); + } + else if (env->IsInstanceOf(o, classBoolean)) { + int* out = (int*) arrays[j]; + env->SetObjectField(param, fieldHolderO, env->NewObject(classBoolean, newBooleanBoolean, (*out == 0 ? JNI_FALSE : JNI_TRUE))); + delete out; + } + + } + + } + + delete [] arrays; + + env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + return outVal; + +} diff --git a/cpp/nativecall/NativeCall.cpp b/cpp/nativecall/NativeCall.cpp new file mode 100644 index 0000000..33fd45c --- /dev/null +++ b/cpp/nativecall/NativeCall.cpp @@ -0,0 +1,234 @@ +/* + * NativeCall.cpp + * + * Created on 11.09.2004. + * + * $Id: NativeCall.cpp,v 1.4 2006/04/19 20:54:55 grnull Exp $ + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#include +#include "com_eaio_nativecall_NativeCall.h" + +#ifdef _WINDOWS +#include +#include +#endif + +// NativeCall fields + +jfieldID fieldFunction, fieldModule, fieldFunctionHandle, + fieldModuleHandle, fieldLastErrorCode; + +// Holder fields + +jfieldID fieldHolderO; + +// Classes + +jclass classBoolean,/* classByte, classCharacter, classShort,*/ + classInteger, /* classLong, classFloat, classDouble,*/ classString, + classByteArray, classCharArray, /*classIntArray,*/ classHolder; + +// Wrapper class methods + +jmethodID methodBooleanValue,/* methodByteValue, methodCharValue, +methodShortValue,*/ methodIntValue/*, methodLongValue, methodFloatValue, +methodDoubleValue*/; + +// Constructors + +jmethodID newIntegerInt, newBooleanBoolean; + +/* + * Class: com_eaio_nativecall_NativeCall + * Method: initIDs + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_NativeCall_initIDs +(JNIEnv *env, jclass cls) { + + // NativeCall fields + + fieldFunction = env->GetFieldID(cls, "function", "Ljava/lang/String;"); + fieldModule = env->GetFieldID(cls, "module", "Ljava/lang/String;"); + + fieldFunctionHandle = env->GetFieldID(cls, "functionHandle", "I"); + fieldModuleHandle = env-> GetFieldID(cls, "moduleHandle", "I"); + + fieldLastErrorCode = env->GetFieldID(cls, "lastErrorCode", "I"); + + // Holder fields + + classHolder = (jclass) env->NewGlobalRef(env->FindClass("com/eaio/nativecall/Holder")); + fieldHolderO = env->GetFieldID(classHolder, "o", "Ljava/lang/Object;"); + + // Other classes + + classBoolean = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Boolean")); + /*classByte = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Byte")); + classCharacter = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Character")); + classShort = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Short"));*/ + classInteger = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Integer")); + /*classLong = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Long")); + classFloat = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Float")); + classDouble = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Double"));*/ + classString = (jclass) env->NewGlobalRef(env->FindClass("java/lang/String")); + classByteArray = (jclass) env->NewGlobalRef(env->FindClass("[B")); + classCharArray = (jclass) env->NewGlobalRef(env->FindClass("[C")); + /*classIntArray = (jclass) env->NewGlobalRef(env->FindClass("[I"));*/ + + // Wrapper class methods + + methodBooleanValue = env->GetMethodID(classBoolean, + "booleanValue", "()Z"); + /*methodByteValue = env->GetMethodID(classByte, + "byteValue", "()B"); + methodCharValue = env->GetMethodID(classCharacter, + "charValue", "()C"); + methodShortValue = env->GetMethodID(classShort, + "shortValue", "()S");*/ + methodIntValue = env->GetMethodID(classInteger, + "intValue", "()I"); + /*methodLongValue = env->GetMethodID(classLong, + "longValue", "()J"); + methodFloatValue = env->GetMethodID(classFloat, + "floatValue", "()F"); + methodDoubleValue = env->GetMethodID(classDouble, + "doubleValue", "()D");*/ + + // Constructors + + newIntegerInt = env->GetMethodID(classInteger, "", "(I)V"); + newBooleanBoolean = env->GetMethodID(classBoolean, "", "(Z)V"); + +} + +/* + * Class: com_eaio_nativecall_NativeCall + * Method: initHandles + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_com_eaio_nativecall_NativeCall_initHandles +(JNIEnv *env, jobject obj) { + + bool out = JNI_TRUE; + + jstring moduleNameS = (jstring) env->GetObjectField(obj, fieldModule); + jstring functionNameS = (jstring) env->GetObjectField(obj, fieldFunction); + + const char* moduleName = env->GetStringUTFChars(moduleNameS, 0); + const char* functionName = env->GetStringUTFChars(functionNameS, 0); + +#ifdef _WINDOWS + + HMODULE mod = LoadLibrary(moduleName); + + if (mod == NULL) { + /* no such module or DllMain returned FALSE */ + env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + out = JNI_FALSE; + } + else { + FARPROC addr = GetProcAddress(mod, functionName); + if (addr == NULL) { + /* function not found */ + FreeLibrary(mod); + env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + out = JNI_FALSE; + } + else { + /* all ok */ + env->SetIntField(obj, fieldModuleHandle, (jint) mod); + env->SetIntField(obj, fieldFunctionHandle, (jint) addr); + } + } + +#endif + + env->ReleaseStringUTFChars(moduleNameS, moduleName); + env->ReleaseStringUTFChars(functionNameS, functionName); + + return out; + +} + +/* + * Class: com_eaio_nativecall_NativeCall + * Method: getLastError + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_com_eaio_nativecall_NativeCall_getLastError +(JNIEnv *env, jobject obj) { + + jint lastError = env->GetIntField(obj, fieldLastErrorCode); + + if (lastError == 0) return NULL; + + jstring out = NULL; + +#ifdef _WINDOWS + + LPVOID msgBufPtr = NULL; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM, NULL, lastError, 0, + (LPSTR) &msgBufPtr, 0, NULL); + + out = env->NewStringUTF((char*) msgBufPtr); + + LocalFree(msgBufPtr); + +#endif + + return out; + +} + +/* + * Class: com_eaio_nativecall_NativeCall + * Method: destroy + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_NativeCall_destroy +(JNIEnv *env, jobject obj) { + + jint module = env->GetIntField(obj, fieldModuleHandle); + + if (module == 0) return; + +#ifdef _WINDOWS + + if (FreeLibrary((HMODULE) module) == 0) { + env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + } + +#endif + + env->SetIntField(obj, fieldModuleHandle, 0); + env->SetIntField(obj, fieldFunctionHandle, 0); + + return; + +} \ No newline at end of file diff --git a/cpp/nativecall/NativeCall.dsp b/cpp/nativecall/NativeCall.dsp new file mode 100644 index 0000000..8eb76c2 --- /dev/null +++ b/cpp/nativecall/NativeCall.dsp @@ -0,0 +1,132 @@ +# Microsoft Developer Studio Project File - Name="NativeCall" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** NICHT BEARBEITEN ** + +# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 + +CFG=NativeCall - Win32 Debug +!MESSAGE Dies ist kein gültiges Makefile. Zum Erstellen dieses Projekts mit NMAKE +!MESSAGE verwenden Sie den Befehl "Makefile exportieren" und führen Sie den Befehl +!MESSAGE +!MESSAGE NMAKE /f "NativeCall.mak". +!MESSAGE +!MESSAGE Sie können beim Ausführen von NMAKE eine Konfiguration angeben +!MESSAGE durch Definieren des Makros CFG in der Befehlszeile. Zum Beispiel: +!MESSAGE +!MESSAGE NMAKE /f "NativeCall.mak" CFG="NativeCall - Win32 Debug" +!MESSAGE +!MESSAGE Für die Konfiguration stehen zur Auswahl: +!MESSAGE +!MESSAGE "NativeCall - Win32 Release" (basierend auf "Win32 (x86) Dynamic-Link Library") +!MESSAGE "NativeCall - Win32 Debug" (basierend auf "Win32 (x86) Dynamic-Link Library") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +MTL=midl.exe +RSC=rc.exe + +!IF "$(CFG)" == "NativeCall - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "NATIVECALL_EXPORTS" /YX /FD /c +# ADD CPP /nologo /G5 /MD /W3 /Oa /Og /Os /Oy /Ob2 /Gf /I "C:\Program Files\IBMJava13\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "NATIVECALL_EXPORTS" /D "WIN32_LEAN_AND_MEAN" /FAs /FR /YX /FD /c +# SUBTRACT CPP /Ox /Ot /Gy +# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x407 /d "NDEBUG" +# ADD RSC /l 0x407 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 +# ADD LINK32 kernel32.lib libctiny.lib "C:\Program Files\Microsoft Visual Studio\VC98\Lib\libcmt.lib" "C:\Program Files\Microsoft Visual Studio\VC98\Lib\msvcrt.lib" /nologo /subsystem:console /dll /map /machine:I386 /nodefaultlib /MERGE:".rdata=.text" /OPT:REF /OPT:NOWIN98 +# SUBTRACT LINK32 /pdb:none + +!ELSEIF "$(CFG)" == "NativeCall - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "NATIVECALL_EXPORTS" /YX /FD /GZ /c +# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "C:\Program Files\IBMJava13\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "NATIVECALL_EXPORTS" /FAs /FR /YX /FD /GZ /c +# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32 +# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x407 /d "_DEBUG" +# ADD RSC /l 0x407 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "NativeCall - Win32 Release" +# Name "NativeCall - Win32 Debug" +# Begin Group "Quellcodedateien" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\IntCall.cpp +# End Source File +# Begin Source File + +SOURCE=.\NativeCall.cpp +# End Source File +# Begin Source File + +SOURCE=.\version.rc +# End Source File +# Begin Source File + +SOURCE=.\VoidCall.cpp +# End Source File +# End Group +# Begin Group "Header-Dateien" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\com_eaio_nativecall_IntCall.h +# End Source File +# Begin Source File + +SOURCE=.\com_eaio_nativecall_NativeCall.h +# End Source File +# Begin Source File + +SOURCE=.\com_eaio_nativecall_VoidCall.h +# End Source File +# End Group +# Begin Group "Ressourcendateien" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project diff --git a/cpp/nativecall/NativeCall.dsw b/cpp/nativecall/NativeCall.dsw new file mode 100644 index 0000000..27e86f6 --- /dev/null +++ b/cpp/nativecall/NativeCall.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNUNG: DIESE ARBEITSBEREICHSDATEI DARF NICHT BEARBEITET ODER GELÖSCHT WERDEN! + +############################################################################### + +Project: "NativeCall"=".\NativeCall.dsp" - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/cpp/nativecall/Release/IntCall.asm b/cpp/nativecall/Release/IntCall.asm new file mode 100644 index 0000000..406ec6c --- /dev/null +++ b/cpp/nativecall/Release/IntCall.asm @@ -0,0 +1,943 @@ + TITLE C:\Documents and Settings\Administrator\My Documents\Software\NativeCall\src\cpp\IntCall.cpp + .386P +include listing.inc +if @Version gt 510 +.model FLAT +else +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +_BSS SEGMENT DWORD USE32 PUBLIC 'BSS' +_BSS ENDS +_TLS SEGMENT DWORD USE32 PUBLIC 'TLS' +_TLS ENDS +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +FLAT GROUP _DATA, CONST, _BSS + ASSUME CS: FLAT, DS: FLAT, SS: FLAT +endif +PUBLIC _Java_com_eaio_nativecall_IntCall_executeCall@8 +EXTRN ?fieldFunctionHandle@@3PAU_jfieldID@@A:DWORD ; fieldFunctionHandle +EXTRN ?fieldLastErrorCode@@3PAU_jfieldID@@A:DWORD ; fieldLastErrorCode +EXTRN __imp__GetLastError@0:NEAR +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_functionHandle$ = 8 +_outVal$ = -4 +_Java_com_eaio_nativecall_IntCall_executeCall@8 PROC NEAR + +; 79 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + push ecx + +; 80 : +; 81 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov eax, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push esi + mov esi, DWORD PTR _env$[ebp] + push eax + push DWORD PTR _obj$[ebp] + mov ecx, DWORD PTR [esi] + push esi + call DWORD PTR [ecx+400] + mov DWORD PTR _functionHandle$[ebp], eax + +; 82 : jint outVal; +; 83 : +; 84 : #ifdef _WINDOWS +; 85 : #ifdef _X86_ +; 86 : +; 87 : __asm { +; 88 : +; 89 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 90 : mov outVal, eax + + mov DWORD PTR _outVal$[ebp], eax + +; 91 : +; 92 : } +; 93 : +; 94 : #endif +; 95 : #endif +; 96 : +; 97 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + call DWORD PTR __imp__GetLastError@0 + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push DWORD PTR _obj$[ebp] + push esi + call DWORD PTR [ecx+436] + +; 98 : +; 99 : return outVal; + + mov eax, DWORD PTR _outVal$[ebp] + +; 100 : +; 101 : } + + pop esi + leave + ret 8 +_Java_com_eaio_nativecall_IntCall_executeCall@8 ENDP +_TEXT ENDS +PUBLIC ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' +PUBLIC _Java_com_eaio_nativecall_IntCall_executeCall0@12 +PUBLIC ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject +PUBLIC ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod +PUBLIC ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod +EXTRN ?fieldHolderO@@3PAU_jfieldID@@A:DWORD ; fieldHolderO +EXTRN ?classBoolean@@3PAV_jclass@@A:DWORD ; classBoolean +EXTRN ?classInteger@@3PAV_jclass@@A:DWORD ; classInteger +EXTRN ?classByteArray@@3PAV_jclass@@A:DWORD ; classByteArray +EXTRN ?classCharArray@@3PAV_jclass@@A:DWORD ; classCharArray +EXTRN ?classHolder@@3PAV_jclass@@A:DWORD ; classHolder +EXTRN ?methodBooleanValue@@3PAU_jmethodID@@A:DWORD ; methodBooleanValue +EXTRN ?methodIntValue@@3PAU_jmethodID@@A:DWORD ; methodIntValue +EXTRN ?newIntegerInt@@3PAU_jmethodID@@A:DWORD ; newIntegerInt +EXTRN ?newBooleanBoolean@@3PAU_jmethodID@@A:DWORD ; newBooleanBoolean +EXTRN ??2@YAPAXI@Z:NEAR ; operator new +EXTRN ??3@YAXPAX@Z:NEAR ; operator delete +EXTRN _memset:NEAR +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +; File C:\Program Files\IBMJava13\include\jni.h +_DATA SEGMENT +??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ DB 'java/lang/OutOfMemor' + DB 'yError', 00H ; `string' +_DATA ENDS +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_params$ = 16 +_len$ = -28 +_arrays$ = -20 +_param$ = -24 +_i$ = 8 +_intArg$27770 = -24 +_byteArrayArg$27773 = -4 +_charArrayArg$27779 = -8 +_tempArg$27786 = -24 +_intPtr$27791 = -24 +_byteArrayArg$27797 = -12 +_charArrayArg$27803 = -16 +_tempPtr$27810 = -24 +_functionHandle$ = 8 +_outVal$ = -32 +_j$ = 8 +_Java_com_eaio_nativecall_IntCall_executeCall0@12 PROC NEAR + +; 109 : (JNIEnv *env, jobject obj, jobjectArray params) { + + push ebp + mov ebp, esp + sub esp, 32 ; 00000020H + push ebx + push esi + +; 110 : +; 111 : const int len = env->GetArrayLength(params); + + mov esi, DWORD PTR _env$[ebp] + push edi + push DWORD PTR _params$[ebp] + mov eax, DWORD PTR [esi] + push esi + call DWORD PTR [eax+684] + mov ebx, eax + +; 112 : +; 113 : int* arrays = NULL; +; 114 : if (!(arrays = new int[len])) { + + mov edi, ebx + mov DWORD PTR _len$[ebp], ebx + shl edi, 2 + push edi + call ??2@YAPAXI@Z ; operator new + test eax, eax + pop ecx + mov DWORD PTR _arrays$[ebp], eax + jne SHORT $L27759 + +; 115 : env->ThrowNew(env->FindClass("java/lang/OutOfMemoryError"), NULL); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push 0 + push eax + push esi + call DWORD PTR [ecx+56] + +; 116 : return 0; + + xor eax, eax + jmp $L27754 +$L27759: + +; 117 : } +; 118 : memset(arrays, 0, (sizeof(int) * len)); + + push edi + push 0 + push eax + call _memset + +; 119 : +; 120 : jobject param; +; 121 : +; 122 : for (int i = len - 1; i >= 0; i--) { + + lea eax, DWORD PTR [ebx-1] + add esp, 12 ; 0000000cH + test eax, eax + mov DWORD PTR _i$[ebp], eax + jl $L27766 + mov ecx, DWORD PTR _arrays$[ebp] + lea edi, DWORD PTR [ecx+eax*4] + jmp SHORT $L27764 +$L28030: + +; 117 : } +; 118 : memset(arrays, 0, (sizeof(int) * len)); + + mov eax, DWORD PTR _i$[ebp] +$L27764: + +; 123 : +; 124 : param = env->GetObjectArrayElement(params, i); + + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR _params$[ebp] + push esi + call DWORD PTR [ecx+692] + mov ebx, eax + +; 125 : +; 126 : if (param == NULL) { + + test ebx, ebx + jne SHORT $L27767 + +; 127 : _push(0); + + push 0 + +; 128 : } +; 129 : else if (env->IsInstanceOf(param, classInteger)) { + + jmp $L27765 +$L27767: + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27769 + +; 130 : int intArg = env->CallIntMethod(param, methodIntValue); + + push DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push ebx + push esi + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + add esp, 12 ; 0000000cH + mov DWORD PTR _intArg$27770[ebp], eax + +; 131 : _push(intArg) + + push DWORD PTR _intArg$27770[ebp] + +; 132 : } +; 133 : else if (env->IsInstanceOf(param, classByteArray)) { + + jmp $L27765 +$L27769: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27772 + +; 134 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) param, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _byteArrayArg$27773[ebp], eax + +; 135 : arrays[i] = (int) &byteArrayArg; + + lea eax, DWORD PTR _byteArrayArg$27773[ebp] + mov DWORD PTR [edi], eax + +; 136 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$27773[ebp] + +; 137 : } +; 138 : else if (env->IsInstanceOf(param, classCharArray)) { + + jmp $L27765 +$L27772: + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27778 + +; 139 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 140 : (jarray) param, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _charArrayArg$27779[ebp], eax + +; 141 : arrays[i] = (int) &charArrayArg; + + lea eax, DWORD PTR _charArrayArg$27779[ebp] + mov DWORD PTR [edi], eax + +; 142 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$27779[ebp] + +; 143 : } +; 144 : else if (env->IsInstanceOf(param, classBoolean)) { + + jmp $L27765 +$L27778: + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27784 + +; 145 : jboolean booleanArg = env->CallBooleanMethod(param, methodBooleanValue); + + push DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ebx + push esi + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + add esp, 12 ; 0000000cH + +; 146 : int tempArg = (booleanArg == JNI_FALSE ? 0 : 1); + + neg al + sbb eax, eax + neg eax + mov DWORD PTR _tempArg$27786[ebp], eax + +; 147 : _push(tempArg) + + push DWORD PTR _tempArg$27786[ebp] + +; 148 : } +; 149 : else if (env->IsInstanceOf(param, classHolder)) { + + jmp $L27765 +$L27784: + mov eax, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je $L27765 + +; 150 : +; 151 : /* Holder */ +; 152 : +; 153 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov eax, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+380] + +; 154 : +; 155 : if (env->IsInstanceOf(o, classInteger)) { + + mov ecx, DWORD PTR [esi] + mov ebx, eax + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27790 + +; 156 : int *intPtr = new int; + + push 4 + call ??2@YAPAXI@Z ; operator new + pop ecx + mov DWORD PTR _intPtr$27791[ebp], eax + +; 157 : *intPtr = env->CallIntMethod(o, methodIntValue); + + push DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push ebx + push esi + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + mov ecx, DWORD PTR _intPtr$27791[ebp] + add esp, 12 ; 0000000cH + +; 158 : arrays[i] = (int) intPtr; + + mov DWORD PTR [edi], ecx + mov DWORD PTR [ecx], eax + +; 159 : _push(intPtr); + + push DWORD PTR _intPtr$27791[ebp] + +; 160 : } +; 161 : else if (env->IsInstanceOf(o, classByteArray)) { + + jmp $L27765 +$L27790: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27796 + +; 162 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) o, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _byteArrayArg$27797[ebp], eax + +; 163 : arrays[i] = (int) &byteArrayArg; + + lea eax, DWORD PTR _byteArrayArg$27797[ebp] + mov DWORD PTR [edi], eax + +; 164 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$27797[ebp] + +; 165 : } +; 166 : else if (env->IsInstanceOf(o, classCharArray)) { + + jmp SHORT $L27765 +$L27796: + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27802 + +; 167 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 168 : (jarray) o, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _charArrayArg$27803[ebp], eax + +; 169 : arrays[i] = (int) &charArrayArg; + + lea eax, DWORD PTR _charArrayArg$27803[ebp] + mov DWORD PTR [edi], eax + +; 170 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$27803[ebp] + +; 171 : } +; 172 : else if (env->IsInstanceOf(o, classBoolean)) { + + jmp SHORT $L27765 +$L27802: + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27765 + +; 173 : jboolean booleanArg = env->CallBooleanMethod(o, methodBooleanValue); + + push DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ebx + push esi + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + +; 174 : int *tempPtr = new int; + + push 4 + mov bl, al + call ??2@YAPAXI@Z ; operator new + add esp, 16 ; 00000010H + +; 175 : *tempPtr = (booleanArg == JNI_FALSE ? 0 : 1); + + xor ecx, ecx + test bl, bl + setne cl + mov DWORD PTR _tempPtr$27810[ebp], eax + mov DWORD PTR [eax], ecx + +; 176 : arrays[i] = (int) tempPtr; + + mov DWORD PTR [edi], eax + +; 177 : _push(tempPtr); + + push DWORD PTR _tempPtr$27810[ebp] + +; 176 : arrays[i] = (int) tempPtr; + +$L27765: + dec DWORD PTR _i$[ebp] + sub edi, 4 + cmp DWORD PTR _i$[ebp], 0 + jge $L28030 + +; 119 : +; 120 : jobject param; +; 121 : +; 122 : for (int i = len - 1; i >= 0; i--) { + + mov ebx, DWORD PTR _len$[ebp] +$L27766: + +; 178 : } +; 179 : +; 180 : /* end Holder */ +; 181 : +; 182 : } +; 183 : +; 184 : } +; 185 : +; 186 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov eax, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR _obj$[ebp] + push esi + call DWORD PTR [ecx+400] + mov DWORD PTR _functionHandle$[ebp], eax + +; 187 : jint outVal; +; 188 : +; 189 : #ifdef _WINDOWS +; 190 : #ifdef _X86_ +; 191 : +; 192 : __asm { +; 193 : +; 194 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 195 : mov outVal, eax + + mov DWORD PTR _outVal$[ebp], eax + +; 196 : +; 197 : } +; 198 : +; 199 : #endif +; 200 : #endif +; 201 : +; 202 : for (int j = 0; j < len; ++j) { + + and DWORD PTR _j$[ebp], 0 + test ebx, ebx + jle $L27819 + +; 178 : } +; 179 : +; 180 : /* end Holder */ +; 181 : +; 182 : } +; 183 : +; 184 : } +; 185 : +; 186 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov ebx, DWORD PTR _arrays$[ebp] +$L27817: + +; 203 : param = env->GetObjectArrayElement(params, j); + + push DWORD PTR _j$[ebp] + mov eax, DWORD PTR [esi] + push DWORD PTR _params$[ebp] + push esi + call DWORD PTR [eax+692] + mov edi, eax + +; 204 : if (param == NULL) {} + + test edi, edi + mov DWORD PTR _param$[ebp], edi + je $L27818 + +; 205 : else if (env->IsInstanceOf(param, classByteArray) || env->IsInstanceOf(param, classCharArray)) { + + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne $L27835 + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne $L27835 + +; 207 : } +; 208 : else if (env->IsInstanceOf(param, classHolder)) { + + mov eax, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + je $L27818 + +; 209 : +; 210 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov eax, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+380] + +; 211 : +; 212 : if (env->IsInstanceOf(o, classInteger)) { + + mov ecx, DWORD PTR [esi] + mov edi, eax + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27829 + +; 213 : int* out = (int*) arrays[j]; + + mov edi, DWORD PTR [ebx] + +; 214 : env->SetObjectField(param, fieldHolderO, env->NewObject(classInteger, newIntegerInt, *out)); + + push DWORD PTR [edi] + push DWORD PTR ?newIntegerInt@@3PAU_jmethodID@@A ; newIntegerInt + push DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger +$L28033: + push esi + call ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject + add esp, 16 ; 00000010H + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push DWORD PTR _param$[ebp] + push esi + call DWORD PTR [ecx+416] + +; 215 : delete out; + + push edi + call ??3@YAXPAX@Z ; operator delete + pop ecx + +; 216 : } +; 217 : else if (env->IsInstanceOf(o, classByteArray) || env->IsInstanceOf(o, classCharArray)) { + + jmp SHORT $L27818 +$L27829: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne SHORT $L27835 + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne SHORT $L27835 + +; 218 : env->ReleasePrimitiveArrayCritical((jarray) o, (void*) arrays[j], 0); +; 219 : } +; 220 : else if (env->IsInstanceOf(o, classBoolean)) { + + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27818 + +; 221 : int* out = (int*) arrays[j]; + + mov edi, DWORD PTR [ebx] + +; 222 : env->SetObjectField(param, fieldHolderO, env->NewObject(classBoolean, newBooleanBoolean, (*out == 0 ? JNI_FALSE : JNI_TRUE))); + + xor eax, eax + cmp DWORD PTR [edi], eax + setne al + push eax + push DWORD PTR ?newBooleanBoolean@@3PAU_jmethodID@@A ; newBooleanBoolean + push DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + +; 223 : delete out; + + jmp SHORT $L28033 +$L27835: + +; 206 : env->ReleasePrimitiveArrayCritical((jarray) param, (void*) arrays[j], 0); + + mov eax, DWORD PTR [esi] + push 0 + push DWORD PTR [ebx] + push edi + push esi + call DWORD PTR [eax+892] +$L27818: + inc DWORD PTR _j$[ebp] + mov eax, DWORD PTR _j$[ebp] + add ebx, 4 + cmp eax, DWORD PTR _len$[ebp] + jl $L27817 +$L27819: + +; 224 : } +; 225 : +; 226 : } +; 227 : +; 228 : } +; 229 : +; 230 : delete [] arrays; + + push DWORD PTR _arrays$[ebp] + call ??3@YAXPAX@Z ; operator delete + pop ecx + +; 231 : +; 232 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + call DWORD PTR __imp__GetLastError@0 + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push DWORD PTR _obj$[ebp] + push esi + call DWORD PTR [ecx+436] + +; 233 : +; 234 : return outVal; + + mov eax, DWORD PTR _outVal$[ebp] +$L27754: + +; 235 : +; 236 : } + + pop edi + pop esi + pop ebx + leave + ret 12 ; 0000000cH +_Java_com_eaio_nativecall_IntCall_executeCall0@12 ENDP +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_clazz$ = 12 +_methodID$ = 16 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::NewObject, COMDAT + +; 835 : va_list args; +; 836 : jobject result; +; 837 : va_start(args, methodID); +; 838 : result = functions->NewObjectV(this,clazz,methodID,args); + + mov eax, DWORD PTR _this$[esp-4] + lea edx, DWORD PTR _methodID$[esp] + push edx + push DWORD PTR _methodID$[esp] + mov ecx, DWORD PTR [eax] + push DWORD PTR _clazz$[esp+4] + push eax + call DWORD PTR [ecx+116] + +; 839 : va_end(args); +; 840 : return result; +; 841 : } + + ret 0 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::NewObject +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_obj$ = 12 +_methodID$ = 16 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallBooleanMethod, COMDAT + +; 882 : va_list args; +; 883 : jboolean result; +; 884 : va_start(args,methodID); +; 885 : result = functions->CallBooleanMethodV(this,obj,methodID,args); + + mov eax, DWORD PTR _this$[esp-4] + lea edx, DWORD PTR _methodID$[esp] + push edx + push DWORD PTR _methodID$[esp] + mov ecx, DWORD PTR [eax] + push DWORD PTR _obj$[esp+4] + push eax + call DWORD PTR [ecx+152] + +; 886 : va_end(args); +; 887 : return result; +; 888 : } + + ret 0 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallBooleanMethod +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_obj$ = 12 +_methodID$ = 16 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallIntMethod, COMDAT + +; 950 : va_list args; +; 951 : jint result; +; 952 : va_start(args,methodID); +; 953 : result = functions->CallIntMethodV(this,obj,methodID,args); + + mov eax, DWORD PTR _this$[esp-4] + lea edx, DWORD PTR _methodID$[esp] + push edx + push DWORD PTR _methodID$[esp] + mov ecx, DWORD PTR [eax] + push DWORD PTR _obj$[esp+4] + push eax + call DWORD PTR [ecx+200] + +; 954 : va_end(args); +; 955 : return result; +; 956 : } + + ret 0 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallIntMethod +_TEXT ENDS +END diff --git a/cpp/nativecall/Release/IntCall.obj b/cpp/nativecall/Release/IntCall.obj new file mode 100644 index 0000000000000000000000000000000000000000..4459fd43b50790667c4b0be371e510ac055df260 GIT binary patch literal 3896 zcmbVPYiv_h96w!4S9GjZCxSyQVG=^13WC7FUvwccKKNjwiHQlZJQC%D@q>w3g2u%xvC9_W1JM~4uK#n+z1{5t8J^^x z`|JPw|G)p^oO91QD3mfRhI8m->Fhh8&_WAnL>p z6GBVN5OSNTa6P>2$o8@$$cwyAuNtr!{OKEGtIZVhEdzy>1$uTH<`X)l?wUQCy$!&2 z&}&q6ai|S8+wMX>?6+-!d@;~_Z2^35E|Bjc=zUqhw>~Iz@lr&LggSS4+I;o<57_mh zmL_+z%fq(W*9!x^@r1a8+sF6uTp%9h1U?k!V!RmY69RlB!ZpUkdi)j!gn%Rp7&F`c zpIt4pag)7Wo@pJ!<@L#u#j8jaa-~l>HwuMKu@l49qSC-Jyk=~cF106L)Y6==xp z+_4*1EeJSgmLr)%DRxGxmd!o*r%&-N zlPkl>>r+~{)n%qG7!m4#pF}rZuMAzU7|B2s*0XcinP(>b;_K5!nYG|hBpVKbI2pMq zm50&Pbx<0^yfEAbgQo!wXT)k6b(@dS0%wZNDpGdpd};L+vN?>vd~^V!f#lQdT&i4= z=B9)N>CdLwS*$-hwWYNF%EEB|8n4d$J+20YN*Y;*aqMI8Xu07%Dp$(mM5fPnZP-Ne zghFTYJjtFc&fS_a;N&k9@STR=P^;zn$=^w{cW^RyrjP5LmsY-=W^ZHV+ta&BD6h>6 zCTx0ZT%8VE-HqX!*7H{&-joH~XBCfS=$2{dlm%JS)_aN~ADz?)>C)3L&WRzxf<|sy z-`;9~iX5F$B#Ue&i(`~5j@c0TSVw--6+$onuC#pka)Df(h*`qz zoo5iY$UBu6XwtOT)}Kwck+KlUM-Um^9*3qoi$j!{60&v0GI6!Mvo5o}+TMDb^>!B!^|l5+ zA=FztAnGj)h>WVV$3;NY$Jc;pq(1|CjPU)ElbPXcrnXA}(K%WQh|W{7-SQPcmm1p8dLf}jcvao*4ShV?!8K@cn$c8WBdj$q^*L!ytKu+ z3ou5EaL%}CM!1sqGx{FJN*dt_D@Ts5P(-_>+*1(hHrMa)yW;^VD#XO3osR|WZGtF< zV%@;A<1k=b2@fVpIqBASA5} z78uq;Xfx?)MHAiaZw?f6hxH<$E?3%;)P{2Xv^$R_Onm49N;>s@?aeb z_ve@ikM2r~XTWH{n+vyHA2RDS8-zI3%7loO?m~(`hDHOvl4?nq$OlqC@A!T^AK|P2 zd;bmIlDqaB-q3! zMe_Zqj|T;Ysq?zpxiA@NbTf<#aa<_c%W-=JF{jDYsBPER=<{pgi zv&b0}`gh0U5rL1XFD<61Aoj$AG$^ODjydEy=ye@r4igjD{6e>ofLBR%l21cC5)=|G znu0DzXCT5SlXRR6`?xR>;Q~0RV>KEdACYpI=7mHI^fBj=kkR@cKH*9v_`zZ))Ot`9 z?lZ2siir;hKrKYE11DF{aJ9RenC6#SJPbZYoEz~u;@ntxkT`2xE(STBo1nx{;YM8I zW}&~OGYtPVnSITTY^;xCm{u2zLXL4NXUGq=YGe`3SLZM=;BU2B9S@nwJSMh)3f5q; NIpkKtbl(F^{{=L(i9!GX literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Release/NativeCall.asm b/cpp/nativecall/Release/NativeCall.asm new file mode 100644 index 0000000..f2ee074 --- /dev/null +++ b/cpp/nativecall/Release/NativeCall.asm @@ -0,0 +1,859 @@ + TITLE C:\Documents and Settings\Administrator\My Documents\Software\NativeCall\src\cpp\NativeCall.cpp + .386P +include listing.inc +if @Version gt 510 +.model FLAT +else +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +_BSS SEGMENT DWORD USE32 PUBLIC 'BSS' +_BSS ENDS +_TLS SEGMENT DWORD USE32 PUBLIC 'TLS' +_TLS ENDS +; COMDAT ??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_08JJOG@function?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_06CODG@module?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_01FLOP@I?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0P@LKIL@functionHandle?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0N@EFAA@moduleHandle?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0O@OMHL@lastErrorCode?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_01PGHN@o?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0BB@LLFN@java?1lang?1String?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_02LOEJ@?$FLB?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_02BENO@?$FLC?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_03KJOK@?$CI?$CJZ?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_0N@KEBP@booleanValue?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_03PPCD@?$CI?$CJI?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_08JCMA@intValue?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_04ECLF@?$CII?$CJV?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_06KILP@?$DMinit?$DO?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ??_C@_04JFOE@?$CIZ?$CJV?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewGlobalRef@JNIEnv_@@QAEPAV_jobject@@PAV2@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetMethodID@JNIEnv_@@QAEPAU_jmethodID@@PAV_jclass@@PBD1@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetFieldID@JNIEnv_@@QAEPAU_jfieldID@@PAV_jclass@@PBD1@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewStringUTF@JNIEnv_@@QAEPAV_jstring@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetStringUTFChars@JNIEnv_@@QAEPBDPAV_jstring@@PAE@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ReleaseStringUTFChars@JNIEnv_@@QAEXPAV_jstring@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +FLAT GROUP _DATA, CONST, _BSS + ASSUME CS: FLAT, DS: FLAT, SS: FLAT +endif +PUBLIC ?fieldFunction@@3PAU_jfieldID@@A ; fieldFunction +PUBLIC ?fieldModule@@3PAU_jfieldID@@A ; fieldModule +PUBLIC ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle +PUBLIC ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle +PUBLIC ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode +PUBLIC ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO +PUBLIC ?classBoolean@@3PAV_jclass@@A ; classBoolean +PUBLIC ?classInteger@@3PAV_jclass@@A ; classInteger +PUBLIC ?classString@@3PAV_jclass@@A ; classString +PUBLIC ?classByteArray@@3PAV_jclass@@A ; classByteArray +PUBLIC ?classCharArray@@3PAV_jclass@@A ; classCharArray +PUBLIC ?classHolder@@3PAV_jclass@@A ; classHolder +PUBLIC ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue +PUBLIC ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue +PUBLIC ?newIntegerInt@@3PAU_jmethodID@@A ; newIntegerInt +PUBLIC ?newBooleanBoolean@@3PAU_jmethodID@@A ; newBooleanBoolean +_BSS SEGMENT +?fieldFunction@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldFunction +?fieldModule@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldModule +?fieldFunctionHandle@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldFunctionHandle +?fieldModuleHandle@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldModuleHandle +?fieldLastErrorCode@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldLastErrorCode +?fieldHolderO@@3PAU_jfieldID@@A DD 01H DUP (?) ; fieldHolderO +?classBoolean@@3PAV_jclass@@A DD 01H DUP (?) ; classBoolean +?classInteger@@3PAV_jclass@@A DD 01H DUP (?) ; classInteger +?classString@@3PAV_jclass@@A DD 01H DUP (?) ; classString +?classByteArray@@3PAV_jclass@@A DD 01H DUP (?) ; classByteArray +?classCharArray@@3PAV_jclass@@A DD 01H DUP (?) ; classCharArray +?classHolder@@3PAV_jclass@@A DD 01H DUP (?) ; classHolder +?methodBooleanValue@@3PAU_jmethodID@@A DD 01H DUP (?) ; methodBooleanValue +?methodIntValue@@3PAU_jmethodID@@A DD 01H DUP (?) ; methodIntValue +?newIntegerInt@@3PAU_jmethodID@@A DD 01H DUP (?) ; newIntegerInt +?newBooleanBoolean@@3PAU_jmethodID@@A DD 01H DUP (?) ; newBooleanBoolean +_BSS ENDS +PUBLIC ??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ ; `string' +PUBLIC ??_C@_08JJOG@function?$AA@ ; `string' +PUBLIC ??_C@_06CODG@module?$AA@ ; `string' +PUBLIC ??_C@_01FLOP@I?$AA@ ; `string' +PUBLIC ??_C@_0P@LKIL@functionHandle?$AA@ ; `string' +PUBLIC ??_C@_0N@EFAA@moduleHandle?$AA@ ; `string' +PUBLIC ??_C@_0O@OMHL@lastErrorCode?$AA@ ; `string' +PUBLIC ??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ ; `string' +PUBLIC ??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ ; `string' +PUBLIC ??_C@_01PGHN@o?$AA@ ; `string' +PUBLIC ??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ ; `string' +PUBLIC ??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ ; `string' +PUBLIC ??_C@_0BB@LLFN@java?1lang?1String?$AA@ ; `string' +PUBLIC ??_C@_02LOEJ@?$FLB?$AA@ ; `string' +PUBLIC ??_C@_02BENO@?$FLC?$AA@ ; `string' +PUBLIC ??_C@_03KJOK@?$CI?$CJZ?$AA@ ; `string' +PUBLIC ??_C@_0N@KEBP@booleanValue?$AA@ ; `string' +PUBLIC ??_C@_03PPCD@?$CI?$CJI?$AA@ ; `string' +PUBLIC ??_C@_08JCMA@intValue?$AA@ ; `string' +PUBLIC ??_C@_04ECLF@?$CII?$CJV?$AA@ ; `string' +PUBLIC ??_C@_06KILP@?$DMinit?$DO?$AA@ ; `string' +PUBLIC ??_C@_04JFOE@?$CIZ?$CJV?$AA@ ; `string' +PUBLIC _Java_com_eaio_nativecall_NativeCall_initIDs@8 +; COMDAT ??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ +; File C:\Program Files\IBMJava13\include\jni.h +_DATA SEGMENT +??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ DB 'Ljava/lang/String;', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_08JJOG@function?$AA@ +_DATA SEGMENT +??_C@_08JJOG@function?$AA@ DB 'function', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_06CODG@module?$AA@ +_DATA SEGMENT +??_C@_06CODG@module?$AA@ DB 'module', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_01FLOP@I?$AA@ +_DATA SEGMENT +??_C@_01FLOP@I?$AA@ DB 'I', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0P@LKIL@functionHandle?$AA@ +_DATA SEGMENT +??_C@_0P@LKIL@functionHandle?$AA@ DB 'functionHandle', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0N@EFAA@moduleHandle?$AA@ +_DATA SEGMENT +??_C@_0N@EFAA@moduleHandle?$AA@ DB 'moduleHandle', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0O@OMHL@lastErrorCode?$AA@ +_DATA SEGMENT +??_C@_0O@OMHL@lastErrorCode?$AA@ DB 'lastErrorCode', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ +_DATA SEGMENT +??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ DB 'com/eaio/nativecall' + DB '/Holder', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ +_DATA SEGMENT +??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ DB 'Ljava/lang/Object;', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_01PGHN@o?$AA@ +_DATA SEGMENT +??_C@_01PGHN@o?$AA@ DB 'o', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ +_DATA SEGMENT +??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ DB 'java/lang/Boolean', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ +_DATA SEGMENT +??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ DB 'java/lang/Integer', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0BB@LLFN@java?1lang?1String?$AA@ +_DATA SEGMENT +??_C@_0BB@LLFN@java?1lang?1String?$AA@ DB 'java/lang/String', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_02LOEJ@?$FLB?$AA@ +_DATA SEGMENT +??_C@_02LOEJ@?$FLB?$AA@ DB '[B', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_02BENO@?$FLC?$AA@ +_DATA SEGMENT +??_C@_02BENO@?$FLC?$AA@ DB '[C', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_03KJOK@?$CI?$CJZ?$AA@ +_DATA SEGMENT +??_C@_03KJOK@?$CI?$CJZ?$AA@ DB '()Z', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_0N@KEBP@booleanValue?$AA@ +_DATA SEGMENT +??_C@_0N@KEBP@booleanValue?$AA@ DB 'booleanValue', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_03PPCD@?$CI?$CJI?$AA@ +_DATA SEGMENT +??_C@_03PPCD@?$CI?$CJI?$AA@ DB '()I', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_08JCMA@intValue?$AA@ +_DATA SEGMENT +??_C@_08JCMA@intValue?$AA@ DB 'intValue', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_04ECLF@?$CII?$CJV?$AA@ +_DATA SEGMENT +??_C@_04ECLF@?$CII?$CJV?$AA@ DB '(I)V', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_06KILP@?$DMinit?$DO?$AA@ +_DATA SEGMENT +??_C@_06KILP@?$DMinit?$DO?$AA@ DB '', 00H ; `string' +_DATA ENDS +; COMDAT ??_C@_04JFOE@?$CIZ?$CJV?$AA@ +_DATA SEGMENT +??_C@_04JFOE@?$CIZ?$CJV?$AA@ DB '(Z)V', 00H ; `string' +_DATA ENDS +_TEXT SEGMENT +_env$ = 8 +_cls$ = 12 +_Java_com_eaio_nativecall_NativeCall_initIDs@8 PROC NEAR + +; 71 : (JNIEnv *env, jclass cls) { + + push ebx + +; 72 : +; 73 : // NativeCall fields +; 74 : +; 75 : fieldFunction = env->GetFieldID(cls, "function", "Ljava/lang/String;"); + + mov ebx, DWORD PTR _cls$[esp] + push esi + mov esi, DWORD PTR _env$[esp+4] + push edi + mov edi, OFFSET FLAT:??_C@_0BD@DFD@Ljava?1lang?1String?$DL?$AA@ ; `string' + mov eax, DWORD PTR [esi] + push edi + push OFFSET FLAT:??_C@_08JJOG@function?$AA@ ; `string' + push ebx + push esi + call DWORD PTR [eax+376] + +; 76 : fieldModule = env->GetFieldID(cls, "module", "Ljava/lang/String;"); + + push edi + mov DWORD PTR ?fieldFunction@@3PAU_jfieldID@@A, eax ; fieldFunction + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_06CODG@module?$AA@ ; `string' + push ebx + push esi + call DWORD PTR [eax+376] + +; 77 : +; 78 : fieldFunctionHandle = env->GetFieldID(cls, "functionHandle", "I"); + + mov edi, OFFSET FLAT:??_C@_01FLOP@I?$AA@ ; `string' + mov DWORD PTR ?fieldModule@@3PAU_jfieldID@@A, eax ; fieldModule + mov eax, DWORD PTR [esi] + push edi + push OFFSET FLAT:??_C@_0P@LKIL@functionHandle?$AA@ ; `string' + push ebx + push esi + call DWORD PTR [eax+376] + +; 79 : fieldModuleHandle = env-> GetFieldID(cls, "moduleHandle", "I"); + + push edi + mov DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A, eax ; fieldFunctionHandle + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0N@EFAA@moduleHandle?$AA@ ; `string' + push ebx + push esi + call DWORD PTR [eax+376] + +; 80 : +; 81 : fieldLastErrorCode = env->GetFieldID(cls, "lastErrorCode", "I"); + + push edi + mov DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A, eax ; fieldModuleHandle + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0O@OMHL@lastErrorCode?$AA@ ; `string' + push ebx + push esi + call DWORD PTR [eax+376] + mov DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A, eax ; fieldLastErrorCode + +; 82 : +; 83 : // Holder fields +; 84 : +; 85 : classHolder = (jclass) env->NewGlobalRef(env->FindClass("com/eaio/nativecall/Holder")); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0BL@DALH@com?1eaio?1nativecall?1Holder?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push eax + push esi + call DWORD PTR [ecx+84] + +; 86 : fieldHolderO = env->GetFieldID(classHolder, "o", "Ljava/lang/Object;"); + + mov ecx, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0BD@GEDI@Ljava?1lang?1Object?$DL?$AA@ ; `string' + push OFFSET FLAT:??_C@_01PGHN@o?$AA@ ; `string' + push eax + push esi + mov DWORD PTR ?classHolder@@3PAV_jclass@@A, eax ; classHolder + call DWORD PTR [ecx+376] + mov DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A, eax ; fieldHolderO + +; 87 : +; 88 : // Other classes +; 89 : +; 90 : classBoolean = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Boolean")); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0BC@IGNJ@java?1lang?1Boolean?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push eax + push esi + call DWORD PTR [ecx+84] + mov DWORD PTR ?classBoolean@@3PAV_jclass@@A, eax ; classBoolean + +; 91 : /*classByte = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Byte")); +; 92 : classCharacter = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Character")); +; 93 : classShort = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Short"));*/ +; 94 : classInteger = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Integer")); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0BC@FBKL@java?1lang?1Integer?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push eax + push esi + call DWORD PTR [ecx+84] + mov DWORD PTR ?classInteger@@3PAV_jclass@@A, eax ; classInteger + +; 95 : /*classLong = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Long")); +; 96 : classFloat = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Float")); +; 97 : classDouble = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Double"));*/ +; 98 : classString = (jclass) env->NewGlobalRef(env->FindClass("java/lang/String")); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0BB@LLFN@java?1lang?1String?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push eax + push esi + call DWORD PTR [ecx+84] + mov DWORD PTR ?classString@@3PAV_jclass@@A, eax ; classString + +; 99 : classByteArray = (jclass) env->NewGlobalRef(env->FindClass("[B")); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_02LOEJ@?$FLB?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push eax + push esi + call DWORD PTR [ecx+84] + mov DWORD PTR ?classByteArray@@3PAV_jclass@@A, eax ; classByteArray + +; 100 : classCharArray = (jclass) env->NewGlobalRef(env->FindClass("[C")); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_02BENO@?$FLC?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push eax + push esi + call DWORD PTR [ecx+84] + +; 101 : /*classIntArray = (jclass) env->NewGlobalRef(env->FindClass("[I"));*/ +; 102 : +; 103 : // Wrapper class methods +; 104 : +; 105 : methodBooleanValue = env->GetMethodID(classBoolean, +; 106 : "booleanValue", "()Z"); + + mov ecx, DWORD PTR [esi] + mov DWORD PTR ?classCharArray@@3PAV_jclass@@A, eax ; classCharArray + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push OFFSET FLAT:??_C@_03KJOK@?$CI?$CJZ?$AA@ ; `string' + push OFFSET FLAT:??_C@_0N@KEBP@booleanValue?$AA@ ; `string' + push eax + push esi + call DWORD PTR [ecx+132] + +; 107 : /*methodByteValue = env->GetMethodID(classByte, +; 108 : "byteValue", "()B"); +; 109 : methodCharValue = env->GetMethodID(classCharacter, +; 110 : "charValue", "()C"); +; 111 : methodShortValue = env->GetMethodID(classShort, +; 112 : "shortValue", "()S");*/ +; 113 : methodIntValue = env->GetMethodID(classInteger, +; 114 : "intValue", "()I"); + + mov ecx, DWORD PTR [esi] + mov DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A, eax ; methodBooleanValue + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push OFFSET FLAT:??_C@_03PPCD@?$CI?$CJI?$AA@ ; `string' + push OFFSET FLAT:??_C@_08JCMA@intValue?$AA@ ; `string' + push eax + push esi + call DWORD PTR [ecx+132] + +; 115 : /*methodLongValue = env->GetMethodID(classLong, +; 116 : "longValue", "()J"); +; 117 : methodFloatValue = env->GetMethodID(classFloat, +; 118 : "floatValue", "()F"); +; 119 : methodDoubleValue = env->GetMethodID(classDouble, +; 120 : "doubleValue", "()D");*/ +; 121 : +; 122 : // Constructors +; 123 : +; 124 : newIntegerInt = env->GetMethodID(classInteger, "", "(I)V"); + + mov ecx, DWORD PTR [esi] + mov DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A, eax ; methodIntValue + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + mov edi, OFFSET FLAT:??_C@_06KILP@?$DMinit?$DO?$AA@ ; `string' + push OFFSET FLAT:??_C@_04ECLF@?$CII?$CJV?$AA@ ; `string' + push edi + push eax + push esi + call DWORD PTR [ecx+132] + +; 125 : newBooleanBoolean = env->GetMethodID(classBoolean, "", "(Z)V"); + + mov ecx, DWORD PTR [esi] + mov DWORD PTR ?newIntegerInt@@3PAU_jmethodID@@A, eax ; newIntegerInt + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + push OFFSET FLAT:??_C@_04JFOE@?$CIZ?$CJV?$AA@ ; `string' + push edi + push eax + push esi + call DWORD PTR [ecx+132] + pop edi + pop esi + mov DWORD PTR ?newBooleanBoolean@@3PAU_jmethodID@@A, eax ; newBooleanBoolean + pop ebx + +; 126 : +; 127 : } + + ret 8 +_Java_com_eaio_nativecall_NativeCall_initIDs@8 ENDP +_TEXT ENDS +PUBLIC _Java_com_eaio_nativecall_NativeCall_initHandles@8 +EXTRN __imp__LoadLibraryA@4:NEAR +EXTRN __imp__GetLastError@0:NEAR +EXTRN __imp__FreeLibrary@4:NEAR +EXTRN __imp__GetProcAddress@8:NEAR +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_out$ = -1 +_moduleNameS$ = 12 +_functionNameS$ = -12 +_moduleName$ = 8 +_functionName$ = -8 +_addr$27794 = -16 +_Java_com_eaio_nativecall_NativeCall_initHandles@8 PROC NEAR + +; 135 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + sub esp, 16 ; 00000010H + +; 136 : +; 137 : bool out = JNI_TRUE; +; 138 : +; 139 : jstring moduleNameS = (jstring) env->GetObjectField(obj, fieldModule); + + mov eax, DWORD PTR ?fieldModule@@3PAU_jfieldID@@A ; fieldModule + push ebx + push esi + mov esi, DWORD PTR _env$[ebp] + push edi + mov edi, DWORD PTR _obj$[ebp] + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + mov BYTE PTR _out$[ebp], 1 + call DWORD PTR [ecx+380] + +; 140 : jstring functionNameS = (jstring) env->GetObjectField(obj, fieldFunction); + + mov ecx, DWORD PTR [esi] + mov DWORD PTR _moduleNameS$[ebp], eax + mov eax, DWORD PTR ?fieldFunction@@3PAU_jfieldID@@A ; fieldFunction + push eax + push edi + push esi + call DWORD PTR [ecx+380] + +; 141 : +; 142 : const char* moduleName = env->GetStringUTFChars(moduleNameS, 0); + + push 0 + mov DWORD PTR _functionNameS$[ebp], eax + push DWORD PTR _moduleNameS$[ebp] + mov eax, DWORD PTR [esi] + push esi + call DWORD PTR [eax+676] + +; 143 : const char* functionName = env->GetStringUTFChars(functionNameS, 0); + + push 0 + mov DWORD PTR _moduleName$[ebp], eax + push DWORD PTR _functionNameS$[ebp] + mov eax, DWORD PTR [esi] + push esi + call DWORD PTR [eax+676] + +; 144 : +; 145 : #ifdef _WINDOWS +; 146 : +; 147 : HMODULE mod = LoadLibrary(moduleName); + + push DWORD PTR _moduleName$[ebp] + mov DWORD PTR _functionName$[ebp], eax + call DWORD PTR __imp__LoadLibraryA@4 + mov ebx, eax + +; 148 : +; 149 : if (mod == NULL) { + + test ebx, ebx + jne SHORT $L27792 +$L27990: + +; 150 : /* no such module or DllMain returned FALSE */ +; 151 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + call DWORD PTR __imp__GetLastError@0 + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push edi + push esi + call DWORD PTR [ecx+436] + +; 152 : out = JNI_FALSE; + + and BYTE PTR _out$[ebp], 0 + +; 153 : } +; 154 : else { + + jmp SHORT $L27982 +$L27792: + +; 155 : FARPROC addr = GetProcAddress(mod, functionName); + + push DWORD PTR _functionName$[ebp] + push ebx + call DWORD PTR __imp__GetProcAddress@8 + +; 156 : if (addr == NULL) { + + test eax, eax + mov DWORD PTR _addr$27794[ebp], eax + jne SHORT $L27795 + +; 157 : /* function not found */ +; 158 : FreeLibrary(mod); + + push ebx + call DWORD PTR __imp__FreeLibrary@4 + +; 159 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); +; 160 : out = JNI_FALSE; +; 161 : } +; 162 : else { + + jmp SHORT $L27990 +$L27795: + +; 163 : /* all ok */ +; 164 : env->SetIntField(obj, fieldModuleHandle, (jint) mod); + + mov eax, DWORD PTR [esi] + push ebx + push DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle + push edi + push esi + call DWORD PTR [eax+436] + +; 165 : env->SetIntField(obj, fieldFunctionHandle, (jint) addr); + + push DWORD PTR _addr$27794[ebp] + mov eax, DWORD PTR [esi] + push DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push edi + push esi + call DWORD PTR [eax+436] +$L27982: + +; 166 : } +; 167 : } +; 168 : +; 169 : #endif +; 170 : +; 171 : env->ReleaseStringUTFChars(moduleNameS, moduleName); + + push DWORD PTR _moduleName$[ebp] + mov eax, DWORD PTR [esi] + push DWORD PTR _moduleNameS$[ebp] + push esi + call DWORD PTR [eax+680] + +; 172 : env->ReleaseStringUTFChars(functionNameS, functionName); + + push DWORD PTR _functionName$[ebp] + mov eax, DWORD PTR [esi] + push DWORD PTR _functionNameS$[ebp] + push esi + call DWORD PTR [eax+680] + +; 173 : +; 174 : return out; + + mov al, BYTE PTR _out$[ebp] + pop edi + pop esi + pop ebx + +; 175 : +; 176 : } + + leave + ret 8 +_Java_com_eaio_nativecall_NativeCall_initHandles@8 ENDP +_TEXT ENDS +PUBLIC _Java_com_eaio_nativecall_NativeCall_getLastError@8 +EXTRN __imp__FormatMessageA@28:NEAR +EXTRN __imp__LocalFree@4:NEAR +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_msgBufPtr$ = 8 +_Java_com_eaio_nativecall_NativeCall_getLastError@8 PROC NEAR + +; 184 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + +; 185 : +; 186 : jint lastError = env->GetIntField(obj, fieldLastErrorCode); + + mov eax, DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push esi + mov esi, DWORD PTR _env$[ebp] + push eax + push DWORD PTR _obj$[ebp] + mov ecx, DWORD PTR [esi] + push esi + call DWORD PTR [ecx+400] + +; 187 : +; 188 : if (lastError == 0) return NULL; + + xor ecx, ecx + cmp eax, ecx + jne SHORT $L27804 + xor eax, eax + jmp SHORT $L27802 +$L27804: + +; 189 : +; 190 : jstring out = NULL; +; 191 : +; 192 : #ifdef _WINDOWS +; 193 : +; 194 : LPVOID msgBufPtr = NULL; +; 195 : FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | +; 196 : FORMAT_MESSAGE_FROM_SYSTEM, NULL, lastError, 0, +; 197 : (LPSTR) &msgBufPtr, 0, NULL); + + push ecx + lea edx, DWORD PTR _msgBufPtr$[ebp] + push ecx + push edx + push ecx + push eax + push ecx + push 4352 ; 00001100H + mov DWORD PTR _msgBufPtr$[ebp], ecx + call DWORD PTR __imp__FormatMessageA@28 + +; 198 : +; 199 : out = env->NewStringUTF((char*) msgBufPtr); + + push DWORD PTR _msgBufPtr$[ebp] + mov eax, DWORD PTR [esi] + push esi + call DWORD PTR [eax+668] + +; 200 : +; 201 : LocalFree(msgBufPtr); + + push DWORD PTR _msgBufPtr$[ebp] + mov esi, eax + call DWORD PTR __imp__LocalFree@4 + +; 202 : +; 203 : #endif +; 204 : +; 205 : return out; + + mov eax, esi +$L27802: + pop esi + +; 206 : +; 207 : } + + pop ebp + ret 8 +_Java_com_eaio_nativecall_NativeCall_getLastError@8 ENDP +_TEXT ENDS +PUBLIC _Java_com_eaio_nativecall_NativeCall_destroy@8 +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_Java_com_eaio_nativecall_NativeCall_destroy@8 PROC NEAR + +; 216 : +; 217 : jint module = env->GetIntField(obj, fieldModuleHandle); + + mov eax, DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle + push esi + mov esi, DWORD PTR _env$[esp] + push edi + mov edi, DWORD PTR _obj$[esp+4] + push eax + mov ecx, DWORD PTR [esi] + push edi + push esi + call DWORD PTR [ecx+400] + +; 218 : +; 219 : if (module == 0) return; + + test eax, eax + je SHORT $L28016 + +; 220 : +; 221 : #ifdef _WINDOWS +; 222 : +; 223 : if (FreeLibrary((HMODULE) module) == 0) { + + push eax + call DWORD PTR __imp__FreeLibrary@4 + test eax, eax + jne SHORT $L28007 + +; 224 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + call DWORD PTR __imp__GetLastError@0 + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push edi + push esi + call DWORD PTR [ecx+436] +$L28007: + +; 225 : } +; 226 : +; 227 : #endif +; 228 : +; 229 : env->SetIntField(obj, fieldModuleHandle, 0); + + mov eax, DWORD PTR [esi] + push 0 + push DWORD PTR ?fieldModuleHandle@@3PAU_jfieldID@@A ; fieldModuleHandle + push edi + push esi + call DWORD PTR [eax+436] + +; 230 : env->SetIntField(obj, fieldFunctionHandle, 0); + + mov eax, DWORD PTR [esi] + push 0 + push DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push edi + push esi + call DWORD PTR [eax+436] +$L28016: + pop edi + pop esi + +; 231 : +; 232 : return; +; 233 : +; 234 : } + + ret 8 +_Java_com_eaio_nativecall_NativeCall_destroy@8 ENDP +_TEXT ENDS +END diff --git a/cpp/nativecall/Release/NativeCall.dll b/cpp/nativecall/Release/NativeCall.dll new file mode 100644 index 0000000000000000000000000000000000000000..6e2cad120371488b6f94c2cc7d2a953a4a8db09f GIT binary patch literal 7680 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 wsA^~>?jnpn+S1LUw8f48_LoQUKSsab(*OVf literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Release/RCa01380 b/cpp/nativecall/Release/RCa01380 new file mode 100644 index 0000000000000000000000000000000000000000..eb8e4b17d0d11871dd188167c7a6fac99cce7dcc GIT binary patch literal 4904 zcmds)U2hsk6o$`rrT&KvzDXq41%D)I?`*#078}c8(nyhzgTY3{V8PNRQh$7(cV;KM z3yYIFxggaFc6MgY*E{c=IkRIE8{5=|7FoqgR<&R49Z$_>Hn64LGcvW<7K~rhy5ZfS zFXoZlEhCzL%*eg#8PgNnoY^rt=5F-NJ|efSQ<5EKjhOp45_2@G@7zg`?JvHov?o03 zUod0fS_6CFQJ?0_85yHzYI|-*$$qpSY$q3+dVc0PW9EQaGi1DFc{X%^s!ywVb`wk{nXmlw@a(jTcdq$EqhB(hyOD>p{GSVcq0t9?+M<8cVtcCT}6E4 z*6p77W3UnqU84Sj|5Ku_5~uK})4$Je9p9i`?;VF_enqZ9_(LLByc!iW2QAx&qCE1k zEy2z+=BZrC?;g*>?Tk1?t+(IHOZcI^c*pm1x4YAx2|HNWyeMGEB0(>k6JIBNW4IC7 zvjkP2GjGs-Yz-Lb_g{y-cEwJt!ofavTRgJ!4^OmFvWt#O_%4Y$@-H$L!y5MOjpO)1 z!oL8e!kstSLd4TiReAC`kZWJcMebv7#d-mNt6> z`^bz_N$1d%JB029x{;LJxmKcejSsU-{>V!Q4{OZK*5>}M5VRECHX`h)()V|e$lWB~ zyHj$GA8EcSwwK=x!Hzf@IhJZo)Glw-)WYLiJeW8H9ebFPtorqUxt@Ik-^n^ ziN@bR;|{qgPXsGgS0^O=6mQ)q- z+WHk~+~j3m(^C*mPrP6bhX3N(WYR_!7l|6Nyku{a2{CSa;{Ux!n`NYzmNUP$f)XCd@KIPE}x9I$7`+uuJ hzwXYg>gscM=Cp#Xz_9P*F1%^?Ovy|!F@FgQ{sr%EaLfPz literal 0 HcmV?d00001 diff --git a/cpp/nativecall/Release/VoidCall.asm b/cpp/nativecall/Release/VoidCall.asm new file mode 100644 index 0000000..5160082 --- /dev/null +++ b/cpp/nativecall/Release/VoidCall.asm @@ -0,0 +1,919 @@ + TITLE C:\Documents and Settings\Administrator\My Documents\Software\NativeCall\src\cpp\VoidCall.cpp + .386P +include listing.inc +if @Version gt 510 +.model FLAT +else +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +CONST SEGMENT DWORD USE32 PUBLIC 'CONST' +CONST ENDS +_BSS SEGMENT DWORD USE32 PUBLIC 'BSS' +_BSS ENDS +_TLS SEGMENT DWORD USE32 PUBLIC 'TLS' +_TLS ENDS +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +_DATA SEGMENT DWORD USE32 PUBLIC 'DATA' +_DATA ENDS +; COMDAT ?FindClass@JNIEnv_@@QAEPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ThrowNew@JNIEnv_@@QAEJPAV_jclass@@PBD@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?IsInstanceOf@JNIEnv_@@QAEEPAV_jobject@@PAV_jclass@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectField@JNIEnv_@@QAEPAV_jobject@@PAV2@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetIntField@JNIEnv_@@QAEJPAV_jobject@@PAU_jfieldID@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetObjectField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@0@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?SetIntField@JNIEnv_@@QAEXPAV_jobject@@PAU_jfieldID@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetArrayLength@JNIEnv_@@QAEJPAV_jarray@@@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetObjectArrayElement@JNIEnv_@@QAEPAV_jobject@@PAV_jobjectArray@@J@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?GetPrimitiveArrayCritical@JNIEnv_@@QAEPAXPAV_jarray@@PAE@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +; COMDAT ?ReleasePrimitiveArrayCritical@JNIEnv_@@QAEXPAV_jarray@@PAXJ@Z +_TEXT SEGMENT PARA USE32 PUBLIC 'CODE' +_TEXT ENDS +FLAT GROUP _DATA, CONST, _BSS + ASSUME CS: FLAT, DS: FLAT, SS: FLAT +endif +PUBLIC _Java_com_eaio_nativecall_VoidCall_executeCall@8 +EXTRN ?fieldFunctionHandle@@3PAU_jfieldID@@A:DWORD ; fieldFunctionHandle +EXTRN ?fieldLastErrorCode@@3PAU_jfieldID@@A:DWORD ; fieldLastErrorCode +EXTRN __imp__GetLastError@0:NEAR +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_functionHandle$ = 8 +_Java_com_eaio_nativecall_VoidCall_executeCall@8 PROC NEAR + +; 79 : (JNIEnv *env, jobject obj) { + + push ebp + mov ebp, esp + +; 80 : +; 81 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov eax, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + push esi + mov esi, DWORD PTR _env$[ebp] + push eax + push DWORD PTR _obj$[ebp] + mov ecx, DWORD PTR [esi] + push esi + call DWORD PTR [ecx+400] + mov DWORD PTR _functionHandle$[ebp], eax + +; 82 : +; 83 : #ifdef _WINDOWS +; 84 : #ifdef _X86_ +; 85 : +; 86 : __asm { +; 87 : +; 88 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 89 : +; 90 : } +; 91 : +; 92 : #endif +; 93 : #endif +; 94 : +; 95 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + call DWORD PTR __imp__GetLastError@0 + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push DWORD PTR _obj$[ebp] + push esi + call DWORD PTR [ecx+436] + +; 96 : +; 97 : } + + pop esi + pop ebp + ret 8 +_Java_com_eaio_nativecall_VoidCall_executeCall@8 ENDP +_TEXT ENDS +PUBLIC ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' +PUBLIC _Java_com_eaio_nativecall_VoidCall_executeCall0@12 +PUBLIC ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject +PUBLIC ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod +PUBLIC ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod +EXTRN ?fieldHolderO@@3PAU_jfieldID@@A:DWORD ; fieldHolderO +EXTRN ?classBoolean@@3PAV_jclass@@A:DWORD ; classBoolean +EXTRN ?classInteger@@3PAV_jclass@@A:DWORD ; classInteger +EXTRN ?classByteArray@@3PAV_jclass@@A:DWORD ; classByteArray +EXTRN ?classCharArray@@3PAV_jclass@@A:DWORD ; classCharArray +EXTRN ?classHolder@@3PAV_jclass@@A:DWORD ; classHolder +EXTRN ?methodBooleanValue@@3PAU_jmethodID@@A:DWORD ; methodBooleanValue +EXTRN ?methodIntValue@@3PAU_jmethodID@@A:DWORD ; methodIntValue +EXTRN ?newIntegerInt@@3PAU_jmethodID@@A:DWORD ; newIntegerInt +EXTRN ?newBooleanBoolean@@3PAU_jmethodID@@A:DWORD ; newBooleanBoolean +EXTRN ??2@YAPAXI@Z:NEAR ; operator new +EXTRN ??3@YAXPAX@Z:NEAR ; operator delete +EXTRN _memset:NEAR +; COMDAT ??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ +; File C:\Program Files\IBMJava13\include\jni.h +_DATA SEGMENT +??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ DB 'java/lang/OutOfMemor' + DB 'yError', 00H ; `string' +_DATA ENDS +_TEXT SEGMENT +_env$ = 8 +_obj$ = 12 +_params$ = 16 +_len$ = -28 +_arrays$ = -20 +_param$ = -24 +_i$ = 8 +_intArg$27769 = -24 +_byteArrayArg$27772 = -4 +_charArrayArg$27778 = -8 +_tempArg$27785 = -24 +_intPtr$27790 = -24 +_byteArrayArg$27796 = -12 +_charArrayArg$27802 = -16 +_tempPtr$27809 = -24 +_functionHandle$ = 8 +_j$ = 8 +_Java_com_eaio_nativecall_VoidCall_executeCall0@12 PROC NEAR + +; 105 : (JNIEnv *env, jobject obj, jobjectArray params) { + + push ebp + mov ebp, esp + sub esp, 28 ; 0000001cH + push ebx + push esi + +; 106 : +; 107 : const int len = env->GetArrayLength(params); + + mov esi, DWORD PTR _env$[ebp] + push edi + push DWORD PTR _params$[ebp] + mov eax, DWORD PTR [esi] + push esi + call DWORD PTR [eax+684] + mov ebx, eax + +; 108 : +; 109 : int* arrays = NULL; +; 110 : if (!(arrays = new int[len])) { + + mov edi, ebx + mov DWORD PTR _len$[ebp], ebx + shl edi, 2 + push edi + call ??2@YAPAXI@Z ; operator new + test eax, eax + pop ecx + mov DWORD PTR _arrays$[ebp], eax + jne SHORT $L27758 + +; 111 : env->ThrowNew(env->FindClass("java/lang/OutOfMemoryError"), NULL); + + mov eax, DWORD PTR [esi] + push OFFSET FLAT:??_C@_0BL@NKOM@java?1lang?1OutOfMemoryError?$AA@ ; `string' + push esi + call DWORD PTR [eax+24] + mov ecx, DWORD PTR [esi] + push 0 + push eax + push esi + call DWORD PTR [ecx+56] + +; 112 : return; + + jmp $L28021 +$L27758: + +; 113 : } +; 114 : memset(arrays, 0, (sizeof(int) * len)); + + push edi + push 0 + push eax + call _memset + +; 115 : +; 116 : jobject param; +; 117 : +; 118 : for (int i = len - 1; i >= 0; i--) { + + lea eax, DWORD PTR [ebx-1] + add esp, 12 ; 0000000cH + test eax, eax + mov DWORD PTR _i$[ebp], eax + jl $L27765 + mov ecx, DWORD PTR _arrays$[ebp] + lea edi, DWORD PTR [ecx+eax*4] + jmp SHORT $L27763 +$L28028: + +; 113 : } +; 114 : memset(arrays, 0, (sizeof(int) * len)); + + mov eax, DWORD PTR _i$[ebp] +$L27763: + +; 119 : +; 120 : param = env->GetObjectArrayElement(params, i); + + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR _params$[ebp] + push esi + call DWORD PTR [ecx+692] + mov ebx, eax + +; 121 : +; 122 : if (param == NULL) { + + test ebx, ebx + jne SHORT $L27766 + +; 123 : _push(0); + + push 0 + +; 124 : } +; 125 : else if (env->IsInstanceOf(param, classInteger)) { + + jmp $L27764 +$L27766: + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27768 + +; 126 : int intArg = env->CallIntMethod(param, methodIntValue); + + push DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push ebx + push esi + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + add esp, 12 ; 0000000cH + mov DWORD PTR _intArg$27769[ebp], eax + +; 127 : _push(intArg) + + push DWORD PTR _intArg$27769[ebp] + +; 128 : } +; 129 : else if (env->IsInstanceOf(param, classByteArray)) { + + jmp $L27764 +$L27768: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27771 + +; 130 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) param, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _byteArrayArg$27772[ebp], eax + +; 131 : arrays[i] = (int) &byteArrayArg; + + lea eax, DWORD PTR _byteArrayArg$27772[ebp] + mov DWORD PTR [edi], eax + +; 132 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$27772[ebp] + +; 133 : } +; 134 : else if (env->IsInstanceOf(param, classCharArray)) { + + jmp $L27764 +$L27771: + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27777 + +; 135 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 136 : (jarray) param, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _charArrayArg$27778[ebp], eax + +; 137 : arrays[i] = (int) &charArrayArg; + + lea eax, DWORD PTR _charArrayArg$27778[ebp] + mov DWORD PTR [edi], eax + +; 138 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$27778[ebp] + +; 139 : } +; 140 : else if (env->IsInstanceOf(param, classBoolean)) { + + jmp $L27764 +$L27777: + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27783 + +; 141 : jboolean booleanArg = env->CallBooleanMethod(param, methodBooleanValue); + + push DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ebx + push esi + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + add esp, 12 ; 0000000cH + +; 142 : int tempArg = (booleanArg == JNI_FALSE ? 0 : 1); + + neg al + sbb eax, eax + neg eax + mov DWORD PTR _tempArg$27785[ebp], eax + +; 143 : _push(tempArg) + + push DWORD PTR _tempArg$27785[ebp] + +; 144 : } +; 145 : else if (env->IsInstanceOf(param, classHolder)) { + + jmp $L27764 +$L27783: + mov eax, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je $L27764 + +; 146 : +; 147 : /* Holder */ +; 148 : +; 149 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov eax, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+380] + +; 150 : +; 151 : if (env->IsInstanceOf(o, classInteger)) { + + mov ecx, DWORD PTR [esi] + mov ebx, eax + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27789 + +; 152 : int *intPtr = new int; + + push 4 + call ??2@YAPAXI@Z ; operator new + pop ecx + mov DWORD PTR _intPtr$27790[ebp], eax + +; 153 : *intPtr = env->CallIntMethod(o, methodIntValue); + + push DWORD PTR ?methodIntValue@@3PAU_jmethodID@@A ; methodIntValue + push ebx + push esi + call ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallIntMethod + mov ecx, DWORD PTR _intPtr$27790[ebp] + add esp, 12 ; 0000000cH + +; 154 : arrays[i] = (int) intPtr; + + mov DWORD PTR [edi], ecx + mov DWORD PTR [ecx], eax + +; 155 : _push(intPtr); + + push DWORD PTR _intPtr$27790[ebp] + +; 156 : } +; 157 : else if (env->IsInstanceOf(o, classByteArray)) { + + jmp $L27764 +$L27789: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27795 + +; 158 : char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) o, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _byteArrayArg$27796[ebp], eax + +; 159 : arrays[i] = (int) &byteArrayArg; + + lea eax, DWORD PTR _byteArrayArg$27796[ebp] + mov DWORD PTR [edi], eax + +; 160 : _push(byteArrayArg) + + push DWORD PTR _byteArrayArg$27796[ebp] + +; 161 : } +; 162 : else if (env->IsInstanceOf(o, classCharArray)) { + + jmp SHORT $L27764 +$L27795: + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27801 + +; 163 : unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( +; 164 : (jarray) o, 0); + + mov eax, DWORD PTR [esi] + push 0 + push ebx + push esi + call DWORD PTR [eax+888] + mov DWORD PTR _charArrayArg$27802[ebp], eax + +; 165 : arrays[i] = (int) &charArrayArg; + + lea eax, DWORD PTR _charArrayArg$27802[ebp] + mov DWORD PTR [edi], eax + +; 166 : _push(charArrayArg) + + push DWORD PTR _charArrayArg$27802[ebp] + +; 167 : } +; 168 : else if (env->IsInstanceOf(o, classBoolean)) { + + jmp SHORT $L27764 +$L27801: + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + mov ecx, DWORD PTR [esi] + push eax + push ebx + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27764 + +; 169 : jboolean booleanArg = env->CallBooleanMethod(o, methodBooleanValue); + + push DWORD PTR ?methodBooleanValue@@3PAU_jmethodID@@A ; methodBooleanValue + push ebx + push esi + call ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ; JNIEnv_::CallBooleanMethod + +; 170 : int *tempPtr = new int; + + push 4 + mov bl, al + call ??2@YAPAXI@Z ; operator new + add esp, 16 ; 00000010H + +; 171 : *tempPtr = (booleanArg == JNI_FALSE ? 0 : 1); + + xor ecx, ecx + test bl, bl + setne cl + mov DWORD PTR _tempPtr$27809[ebp], eax + mov DWORD PTR [eax], ecx + +; 172 : arrays[i] = (int) tempPtr; + + mov DWORD PTR [edi], eax + +; 173 : _push(tempPtr); + + push DWORD PTR _tempPtr$27809[ebp] + +; 172 : arrays[i] = (int) tempPtr; + +$L27764: + dec DWORD PTR _i$[ebp] + sub edi, 4 + cmp DWORD PTR _i$[ebp], 0 + jge $L28028 + +; 115 : +; 116 : jobject param; +; 117 : +; 118 : for (int i = len - 1; i >= 0; i--) { + + mov ebx, DWORD PTR _len$[ebp] +$L27765: + +; 174 : } +; 175 : +; 176 : /* end Holder */ +; 177 : +; 178 : } +; 179 : +; 180 : } +; 181 : +; 182 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov eax, DWORD PTR ?fieldFunctionHandle@@3PAU_jfieldID@@A ; fieldFunctionHandle + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR _obj$[ebp] + push esi + call DWORD PTR [ecx+400] + mov DWORD PTR _functionHandle$[ebp], eax + +; 183 : +; 184 : #ifdef _WINDOWS +; 185 : #ifdef _X86_ +; 186 : +; 187 : __asm { +; 188 : +; 189 : call functionHandle + + call DWORD PTR _functionHandle$[ebp] + +; 190 : +; 191 : } +; 192 : +; 193 : #endif +; 194 : #endif +; 195 : +; 196 : for (int j = 0; j < len; ++j) { + + and DWORD PTR _j$[ebp], 0 + test ebx, ebx + jle $L27817 + +; 174 : } +; 175 : +; 176 : /* end Holder */ +; 177 : +; 178 : } +; 179 : +; 180 : } +; 181 : +; 182 : jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + + mov ebx, DWORD PTR _arrays$[ebp] +$L27815: + +; 197 : param = env->GetObjectArrayElement(params, j); + + push DWORD PTR _j$[ebp] + mov eax, DWORD PTR [esi] + push DWORD PTR _params$[ebp] + push esi + call DWORD PTR [eax+692] + mov edi, eax + +; 198 : if (param == NULL) {} + + test edi, edi + mov DWORD PTR _param$[ebp], edi + je $L27816 + +; 199 : else if (env->IsInstanceOf(param, classByteArray) || env->IsInstanceOf(param, classCharArray)) { + + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne $L27833 + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne $L27833 + +; 201 : } +; 202 : else if (env->IsInstanceOf(param, classHolder)) { + + mov eax, DWORD PTR ?classHolder@@3PAV_jclass@@A ; classHolder + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + je $L27816 + +; 203 : +; 204 : jobject o = env->GetObjectField(param, fieldHolderO); + + mov eax, DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+380] + +; 205 : +; 206 : if (env->IsInstanceOf(o, classInteger)) { + + mov ecx, DWORD PTR [esi] + mov edi, eax + mov eax, DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27827 + +; 207 : int* out = (int*) arrays[j]; + + mov edi, DWORD PTR [ebx] + +; 208 : env->SetObjectField(param, fieldHolderO, env->NewObject(classInteger, newIntegerInt, *out)); + + push DWORD PTR [edi] + push DWORD PTR ?newIntegerInt@@3PAU_jmethodID@@A ; newIntegerInt + push DWORD PTR ?classInteger@@3PAV_jclass@@A ; classInteger +$L28031: + push esi + call ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ; JNIEnv_::NewObject + add esp, 16 ; 00000010H + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldHolderO@@3PAU_jfieldID@@A ; fieldHolderO + push DWORD PTR _param$[ebp] + push esi + call DWORD PTR [ecx+416] + +; 209 : delete out; + + push edi + call ??3@YAXPAX@Z ; operator delete + pop ecx + +; 210 : } +; 211 : else if (env->IsInstanceOf(o, classByteArray) || env->IsInstanceOf(o, classCharArray)) { + + jmp SHORT $L27816 +$L27827: + mov eax, DWORD PTR ?classByteArray@@3PAV_jclass@@A ; classByteArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne SHORT $L27833 + mov eax, DWORD PTR ?classCharArray@@3PAV_jclass@@A ; classCharArray + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + jne SHORT $L27833 + +; 212 : env->ReleasePrimitiveArrayCritical((jarray) o, (void*) arrays[j], 0); +; 213 : } +; 214 : else if (env->IsInstanceOf(o, classBoolean)) { + + mov eax, DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + mov ecx, DWORD PTR [esi] + push eax + push edi + push esi + call DWORD PTR [ecx+128] + test al, al + je SHORT $L27816 + +; 215 : int* out = (int*) arrays[j]; + + mov edi, DWORD PTR [ebx] + +; 216 : env->SetObjectField(param, fieldHolderO, env->NewObject(classBoolean, newBooleanBoolean, (*out == 0 ? JNI_FALSE : JNI_TRUE))); + + xor eax, eax + cmp DWORD PTR [edi], eax + setne al + push eax + push DWORD PTR ?newBooleanBoolean@@3PAU_jmethodID@@A ; newBooleanBoolean + push DWORD PTR ?classBoolean@@3PAV_jclass@@A ; classBoolean + +; 217 : delete out; + + jmp SHORT $L28031 +$L27833: + +; 200 : env->ReleasePrimitiveArrayCritical((jarray) param, (void*) arrays[j], 0); + + mov eax, DWORD PTR [esi] + push 0 + push DWORD PTR [ebx] + push edi + push esi + call DWORD PTR [eax+892] +$L27816: + inc DWORD PTR _j$[ebp] + mov eax, DWORD PTR _j$[ebp] + add ebx, 4 + cmp eax, DWORD PTR _len$[ebp] + jl $L27815 +$L27817: + +; 218 : } +; 219 : +; 220 : } +; 221 : +; 222 : } +; 223 : +; 224 : delete [] arrays; + + push DWORD PTR _arrays$[ebp] + call ??3@YAXPAX@Z ; operator delete + pop ecx + +; 225 : +; 226 : env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + + call DWORD PTR __imp__GetLastError@0 + mov ecx, DWORD PTR [esi] + push eax + push DWORD PTR ?fieldLastErrorCode@@3PAU_jfieldID@@A ; fieldLastErrorCode + push DWORD PTR _obj$[ebp] + push esi + call DWORD PTR [ecx+436] +$L28021: + +; 227 : +; 228 : } + + pop edi + pop esi + pop ebx + leave + ret 12 ; 0000000cH +_Java_com_eaio_nativecall_VoidCall_executeCall0@12 ENDP +_TEXT ENDS +; COMDAT ?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_clazz$ = 12 +_methodID$ = 16 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::NewObject, COMDAT + +; 835 : va_list args; +; 836 : jobject result; +; 837 : va_start(args, methodID); +; 838 : result = functions->NewObjectV(this,clazz,methodID,args); + + mov eax, DWORD PTR _this$[esp-4] + lea edx, DWORD PTR _methodID$[esp] + push edx + push DWORD PTR _methodID$[esp] + mov ecx, DWORD PTR [eax] + push DWORD PTR _clazz$[esp+4] + push eax + call DWORD PTR [ecx+116] + +; 839 : va_end(args); +; 840 : return result; +; 841 : } + + ret 0 +?NewObject@JNIEnv_@@QAAPAV_jobject@@PAV_jclass@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::NewObject +_TEXT ENDS +; COMDAT ?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_obj$ = 12 +_methodID$ = 16 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallBooleanMethod, COMDAT + +; 882 : va_list args; +; 883 : jboolean result; +; 884 : va_start(args,methodID); +; 885 : result = functions->CallBooleanMethodV(this,obj,methodID,args); + + mov eax, DWORD PTR _this$[esp-4] + lea edx, DWORD PTR _methodID$[esp] + push edx + push DWORD PTR _methodID$[esp] + mov ecx, DWORD PTR [eax] + push DWORD PTR _obj$[esp+4] + push eax + call DWORD PTR [ecx+152] + +; 886 : va_end(args); +; 887 : return result; +; 888 : } + + ret 0 +?CallBooleanMethod@JNIEnv_@@QAAEPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallBooleanMethod +_TEXT ENDS +; COMDAT ?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ +_TEXT SEGMENT +_this$ = 8 +_obj$ = 12 +_methodID$ = 16 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ PROC NEAR ; JNIEnv_::CallIntMethod, COMDAT + +; 950 : va_list args; +; 951 : jint result; +; 952 : va_start(args,methodID); +; 953 : result = functions->CallIntMethodV(this,obj,methodID,args); + + mov eax, DWORD PTR _this$[esp-4] + lea edx, DWORD PTR _methodID$[esp] + push edx + push DWORD PTR _methodID$[esp] + mov ecx, DWORD PTR [eax] + push DWORD PTR _obj$[esp+4] + push eax + call DWORD PTR [ecx+200] + +; 954 : va_end(args); +; 955 : return result; +; 956 : } + + ret 0 +?CallIntMethod@JNIEnv_@@QAAJPAV_jobject@@PAU_jmethodID@@ZZ ENDP ; JNIEnv_::CallIntMethod +_TEXT ENDS +END diff --git a/cpp/nativecall/Release/VoidCall.obj b/cpp/nativecall/Release/VoidCall.obj new file mode 100644 index 0000000000000000000000000000000000000000..3edebca899b9e4043a8eeb99c1ddc7ad93c8db9a GIT binary patch literal 3885 zcmbVPe{2&~9Dm(Pci>#B4h6wb!X#vYF_`=ikY3pi7_M8PtYgq|-rC#N()PCYZfpXH zW?M`-YK95Q9~wjx6c{#*oZcYd06Wf)}irt3X z0bniY?a*~`sCylbUAcVN@9uf>382?A555!gIphP?1H9 z*{%Q6u$tYl(b=p{UBvbEs|w@Qlv1_Kubmx+%BDC*Yi6{?cu+0#YMU?s1sMJuhL5&g zWe^w-OfC0e+ZIi6s5ZYg{3$F9byWQ~)pqO3FGVdGY&JB~n&PIErK+t9zxp-r616OX zynb!})`>TY5o&=KqM5GM2CkP5jevLinHlh-dZyAlUY#sfIR;0eIIw@>VrWb$iJ*z= zpmY(l!mtkpUjaBcA}^x>`}~9!I8$6kQ!*3h3ac+yZ4m_K!+j71n@ z98anzgLAj1EI9e|Ief3cJJbs1#hm<|G z)1&%yIBISTj@i#$fp}94w$ErDX5csLz$pgV)AoCsrncQO2WXp_R~=5mX8N zqXY@iJKH)L{P&qmcXfct!2dJE&F91;=Hvu_`-j9H&w=qD}+aG|aw-xa5pxzn)QEvhu z>a7b9_0|K3^1TCy*5GGAlw}$aWpO}(X;fFT41{994!Jw=O_Ya$@-`e?_A%c$W0v{ zF(xJYxkN%rAhoW-nm$ZSKBXN1AgKdKY^RHRnV6dwm5qp#)uKl88^cS zSMq*F-@;fyBRpXxsH!6zH7+LiG=w^Bwc7%9Qc#JBaXIM};vuI`l;v=|GZ}D)V&Ql= zDJKM3N(4Op&a7U*Cw0ijg@hPrB!?(IF9XR$Fc9qS4j6}N6}*5?b7SG~?XC)kHm`mJ zY2dvWneR%lmQb+;-jQM~O$q1oe$Pq_o_kq|!Q;dU>5ckg^CWF~lEFL)-j+tA zJXiB1<9U(=RFxPOAwDL?lA>|j#4($1m3UzlTa0D)EBEn-Mh>v0bRMij;lV63;W6D} z@eCAO@aDp8=LL4HVS^C<7~p0_#L9FBT>#Qz3%-RKNmvnw%A*_Ox5%wfK?`K!`d=5d{w$zxua$IKAsXP`_Ed(T9!j<6UFH3&(Wd_ZcY zkjSz%UUxGeAtUv5EbB%*AC7hN{2o!xYO>Y3?QSI=l*3YdFKpmwLF0$I`{FAsa>d2t zyCf+p3UU2m1QiqIE-6H#a=B{QR`(&V`w)AWnAFE*u~SUIqo6uTXs;9viHRmd!IY#c z7!{I9I!=cDe1wQ_1zgmz9*tj!D%n)$ghUL?G0!0(qqSW^!ktJ6{rOI)b-yg$XIys` zmmd&-UWj}LF20uKt9Lc9jW0HNSbUJUHsF)QwITN?aaFk8EONOvLW!Zm^|-{1;_;^T z2>iih_chjY@m`)~_q$;fa+Ii?B`) + * + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#include +#include "com_eaio_nativecall_VoidCall.h" + +#ifdef _WINDOWS +#include +#include +#endif + +#ifdef _WINDOWS +#ifdef _X86_ + +#define _push(x) __asm { push x }; + +#endif +#endif + +// NativeCall fields + +extern jfieldID fieldFunction, fieldModule, fieldFunctionHandle, + fieldModuleHandle, fieldLastErrorCode; + +// Holder fields + +extern jfieldID fieldHolderO; + +// Classes + +extern jclass classBoolean,/* classByte, classCharacter, classShort,*/ + classInteger, /* classLong, classFloat, classDouble,*/ classString, + classByteArray, classCharArray, /*classIntArray,*/ classHolder; + +// Wrapper class methods + +extern jmethodID methodBooleanValue,/* methodByteValue, methodCharValue, +methodShortValue,*/ methodIntValue/*, methodLongValue, methodFloatValue, +methodDoubleValue*/; + +// Constructors + +extern jmethodID newIntegerInt, newBooleanBoolean; + +/* + * Class: com_eaio_nativecall_VoidCall + * Method: executeCall + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_VoidCall_executeCall +(JNIEnv *env, jobject obj) { + + jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + +#ifdef _WINDOWS +#ifdef _X86_ + + __asm { + + call functionHandle + + } + +#endif +#endif + + env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + +} + +/* + * Class: com_eaio_nativecall_VoidCall + * Method: executeCall0 + * Signature: ([Ljava/lang/Object;)V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_VoidCall_executeCall0 +(JNIEnv *env, jobject obj, jobjectArray params) { + + const int len = env->GetArrayLength(params); + + int* arrays = NULL; + if (!(arrays = new int[len])) { + env->ThrowNew(env->FindClass("java/lang/OutOfMemoryError"), NULL); + return; + } + memset(arrays, 0, (sizeof(int) * len)); + + jobject param; + + for (int i = len - 1; i >= 0; i--) { + + param = env->GetObjectArrayElement(params, i); + + if (param == NULL) { + _push(0); + } + else if (env->IsInstanceOf(param, classInteger)) { + int intArg = env->CallIntMethod(param, methodIntValue); + _push(intArg) + } + else if (env->IsInstanceOf(param, classByteArray)) { + char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) param, 0); + arrays[i] = (int) &byteArrayArg; + _push(byteArrayArg) + } + else if (env->IsInstanceOf(param, classCharArray)) { + unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( + (jarray) param, 0); + arrays[i] = (int) &charArrayArg; + _push(charArrayArg) + } + else if (env->IsInstanceOf(param, classBoolean)) { + jboolean booleanArg = env->CallBooleanMethod(param, methodBooleanValue); + int tempArg = (booleanArg == JNI_FALSE ? 0 : 1); + _push(tempArg) + } + else if (env->IsInstanceOf(param, classHolder)) { + + /* Holder */ + + jobject o = env->GetObjectField(param, fieldHolderO); + + if (env->IsInstanceOf(o, classInteger)) { + int *intPtr = new int; + *intPtr = env->CallIntMethod(o, methodIntValue); + arrays[i] = (int) intPtr; + _push(intPtr); + } + else if (env->IsInstanceOf(o, classByteArray)) { + char* byteArrayArg = (char*) env->GetPrimitiveArrayCritical((jarray) o, 0); + arrays[i] = (int) &byteArrayArg; + _push(byteArrayArg) + } + else if (env->IsInstanceOf(o, classCharArray)) { + unsigned short* charArrayArg = (unsigned short*) env->GetPrimitiveArrayCritical( + (jarray) o, 0); + arrays[i] = (int) &charArrayArg; + _push(charArrayArg) + } + else if (env->IsInstanceOf(o, classBoolean)) { + jboolean booleanArg = env->CallBooleanMethod(o, methodBooleanValue); + int *tempPtr = new int; + *tempPtr = (booleanArg == JNI_FALSE ? 0 : 1); + arrays[i] = (int) tempPtr; + _push(tempPtr); + } + + /* end Holder */ + + } + + } + + jint functionHandle = env->GetIntField(obj, fieldFunctionHandle); + +#ifdef _WINDOWS +#ifdef _X86_ + + __asm { + + call functionHandle + + } + +#endif +#endif + + for (int j = 0; j < len; ++j) { + param = env->GetObjectArrayElement(params, j); + if (param == NULL) {} + else if (env->IsInstanceOf(param, classByteArray) || env->IsInstanceOf(param, classCharArray)) { + env->ReleasePrimitiveArrayCritical((jarray) param, (void*) arrays[j], 0); + } + else if (env->IsInstanceOf(param, classHolder)) { + + jobject o = env->GetObjectField(param, fieldHolderO); + + if (env->IsInstanceOf(o, classInteger)) { + int* out = (int*) arrays[j]; + env->SetObjectField(param, fieldHolderO, env->NewObject(classInteger, newIntegerInt, *out)); + delete out; + } + else if (env->IsInstanceOf(o, classByteArray) || env->IsInstanceOf(o, classCharArray)) { + env->ReleasePrimitiveArrayCritical((jarray) o, (void*) arrays[j], 0); + } + else if (env->IsInstanceOf(o, classBoolean)) { + int* out = (int*) arrays[j]; + env->SetObjectField(param, fieldHolderO, env->NewObject(classBoolean, newBooleanBoolean, (*out == 0 ? JNI_FALSE : JNI_TRUE))); + delete out; + } + + } + + } + + delete [] arrays; + + env->SetIntField(obj, fieldLastErrorCode, GetLastError()); + +} \ No newline at end of file diff --git a/cpp/nativecall/com_eaio_nativecall_IntCall.h b/cpp/nativecall/com_eaio_nativecall_IntCall.h new file mode 100644 index 0000000..3940b16 --- /dev/null +++ b/cpp/nativecall/com_eaio_nativecall_IntCall.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class com_eaio_nativecall_IntCall */ + +#ifndef _Included_com_eaio_nativecall_IntCall +#define _Included_com_eaio_nativecall_IntCall +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: com_eaio_nativecall_IntCall + * Method: executeCall + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_com_eaio_nativecall_IntCall_executeCall + (JNIEnv *, jobject); + +/* + * Class: com_eaio_nativecall_IntCall + * Method: executeCall0 + * Signature: ([Ljava/lang/Object;)I + */ +JNIEXPORT jint JNICALL Java_com_eaio_nativecall_IntCall_executeCall0 + (JNIEnv *, jobject, jobjectArray); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/cpp/nativecall/com_eaio_nativecall_NativeCall.h b/cpp/nativecall/com_eaio_nativecall_NativeCall.h new file mode 100644 index 0000000..2e92b91 --- /dev/null +++ b/cpp/nativecall/com_eaio_nativecall_NativeCall.h @@ -0,0 +1,45 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class com_eaio_nativecall_NativeCall */ + +#ifndef _Included_com_eaio_nativecall_NativeCall +#define _Included_com_eaio_nativecall_NativeCall +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: com_eaio_nativecall_NativeCall + * Method: initIDs + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_NativeCall_initIDs + (JNIEnv *, jclass); + +/* + * Class: com_eaio_nativecall_NativeCall + * Method: initHandles + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_com_eaio_nativecall_NativeCall_initHandles + (JNIEnv *, jobject); + +/* + * Class: com_eaio_nativecall_NativeCall + * Method: getLastError + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_com_eaio_nativecall_NativeCall_getLastError + (JNIEnv *, jobject); + +/* + * Class: com_eaio_nativecall_NativeCall + * Method: destroy + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_NativeCall_destroy + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/cpp/nativecall/com_eaio_nativecall_VoidCall.h b/cpp/nativecall/com_eaio_nativecall_VoidCall.h new file mode 100644 index 0000000..e72afb9 --- /dev/null +++ b/cpp/nativecall/com_eaio_nativecall_VoidCall.h @@ -0,0 +1,29 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class com_eaio_nativecall_VoidCall */ + +#ifndef _Included_com_eaio_nativecall_VoidCall +#define _Included_com_eaio_nativecall_VoidCall +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: com_eaio_nativecall_VoidCall + * Method: executeCall + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_VoidCall_executeCall + (JNIEnv *, jobject); + +/* + * Class: com_eaio_nativecall_VoidCall + * Method: executeCall0 + * Signature: ([Ljava/lang/Object;)V + */ +JNIEXPORT void JNICALL Java_com_eaio_nativecall_VoidCall_executeCall0 + (JNIEnv *, jobject, jobjectArray); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/cpp/nativecall/readme.txt b/cpp/nativecall/readme.txt new file mode 100644 index 0000000..7799a92 --- /dev/null +++ b/cpp/nativecall/readme.txt @@ -0,0 +1,25 @@ +# $Id: readme.txt,v 1.1 2006/01/05 19:55:58 grnull Exp $ + +Hi, + +this is the readme file for people who want to build the native libraries for +NativeCall themselves. + +Compiling the native libraries requires some header files (after all, it's +just C++). + +Search for + + jni.h + +which is required. You will most likey also need jni_md.h and +jniproto_md.h. Copy these files to this directory. + +The library has been compiled and is set up for libctiny.lib to make the +binaries even smaller. You can download libctiny.lib from + + + +After you downloaded it, extract libctiny.lib to this folder. You also might +have to change the paths for the compiler and the linker. + diff --git a/cpp/nativecall/resource.h b/cpp/nativecall/resource.h new file mode 100644 index 0000000..e9f970e --- /dev/null +++ b/cpp/nativecall/resource.h @@ -0,0 +1,15 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by version.rc +// + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 103 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1000 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/cpp/nativecall/version.rc b/cpp/nativecall/version.rc new file mode 100644 index 0000000..69ae71a --- /dev/null +++ b/cpp/nativecall/version.rc @@ -0,0 +1,104 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// Deutsch (Deutschland) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU) +#ifdef _WIN32 +LANGUAGE LANG_GERMAN, SUBLANG_GERMAN +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +#ifndef _MAC +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 0,4,1,0 + PRODUCTVERSION 0,4,1,0 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x40004L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040704b0" + BEGIN + VALUE "CompanyName", "eaio\0" + VALUE "FileDescription", "NativeCall native library\0" + VALUE "FileVersion", "0, 4, 1, 0\0" + VALUE "LegalCopyright", "2003-2006 Johann Burkard\0" + VALUE "OriginalFilename", "NativeCall.dll\0" + VALUE "ProductName", "NativeCall\0" + VALUE "ProductVersion", "0, 4, 1, 0\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x407, 1200 + END +END + +#endif // !_MAC + +#endif // Deutsch (Deutschland) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/java/src/com/eaio/nativecall/Holder.java b/java/src/com/eaio/nativecall/Holder.java new file mode 100644 index 0000000..6c1ee68 --- /dev/null +++ b/java/src/com/eaio/nativecall/Holder.java @@ -0,0 +1,133 @@ +/* + * Holder.java + * + * Created on 14.09.2004. + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.nativecall; + +/** + * Holder is a class that encapsulates another Object. Use this class for output + * parameters. + * + * @author Johann Burkard + * @version $Id: Holder.java,v 1.3 2006/04/19 20:54:58 grnull Exp $ + */ +public class Holder { + + /** + * The encapsulated object. + *

+ * Accessed by native code. DO NOT RENAME THIS FIELD. + */ + private Object o; + + /** + * Constructor for Holder. + * + * @param o the Object to encapsulate, may be null, but cannot + * be of type Holder + * @throws ClassCastException if o is of type Holder + */ + public Holder(Object o) { + if (o instanceof Holder) { + throw new ClassCastException(); + } + else if (o == null) { + o = new Integer(0); + } + this.o = o; + } + + /** + * Returns the referenced Object. + * + * @return an Object + */ + public final Object get() { + return o; + } + + /** + * Returns the hashCode of the encapsulated Object or + * {@link java.lang.Object#hashCode()} if the Object is null. + * + * @return the hashCode + * @see java.lang.Object#hashCode() + */ + public int hashCode() { + return getClass().getName().hashCode() ^ (o == null ? 0 : o.hashCode()); + } + + /** + * Returns if this Object is equal to another Object. + * + * @param obj the other Object, may be null + * @return if both Objects are equal + * @see java.lang.Object#equals(java.lang.Object) + */ + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof Holder)) { + return false; + } + Holder h = (Holder) obj; + return o == null ? h.o == null : o.equals(h.o); + } + + /** + * Returns a String representation of this Object. + * + * @return a String, never null + * @see java.lang.Object#toString() + * @see #toStringBuffer(StringBuffer) + */ + public final String toString() { + return toStringBuffer(null).toString(); + } + + /** + * Appends a String representation of this Object to the given + * {@link StringBuffer} or creates a new one if none is given. + * + * @param in the StringBuffer to append to, may be null + * @return a StringBuffer, never null + */ + public StringBuffer toStringBuffer(StringBuffer in) { + if (in == null) { + in = new StringBuffer(32); + } + else { + in.ensureCapacity(in.length() + 32); + } + in.append("{ Holder: o = "); + in.append(o); + in.append(" }"); + return in; + } + +} diff --git a/java/src/com/eaio/nativecall/IntCall.java b/java/src/com/eaio/nativecall/IntCall.java new file mode 100644 index 0000000..97c6362 --- /dev/null +++ b/java/src/com/eaio/nativecall/IntCall.java @@ -0,0 +1,143 @@ +/* + * IntCall.java + * + * Created on 07.09.2004. + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.nativecall; + +/** + * An IntCall instance encapsulates an operating system method that returns + * an integer. + * + * @author Johann Burkard + * @version $Id: IntCall.java,v 1.1 2006/01/05 20:02:44 grnull Exp $ + */ +public class IntCall extends NativeCall { + + /** + * Constructor for IntCall. + * + * @see NativeCall#NativeCall(String) + */ + public IntCall(String function) throws SecurityException, + IllegalArgumentException, NullPointerException { + super(function); + } + + /** + * Constructor for IntCall. + * + * @see NativeCall#NativeCall(String, String) + */ + public IntCall(String module, String function) throws SecurityException, + IllegalArgumentException, NullPointerException { + super(module, function); + } + + /** + * Returns false if calling {@link #executeCall()} returned + * 0, true otherwise. + *

+ * Updates the error code field. See {@link #getLastError()}. + * + * @return true or false + */ + public boolean executeBooleanCall() { + return executeCall() == 0 ? false : true; + } + + /** + * Returns false if calling {@link #executeCall(Object)} + * returned 0, true otherwise. + *

+ * Updates the error code field. See {@link #getLastError()}. + * + * @param param the parameter, may be null + * @return true or false + * @see #executeBooleanCall(Object[]) + */ + public boolean executeBooleanCall(Object param) { + return executeCall(param) == 0 ? false : true; + } + + /** + * Returns false if calling + * {@link #executeCall(Object[])} returned 0, true otherwise. + *

+ * Updates the error code field. See {@link #getLastError()}. + *

+ * During this operation, the contents of the array might be changed. + * + * @param params the parameter array, may be null + * @return true or false + */ + public boolean executeBooleanCall(Object[] params) { + return executeCall(params) == 0 ? false : true; + } + + /** + * Calls the function, returning its output. + *

+ * Updates the error code field. See {@link #getLastError()}. + * + * @return an int + */ + public native int executeCall(); + + /** + * Calls the function using the given parameter. + *

+ * Updates the error code field. See {@link #getLastError()}. + * + * @param param the parameter, may be null + * @return an int + * @see #executeCall(Object[]) + */ + public int executeCall(Object param) { + return executeCall(new Object[] { param }); + } + + /** + * Calls the function using the given parameters. + *

+ * Updates the error code field. See {@link #getLastError()}. + *

+ * During this operation, the contents of the array might be changed. + * + * @param params the parameter array, may be null + * @return an int + */ + public int executeCall(Object[] params) { + if (params == null || params.length == 0) { + return executeCall(); + } + check(params); + return executeCall0(params); + } + + private native int executeCall0(Object[] params); + +} diff --git a/java/src/com/eaio/nativecall/NativeCall.java b/java/src/com/eaio/nativecall/NativeCall.java new file mode 100644 index 0000000..ce1c820 --- /dev/null +++ b/java/src/com/eaio/nativecall/NativeCall.java @@ -0,0 +1,355 @@ +/* + * NativeCall.java + * + * Created on 07.09.2004. + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.nativecall; + +import java.io.IOException; + +import sun.misc.ServiceConfigurationError; + +import com.eaio.util.lang.NativeLoader; + +/** + * NativeCall loads the native library and prepares the matching + * {@link com.eaio.nativecall.Verifier}. + *

+ * Before being able to use NativeCall, the {@link #init()} method must have + * been called: + * 

+ * try {
+ *     NativeCall.init();
+ * }
+ * catch (IOException ex) { ... }
+ * catch (SecurityException ex) { ... }
+ * catch (UnsatisfiedLinkError er) { ... }
+ * catch (sun.misc.ServiceConfigurationError) { ... }
+ * catch (UnsupportedOperationException) { ... }
+ *
+ * After usage, each NativeCall object must be destroyed to release + * resources. This is done by calling the {@link #destroy()} method. Failure + * to call this method might result in memory leaks. + * + * @see #destroy() + * @see #init() + * @author Johann Burkard + * @version $Id: NativeCall.java,v 1.3 2006/04/19 20:54:58 grnull Exp $ + */ +public abstract class NativeCall { + + /** + * The error code of the last call. + *

+ * Accessed by native code. DO NOT RENAME THIS FIELD. + */ + private int lastErrorCode; + + /** + * The internal handle to the function and the module. + *

+ * These are set in native code, so ignore any warnings. + *

+ * Accessed by native code. DO NOT RENAME THIS FIELD. + */ + private int functionHandle, moduleHandle; + + /** + * The name of the function to call. + *

+ * Accessed by native code. DO NOT RENAME THIS FIELD. + */ + private String function; + + /** + * The name of the module to call. + *

+ * Accessed by native code. DO NOT RENAME THIS FIELD. + */ + private String module; + + /** + * Initialize JNI field and method IDs + */ + private static native void initIDs(); + + /** + * Whether the class has been initialized properly. + */ + private static boolean initialized = false; + + /** + * Before NativeCall may be used, this method must be called. + * It loads the native library, prepares JNI field and method IDs and loads + * the matching {@link Verifier}. + *

+ * Multiple calls are ignored. + * + * @throws IOException if an IOException occured during unpacking of + * the native library + * @throws SecurityException if accessing system properties was forbidden + * by the {@link SecurityManager} + * @throws UnsatisfiedLinkError if the NativeCall.dll could + * not be found + * @throws sun.misc.ServiceConfigurationError + * @throws UnsupportedOperationException if no matching + * {@link Verifier} could be found + */ + public static synchronized void init() + throws + IOException, + SecurityException, + UnsatisfiedLinkError, + ServiceConfigurationError, + UnsupportedOperationException { + if (!initialized) { + Verifiers.init(); + if (Verifiers.getInstance() == null) { + throw new UnsupportedOperationException(); + } + new NativeLoader("NativeCall").load(); + initIDs(); + initialized = true; + } + } + + /** + * Constructor for NativeCall. + * + * @param function the name of the function to use, may not be + * null + * @throws IllegalArgumentException if the function could not be found + * @throws NullPointerException if function is null + * @see Verifier#getDefaultModule() + * @see NativeCall#NativeCall(String, String) + */ + public NativeCall(String function) + throws IllegalArgumentException, NullPointerException { + this(Verifiers.getInstance().getDefaultModule(), function); + } + + /** + * Constructor for NativeCall. + * + * @param module the name of the module the function is stored in, may be + * null + * @param function the name of the function to use, may not be + * null + * @throws IllegalArgumentException if the function could not be found + * @throws NullPointerException if function is null + */ + public NativeCall(String module, String function) + throws IllegalArgumentException, NullPointerException { + Verifier v = Verifiers.getInstance(); + this.function = v.verifyFunctionName(function); + this.module = v.verifyModuleName(module); + if (!initHandles()) { + if (lastErrorCode != 0) { + throw new IllegalArgumentException(getLastError()); + } + throw new IllegalArgumentException(); + } + } + + /** + * Attempts to acquire handles to the functions. Returns if these could be + * acquired. + * + * @return if the handles could be acquired + */ + private native boolean initHandles(); + + /** + * Returns the error code that was returned during the last method call or + * 0 if the last method call did not produce an error. + * + * @see #getLastError() + * @return the last error code or 0 + */ + public final int getLastErrorCode() { + return lastErrorCode; + } + + /** + * Returns a formatted String containing the last error code or + * null if the last call did not produce an error. + * + * @see #getLastErrorCode() + * @return a String or null if the last error code is 0 + */ + public final native String getLastError(); + + /** + * Releases acquired module handles. This method must be called if the + * instance is not used anymore. After this method is called, methods of this + * NativeCall Object cannot be called anymore. + *

+ * Failure to call this method might result in memory leaks. + *

+ * Updates the error code field. See {@link #getLastError()}. + */ + public native synchronized void destroy(); + + /** + * Checks the supplied Object array for illegal/unsupported types. + *

+ * During the verification, the contents of the array might be + * changed. + * + * @param params the Object array, may be null + * @throws ClassCastException if the type of one argument is not supported + */ + protected void check(Object[] params) throws ClassCastException { + if (params == null) { + return; + } + for (int i = 0; i < params.length; ++i) { + checkParam(params[i]); + if (params[i] instanceof String) { + params[i] = + Verifiers.getInstance().handleString( + (String) params[i], + module, + function); + } + } + } + + /** + * Checks one Object for illegal/unsupported types. + * + * @param o the Object, may be null + * @throws ClassCastException if the type of one argument is not supported + */ + protected void checkParam(Object o) throws ClassCastException { + if (o == null + || o instanceof Boolean + || o instanceof Integer + || o instanceof byte[] + || o instanceof char[] + || o instanceof String) { + return; + } + if (o instanceof Holder) { + checkParam(((Holder) o).get()); + return; + } + throw new ClassCastException(o.getClass().getName()); + } + + /** + * Returns if this Object is equal to another Object. The other Object must + * be an instance of the same type as this Object. Also, both the module + * and the function field must be equal. + * + * @param obj the other Object + * @return if this and the other Object are equal + * @see java.lang.Object#equals(java.lang.Object) + */ + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof NativeCall)) { + return false; + } + if (!getClass().getName().equals(obj.getClass().getName())) { + return false; + } + NativeCall c = (NativeCall) obj; + return module.equals(c.module) && function.equals(c.function); + } + + /** + * Returns the hashCode of this Object. The hashCode is computed by XOR'ing + * the hash codes of the function and the module names. + * + * @return the hashCode + * @see java.lang.Object#hashCode() + */ + public int hashCode() { + int out = function.hashCode(); + out ^= module.hashCode(); + return out; + } + + /** + * Calls {@link #destroy()}. + * + * @see java.lang.Object#finalize() + */ + protected void finalize() throws Throwable { + try { + destroy(); + } + finally { + super.finalize(); + // in case NativeCall is a subclass of a class other than Object + } + } + + /** + * Returns a String representation of this Object. + * + * @return a String, never null + * @see java.lang.Object#toString() + * @see #toStringBuffer(StringBuffer) + */ + public final String toString() { + return toStringBuffer(null).toString(); + } + + /** + * Appends a String representation of this Object to the given + * {@link StringBuffer} or creates a new one if none is given. + * + * @param in the StringBuffer to append to, may be null + * @return a StringBuffer, never null + */ + public StringBuffer toStringBuffer(StringBuffer in) { + if (in == null) { + in = new StringBuffer(64); + } + else { + in.ensureCapacity(in.length() + 64); + } + in.append("{ "); + int idx = getClass().getName().lastIndexOf("."); + if (idx > -1) { + in.append(getClass().getName().substring(++idx)); + } + else { + in.append(getClass().getName()); + } + in.append(": module = "); + in.append(module); + in.append(", function = "); + in.append(function); + in.append(" }"); + return in; + } + +} diff --git a/java/src/com/eaio/nativecall/Verifier.java b/java/src/com/eaio/nativecall/Verifier.java new file mode 100644 index 0000000..1780cfc --- /dev/null +++ b/java/src/com/eaio/nativecall/Verifier.java @@ -0,0 +1,101 @@ +/* + * Verifier.java + * + * Created on 07.09.2004. + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.nativecall; + +/** + * A Verifier implements method and module name checking for one given + * operating system. Classes implementing Verifier must be public and have + * a public no-argument constructor. + * + * @author Johann Burkard + * @version $Id: Verifier.java,v 1.1 2006/01/05 20:02:44 grnull Exp $ + */ +public interface Verifier { + + /** + * If there is a default module that system functions are stored in, the + * module's name may be returned here. + * + * @return the name of a default module or null + * @see NativeCall#NativeCall(String) + */ + String getDefaultModule(); + + /** + * Returns if this Verifier supports the given operating system. + * + * @return if this operating system is supported + * @throws SecurityException because {@link java.lang.System} properties + * may be queried + */ + boolean supports() throws SecurityException; + + /** + * Verifies that the given module name is correct. + * + * @param module the module name, may be null + * @return a module name, possibly modified, never null + * @throws NullPointerException if the module name is null + * and there is no default module defined + * @throws IllegalArgumentException if the module is illegal in the + * operating system + * @see #getDefaultModule() + */ + String verifyModuleName(String module) + throws NullPointerException, IllegalArgumentException; + + /** + * Verifies that the given function name is correct. + * + * @param function the function name, may be null + * @return a function name, possibly modified, never null + * @throws NullPointerException if the function name is null + * @throws IllegalArgumentException if the function is illegal in the + * operating system + */ + String verifyFunctionName(String function) + throws NullPointerException, IllegalArgumentException; + + /** + * Converts the given String to one of the following data types, based on the + * module and the function name: + *
+ *

    + *
  • a byte array
    • + *
  • a char array
    • + *
+ * + * @param val the String, never null + * @param module the module name, never null + * @param function the function name, never null + * @return the String converted, never null + */ + Object handleString(String val, String module, String function); + +} diff --git a/java/src/com/eaio/nativecall/Verifiers.java b/java/src/com/eaio/nativecall/Verifiers.java new file mode 100644 index 0000000..5fc674b --- /dev/null +++ b/java/src/com/eaio/nativecall/Verifiers.java @@ -0,0 +1,83 @@ +/* + * Verifiers.java + * + * Created on 07.09.2004. + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.nativecall; + +import java.util.Iterator; + +import sun.misc.Service; +import sun.misc.ServiceConfigurationError; + +/** + * Verifiers instantiates the matching {@link com.eaio.nativecall.Verifier} for + * the current operating system. + * + * @author Johann Burkard + * @version $Id: Verifiers.java,v 1.2 2006/01/06 10:58:33 grnull Exp $ + */ +final class Verifiers { + + /** + * No instances needed. + */ + private Verifiers() {} + + /** + * The Verifier. + */ + private static Verifier v = null; + + /** + * Find the matching Verifier. + * + * @throws ServiceConfigurationError + * @throws SecurityException + */ + static void init() throws ServiceConfigurationError, SecurityException { + Iterator i = + Service.providers(Verifier.class, Verifier.class.getClassLoader()); + Verifier ver = null; + while (i.hasNext()) { + ver = (Verifier) i.next(); + if (ver.supports()) { + v = ver; + break; + } + } + } + + /** + * Returns the Verifier. + * + * @return a Verifier or null + */ + static Verifier getInstance() { + return v; + } + +} diff --git a/java/src/com/eaio/nativecall/VoidCall.java b/java/src/com/eaio/nativecall/VoidCall.java new file mode 100644 index 0000000..21ea7a0 --- /dev/null +++ b/java/src/com/eaio/nativecall/VoidCall.java @@ -0,0 +1,99 @@ +/* + * VoidCall.java + * + * Created on 16.09.2004 + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.nativecall; + +/** + * A VoidCall instance encapsulates an operating system method that returns + * nothing. + * + * @author Johann Burkard + * @version $Id: VoidCall.java,v 1.1 2006/01/05 20:02:44 grnull Exp $ + */ +public class VoidCall extends NativeCall { + + /** + * Constructor for VoidCall. + * + * @see NativeCall#NativeCall(String) + */ + public VoidCall(String function) throws SecurityException, + IllegalArgumentException, NullPointerException { + super(function); + } + + /** + * Constructor for VoidCall. + * + * @see NativeCall#NativeCall(String, String) + */ + public VoidCall(String module, String function) throws SecurityException, + IllegalArgumentException, NullPointerException { + super(module, function); + } + + /** + * Calls the function. + *

+ * Updates the error code field. See {@link #getLastError()}. + */ + public native void executeCall(); + + /** + * Calls the function using the given parameter. + *

+ * Updates the error code field. See {@link #getLastError()}. + * + * @param param the parameter, may be null + * @see #executeCall(Object[]) + */ + public void executeCall(Object param) { + executeCall(new Object[] { param }); + } + + /** + * Calls the function using the given parameters. + *

+ * Updates the error code field. See {@link #getLastError()}. + *

+ * During this operation, the contents of the array might be changed. + * + * @param params the parameter array, may be null + */ + public void executeCall(Object[] params) { + if (params == null || params.length == 0) { + executeCall(); + return; + } + check(params); + executeCall0(params); + } + + private native void executeCall0(Object[] params); + +} diff --git a/java/src/com/eaio/nativecall/Win32Verifier.java b/java/src/com/eaio/nativecall/Win32Verifier.java new file mode 100644 index 0000000..b07f2cc --- /dev/null +++ b/java/src/com/eaio/nativecall/Win32Verifier.java @@ -0,0 +1,122 @@ +/* + * Win32Verifier.java + * + * Created on 08.09.2004. + * + * eaio: NativeCall - calling operating system methods from Java + * Copyright (c) 2004-2006 Johann Burkard () + * + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.nativecall; + +/** + * A {@link com.eaio.nativecall.Verifier} for the Windows environment. + * + * @author Johann Burkard + * @version $Id: Win32Verifier.java,v 1.3 2006/04/19 20:54:58 grnull Exp $ + */ +public class Win32Verifier implements Verifier { + + /** + * Constructor for Win32Verifier. Does nothing. + */ + public Win32Verifier() {} + + /** + * Verifies that the {@link java.lang.System} property "os.name" starts + * with "Windows". + * + * @see Verifier#supports() + */ + public boolean supports() throws SecurityException { + return System.getProperty("os.name").startsWith("Windows"); + } + + /** + * Returns the default module name if the module name is null + * or an empty String. If the module name contains forward slashes (/), they + * are converted to backward slashes (\). + * + * @see + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/loadlibrary.asp + * + * @see com.eaio.nativecall.Verifier#verifyModuleName(java.lang.String) + */ + public String verifyModuleName(String module) { + if (module == null || module.length() == 0) { + return getDefaultModule(); + } + if (module.indexOf('/') != -1) { + module = module.replace('/', '\\'); + } + return module; + } + + /** + * Throws a {@link java.lang.NullPointerException} if the function + * name is null or an empty String. No further processing is + * done. + * + * @see com.eaio.nativecall.Verifier#verifyFunctionName(java.lang.String) + */ + public String verifyFunctionName(String function) { + if (function == null || function.length() == 0) { + throw new NullPointerException(); + } + return function; + } + + /** + * Returns "kernel32". + * + * @return "kernel32" + * @see com.eaio.nativecall.Verifier#getDefaultModule() + */ + public String getDefaultModule() { + return "kernel32"; + } + + /** + * If the function name ends on 'W' (Windows' Unicode functions), a + * char array is returned, otherwise a byte array + * is returned. + *

+ * The arrays are always null-terminated. + * + * @see com.eaio.nativecall.Verifier#handleString(java.lang.String, + * java.lang.String, + * java.lang.String) + */ + public Object handleString(String val, String module, String function) { + if (function.charAt(function.length() - 1) == 'W') { + char[] buf = new char[val.length() + 1]; + val.getChars(0, val.length(), buf, 0); + return buf; + } + byte[] buf = new byte[val.length() + 1]; + val.getBytes(0, val.length(), buf, 0); + return buf; + } + +} diff --git a/java/src/com/eaio/nativecall/package.html b/java/src/com/eaio/nativecall/package.html new file mode 100644 index 0000000..ebbd694 --- /dev/null +++ b/java/src/com/eaio/nativecall/package.html @@ -0,0 +1,15 @@ + + + +Untitled Document + + +

Contains the main NativeCall classes.

+

For instant API information, see:

+
    +
  • {@link com.eaio.nativecall.NativeCall}
    • +
  • {@link com.eaio.nativecall.IntCall}
    • +
  • {@link com.eaio.nativecall.VoidCall}
    • +
+ +