mirrors/mkxp-z
1
0
Fork 0
mirror of https://github.com/mkxp-z/mkxp-z.git synced 2025-08-07 07:25:49 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

always alias MiniFFI class as Win32API

Browse source
This commit is contained in:
Inori 2019-12-21 04:53:14 -05:00 • committed by Inori
parent a213b45e84
commit faef84e1ae
1 changed files with 239 additions and 235 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

436
binding/miniffi-binding.cpp
View file

@ -1,17 +1,16 @@
// Most of the MiniFFI class was taken from Ruby 1.8's Win32API.c, // Most of the MiniFFI class was taken from Ruby 1.8's Win32API.c,
// it's just as basic but should work fine for the moment // it's just as basic but should work fine for the moment
#include <SDL.h>
#include "fake-api.h" #include "fake-api.h"
#include <SDL.h>
#include "binding-util.h" #include "binding-util.h"
#define _T_VOID 0 #define _T_VOID 0
#define _T_NUMBER 1 #define _T_NUMBER 1
#define _T_POINTER 2 #define _T_POINTER 2
#define _T_INTEGER 3 #define _T_INTEGER 3
#define _T_BOOL 4 #define _T_BOOL 4
// Might need to let MiniFFI.initialize set calling convention // Might need to let MiniFFI.initialize set calling convention
// as an optional arg, this won't work with everything // as an optional arg, this won't work with everything
@ -24,7 +23,10 @@
// L O N G, but variables won't get set up correctly otherwise // L O N G, but variables won't get set up correctly otherwise
// should allow for __fastcalls (macOS likes these) and whatever else // should allow for __fastcalls (macOS likes these) and whatever else
typedef PREFABI void* (*MINIFFI_FUNC)(unsigned long,unsigned long,unsigned long,unsigned long,unsigned long,unsigned long,unsigned long,unsigned long); typedef PREFABI void *(*MINIFFI_FUNC)(unsigned long, unsigned long,
unsigned long, unsigned long,
unsigned long, unsigned long,
unsigned long, unsigned long);
// MiniFFI class, also named Win32API on Windows // MiniFFI class, also named Win32API on Windows
// Uses LoadLibrary/GetProcAddress on Windows, dlopen/dlsym everywhere else // Uses LoadLibrary/GetProcAddress on Windows, dlopen/dlsym everywhere else
@ -35,254 +37,256 @@ DEF_TYPE_CUSTOMFREE(MiniFFI, SDL_UnloadObject);
DEF_ALLOCFUNC_CUSTOMFREE(MiniFFI, SDL_UnloadObject); DEF_ALLOCFUNC_CUSTOMFREE(MiniFFI, SDL_UnloadObject);
#endif #endif
static void* static void *MiniFFI_GetFunctionHandle(void *libhandle, const char *func) {
MiniFFI_GetFunctionHandle(void *libhandle, const char *func)
{
#ifdef USE_FAKEAPI #ifdef USE_FAKEAPI
#define CAPTURE(n) if (!strcmp(#n,func)) return (void*)&MKXP_##n #define CAPTURE(n) \
CAPTURE(GetCurrentThreadId); if (!strcmp(#n, func)) \
CAPTURE(GetWindowThreadProcessId); return (void *)&MKXP_##n
CAPTURE(FindWindowEx); CAPTURE(GetCurrentThreadId);
CAPTURE(GetForegroundWindow); CAPTURE(GetWindowThreadProcessId);
CAPTURE(GetClientRect); CAPTURE(FindWindowEx);
CAPTURE(GetCursorPos); CAPTURE(GetForegroundWindow);
CAPTURE(ScreenToClient); CAPTURE(GetClientRect);
CAPTURE(SetWindowPos); CAPTURE(GetCursorPos);
CAPTURE(SetWindowTextA); CAPTURE(ScreenToClient);
CAPTURE(GetWindowRect); CAPTURE(SetWindowPos);
CAPTURE(RegisterHotKey); CAPTURE(SetWindowTextA);
CAPTURE(SetWindowLong); CAPTURE(GetWindowRect);
CAPTURE(GetKeyboardState); CAPTURE(RegisterHotKey);
CAPTURE(SetWindowLong);
CAPTURE(GetKeyboardState);
#ifndef __WIN32__ #ifndef __WIN32__
// Functions only needed on Linux and macOS go here // Functions only needed on Linux and macOS go here
CAPTURE(RtlMoveMemory); CAPTURE(RtlMoveMemory);
CAPTURE(LoadLibrary); CAPTURE(LoadLibrary);
CAPTURE(FreeLibrary); CAPTURE(FreeLibrary);
CAPTURE(GetAsyncKeyState); CAPTURE(GetAsyncKeyState);
CAPTURE(GetSystemPowerStatus); CAPTURE(GetSystemPowerStatus);
CAPTURE(ShowWindow); CAPTURE(ShowWindow);
CAPTURE(GetSystemMetrics); CAPTURE(GetSystemMetrics);
CAPTURE(SetCapture); CAPTURE(SetCapture);
CAPTURE(ReleaseCapture); CAPTURE(ReleaseCapture);
CAPTURE(ShowCursor); CAPTURE(ShowCursor);
CAPTURE(GetPrivateProfileString); CAPTURE(GetPrivateProfileString);
CAPTURE(GetUserDefaultLangID); CAPTURE(GetUserDefaultLangID);
CAPTURE(GetUserName); CAPTURE(GetUserName);
#endif #endif
#endif #endif
if (!libhandle) return 0; if (!libhandle)
return SDL_LoadFunction(libhandle, func); return 0;
return SDL_LoadFunction(libhandle, func);
} }
// MiniFFI.new(library, function[, imports[, exports]]) // MiniFFI.new(library, function[, imports[, exports]])
// Yields itself in blocks // Yields itself in blocks
RB_METHOD(MiniFFI_initialize) RB_METHOD(MiniFFI_initialize) {
{ VALUE libname, func, imports, exports;
VALUE libname, func, imports, exports; rb_scan_args(argc, argv, "22", &libname, &func, &imports, &exports);
rb_scan_args(argc, argv, "22", &libname, &func, &imports, &exports); SafeStringValue(libname);
SafeStringValue(libname); SafeStringValue(func);
SafeStringValue(func); void *hlib = SDL_LoadObject(RSTRING_PTR(libname));
void *hlib = SDL_LoadObject(RSTRING_PTR(libname)); setPrivateData(self, hlib);
setPrivateData(self, hlib); void *hfunc = MiniFFI_GetFunctionHandle(hlib, RSTRING_PTR(func));
void *hfunc = MiniFFI_GetFunctionHandle(hlib, RSTRING_PTR(func));
#ifdef __WIN32__ #ifdef __WIN32__
if (hlib && !hfunc) if (hlib && !hfunc) {
{ VALUE func_a = rb_str_new3(func);
VALUE func_a = rb_str_new3(func); func_a = rb_str_cat(func_a, "A", 1);
func_a = rb_str_cat(func_a, "A", 1); hfunc = SDL_LoadFunction(hlib, RSTRING_PTR(func_a));
hfunc = SDL_LoadFunction(hlib, RSTRING_PTR(func_a)); }
}
#endif #endif
if (!hfunc) if (!hfunc)
rb_raise(rb_eRuntimeError, SDL_GetError()); rb_raise(rb_eRuntimeError, "%s", SDL_GetError());
rb_iv_set(self, "_func", ULONG2NUM((unsigned long)hfunc));
rb_iv_set(self, "_funcname", func);
rb_iv_set(self, "_libname", libname);
rb_iv_set(self, "_func", ULONG2NUM((unsigned long)hfunc)); VALUE ary_imports = rb_ary_new();
rb_iv_set(self, "_funcname", func); VALUE *entry;
rb_iv_set(self, "_libname", libname); switch (TYPE(imports)) {
case T_NIL:
break;
case T_ARRAY:
entry = RARRAY_PTR(imports);
for (int i = 0; i < RARRAY_LEN(imports); i++) {
SafeStringValue(entry[i]);
switch (*(char *)RSTRING_PTR(entry[i])) {
case 'N':
case 'n':
case 'L':
case 'l':
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER));
break;
VALUE ary_imports = rb_ary_new(); case 'P':
VALUE *entry; case 'p':
switch (TYPE(imports)) rb_ary_push(ary_imports, INT2FIX(_T_POINTER));
{ break;
case T_NIL:
break;
case T_ARRAY:
entry = RARRAY_PTR(imports);
for (int i = 0; i < RARRAY_LEN(imports); i++)
{
SafeStringValue(entry[i]);
switch (*(char*)RSTRING_PTR(entry[i]))
{
case 'N': case 'n': case 'L': case 'l':
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER));
break;
case 'P': case 'p': case 'I':
rb_ary_push(ary_imports, INT2FIX(_T_POINTER)); case 'i':
break; rb_ary_push(ary_imports, INT2FIX(_T_INTEGER));
break;
case 'I': case 'i': case 'B':
rb_ary_push(ary_imports, INT2FIX(_T_INTEGER)); case 'b':
break; rb_ary_push(ary_imports, INT2FIX(_T_BOOL));
break;
case 'B': case 'b': }
rb_ary_push(ary_imports, INT2FIX(_T_BOOL));
break;
}
}
break;
default:
SafeStringValue(imports);
const char *s = RSTRING_PTR(imports);
for (int i = 0; i < RSTRING_LEN(imports); i++)
{
switch (*s++)
{
case 'N': case 'n': case 'L': case 'l':
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER));
break;
case 'P': case 'p':
rb_ary_push(ary_imports, INT2FIX(_T_POINTER));
break;
case 'I': case 'i':
rb_ary_push(ary_imports, INT2FIX(_T_INTEGER));
break;
case 'B': case 'b':
rb_ary_push(ary_imports, INT2FIX(_T_BOOL));
break;
}
}
break;
} }
break;
default:
SafeStringValue(imports);
const char *s = RSTRING_PTR(imports);
for (int i = 0; i < RSTRING_LEN(imports); i++) {
switch (*s++) {
case 'N':
case 'n':
case 'L':
case 'l':
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER));
break;
if (8 < RARRAY_LEN(ary_imports)) case 'P':
rb_raise(rb_eRuntimeError, "too many parameters: %ld\n", RARRAY_LEN(ary_imports)); case 'p':
rb_ary_push(ary_imports, INT2FIX(_T_POINTER));
break;
rb_iv_set(self, "_imports", ary_imports); case 'I':
int ex; case 'i':
if (NIL_P(exports)) rb_ary_push(ary_imports, INT2FIX(_T_INTEGER));
{ break;
ex = _T_VOID;
case 'B':
case 'b':
rb_ary_push(ary_imports, INT2FIX(_T_BOOL));
break;
}
} }
else break;
{ }
SafeStringValue(exports);
switch(*RSTRING_PTR(exports))
{
case 'V': case 'v':
ex = _T_VOID;
break;
case 'N': case 'n': case 'L': case 'l': if (8 < RARRAY_LEN(ary_imports))
ex = _T_NUMBER; rb_raise(rb_eRuntimeError, "too many parameters: %ld\n",
break; RARRAY_LEN(ary_imports));
case 'P': case 'p': rb_iv_set(self, "_imports", ary_imports);
ex = _T_POINTER; int ex;
break; if (NIL_P(exports)) {
ex = _T_VOID;
} else {
SafeStringValue(exports);
switch (*RSTRING_PTR(exports)) {
case 'V':
case 'v':
ex = _T_VOID;
break;
case 'I': case 'i': case 'N':
ex = _T_INTEGER; case 'n':
break; case 'L':
case 'l':
ex = _T_NUMBER;
break;
case 'B': case 'b': case 'P':
ex = _T_BOOL; case 'p':
break; ex = _T_POINTER;
} break;
case 'I':
case 'i':
ex = _T_INTEGER;
break;
case 'B':
case 'b':
ex = _T_BOOL;
break;
} }
rb_iv_set(self, "_exports", INT2FIX(ex)); }
if (rb_block_given_p()) rb_yield(self); rb_iv_set(self, "_exports", INT2FIX(ex));
return Qnil; if (rb_block_given_p())
rb_yield(self);
return Qnil;
} }
RB_METHOD(MiniFFI_call) RB_METHOD(MiniFFI_call) {
{ struct {
struct { unsigned long params[8];
unsigned long params[8]; } param;
} param;
#define params param.params #define params param.params
VALUE func = rb_iv_get(self, "_func"); VALUE func = rb_iv_get(self, "_func");
VALUE own_imports = rb_iv_get(self, "_imports"); VALUE own_imports = rb_iv_get(self, "_imports");
VALUE own_exports = rb_iv_get(self, "_exports"); VALUE own_exports = rb_iv_get(self, "_exports");
MINIFFI_FUNC ApiFunction = (MINIFFI_FUNC)NUM2ULONG(func); MINIFFI_FUNC ApiFunction = (MINIFFI_FUNC)NUM2ULONG(func);
VALUE args; VALUE args;
int items = rb_scan_args(argc, argv, "0*", &args); int items = rb_scan_args(argc, argv, "0*", &args);
int nimport = RARRAY_LEN(own_imports); int nimport = RARRAY_LEN(own_imports);
if (items != nimport) if (items != nimport)
rb_raise(rb_eRuntimeError, "wrong number of parameters: expected %d, got %d", rb_raise(rb_eRuntimeError,
nimport, items); "wrong number of parameters: expected %d, got %d", nimport, items);
for (int i = 0; i < nimport; i++) for (int i = 0; i < nimport; i++) {
{ VALUE str = rb_ary_entry(args, i);
VALUE str = rb_ary_entry(args, i); unsigned long lParam = 0;
unsigned long lParam = 0; switch (FIX2INT(rb_ary_entry(own_imports, i))) {
switch(FIX2INT(rb_ary_entry(own_imports, i))) case _T_POINTER:
{ if (NIL_P(str)) {
case _T_POINTER: lParam = 0;
if (NIL_P(str)) } else if (FIXNUM_P(str)) {
{ lParam = NUM2ULONG(str);
lParam = 0; } else {
} StringValue(str);
else if (FIXNUM_P(str)) rb_str_modify(str);
{ lParam = (unsigned long)RSTRING_PTR(str);
lParam = NUM2ULONG(str); }
} break;
else
{
StringValue(str);
rb_str_modify(str);
lParam = (unsigned long)RSTRING_PTR(str);
}
break;
case _T_BOOL: case _T_BOOL:
lParam = RTEST(rb_ary_entry(args, i)); lParam = RTEST(rb_ary_entry(args, i));
break; break;
case _T_NUMBER: case _T_INTEGER: default: case _T_NUMBER:
lParam = NUM2ULONG(rb_ary_entry(args, i)); case _T_INTEGER:
break; default:
} lParam = NUM2ULONG(rb_ary_entry(args, i));
params[i] = lParam; break;
} }
unsigned long ret = (unsigned long)ApiFunction(params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7]); params[i] = lParam;
}
unsigned long ret =
(unsigned long)ApiFunction(params[0], params[1], params[2], params[3],
params[4], params[5], params[6], params[7]);
switch (FIX2INT(own_exports)) switch (FIX2INT(own_exports)) {
{ case _T_NUMBER:
case _T_NUMBER: case _T_INTEGER: case _T_INTEGER:
return ULONG2NUM(ret); return ULONG2NUM(ret);
case _T_POINTER: case _T_POINTER:
return rb_str_new_cstr((char*)ret); return rb_str_new_cstr((char *)ret);
case _T_BOOL: case _T_BOOL:
return rb_bool_new(ret); return rb_bool_new(ret);
case _T_VOID: default: case _T_VOID:
return ULONG2NUM(0); default:
} return ULONG2NUM(0);
}
} }
void MiniFFIBindingInit() {
void VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject);
MiniFFIBindingInit()
{
VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject);
#ifndef OLD_RUBY #ifndef OLD_RUBY
rb_define_alloc_func(cMiniFFI, classAllocate<&MiniFFIType>); rb_define_alloc_func(cMiniFFI, classAllocate<&MiniFFIType>);
#else #else
rb_define_alloc_func(cMiniFFI, MiniFFIAllocate); rb_define_alloc_func(cMiniFFI, MiniFFIAllocate);
#endif #endif
_rb_define_method(cMiniFFI, "initialize", MiniFFI_initialize); _rb_define_method(cMiniFFI, "initialize", MiniFFI_initialize);
_rb_define_method(cMiniFFI, "call", MiniFFI_call); _rb_define_method(cMiniFFI, "call", MiniFFI_call);
rb_define_alias(cMiniFFI, "Call", "call"); rb_define_alias(cMiniFFI, "Call", "call");
#if defined(__WIN32__) || defined(USE_FAKEAPI) rb_define_const(rb_cObject, "Win32API", cMiniFFI);
rb_define_const(rb_cObject, "Win32API", cMiniFFI);
#endif
} }