mkxp-z/binding/miniffi-binding.cpp

// 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

#include <SDL.h>
#ifdef USE_FAKEAPI
#include "fake-api.h"
#endif

#include "binding-util.h"

#define _T_VOID     0
#define _T_NUMBER   1
#define _T_POINTER  2
#define _T_INTEGER  3


// Might need to let MiniFFI.initialize set calling convention
// as an optional arg, this won't work with everything
// Maybe libffi would help out with this

// Only using 8 max args instead of 16 to reduce the time taken
// to set all those variables up and ease the eyesore, and I don't
// think there are many functions one would need to use that require
// that many arguments anyway

// stdcall is easy, everything in a struct gets pushed to the stack
#ifdef __WIN32__
typedef void* (__stdcall *MINIFFI_FUNC)(...);
#else
// L O N G, but variables won't get set up correctly otherwise
// should allow for __fastcalls (macOS likes these) and whatever else
typedef void* (*MINIFFI_FUNC)(unsigned long,unsigned long,unsigned long,unsigned long,unsigned long,unsigned long,unsigned long,unsigned long);
#endif

// MiniFFI class, also named Win32API on Windows
// Uses LoadLibrary/GetProcAddress on Windows, dlopen/dlsym everywhere else

static VALUE
MiniFFI_alloc(VALUE self)
{
    return Data_Wrap_Struct(self, 0, SDL_UnloadObject, 0);
}

static void*
MiniFFI_GetFunctionHandle(void *libhandle, const char *func)
{
#ifdef USE_FAKEAPI
#define CAPTURE(n) if (!strcmp(#n,func)) return (void*)&MKXP_##n
    CAPTURE(GetCurrentThreadId);
    CAPTURE(GetWindowThreadProcessId);
    CAPTURE(FindWindowEx);
    CAPTURE(GetForegroundWindow);
    CAPTURE(GetClientRect);
    CAPTURE(GetCursorPos);
    CAPTURE(ScreenToClient);
    CAPTURE(SetWindowPos);
    CAPTURE(SetWindowTextA);
    CAPTURE(GetWindowRect);
    CAPTURE(RegisterHotKey);
    CAPTURE(GetKeyboardState);
#ifndef __WIN32__  
    // Functions only needed on Linux and macOS go here
    CAPTURE(RtlMoveMemory);
    CAPTURE(LoadLibrary);
    CAPTURE(FreeLibrary);
#endif
#endif
    if (!libhandle) return 0;
    return SDL_LoadFunction(libhandle, func);
}

// MiniFFI.new(library, function[, imports[, exports]])
// Yields itself in blocks

RB_METHOD(MiniFFI_initialize)
{
    VALUE libname, func, imports, exports;
    rb_scan_args(argc, argv, "22", &libname, &func, &imports, &exports);
    SafeStringValue(libname);
    SafeStringValue(func);
    void *hlib = SDL_LoadObject(RSTRING_PTR(libname));
    DATA_PTR(self) = hlib;
    void *hfunc = MiniFFI_GetFunctionHandle(hlib, RSTRING_PTR(func));
#ifdef __WIN32__
    if (hlib && !hfunc)
    {
        VALUE func_a = rb_str_new3(func);
        func_a = rb_str_cat(func_a, "A", 1);
        hfunc = SDL_LoadFunction(hlib, RSTRING_PTR(func_a));
    }
#endif
    if (!hfunc)
        rb_raise(rb_eRuntimeError, SDL_GetError());
    
    
    rb_iv_set(self, "_func", OFFT2NUM((unsigned long)hfunc));
    rb_iv_set(self, "_funcname", func);
    rb_iv_set(self, "_libname", libname);
    
    VALUE ary_imports = rb_ary_new();
    VALUE *entry;
    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;
                        
                    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;
                }
            }
            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;
                }
            }
            break;
    }
    
    if (8 < RARRAY_LEN(ary_imports))
        rb_raise(rb_eRuntimeError, "too many parameters: %ld\n", RARRAY_LEN(ary_imports));
    
    rb_iv_set(self, "_imports", ary_imports);
    int ex;
    if (NIL_P(exports))
    {
        ex = _T_VOID;
    }
    else
    {
        SafeStringValue(exports);
        switch(*RSTRING_PTR(exports))
        {
            case 'V': case 'v':
                ex = _T_VOID;
                break;
                
            case 'N': case 'n': case 'L': case 'l':
                ex = _T_NUMBER;
                break;
                
            case 'P': case 'p':
                ex = _T_POINTER;
                break;
                
            case 'I': case 'i':
                ex = _T_INTEGER;
                break;
        }
    }
    rb_iv_set(self, "_exports", INT2FIX(ex));
    if (rb_block_given_p()) rb_yield(self);
    return Qnil;
}

RB_METHOD(MiniFFI_call)
{
    struct {
        unsigned long params[8];
    } param;
#define params param.params
    VALUE func = rb_iv_get(self, "_func");
    VALUE own_imports = rb_iv_get(self, "_imports");
    VALUE own_exports = rb_iv_get(self, "_exports");
    MINIFFI_FUNC ApiFunction = (MINIFFI_FUNC)NUM2OFFT(func);
    VALUE args;
    int items = rb_scan_args(argc, argv, "0*", &args);
    int nimport = RARRAY_LEN(own_imports);
    if (items != nimport)
        rb_raise(rb_eRuntimeError, "wrong number of parameters: expected %d, got %d",
                 nimport, items);
    
    for (int i = 0; i < nimport; i++)
    {
        VALUE str = rb_ary_entry(args, i);
        unsigned long lParam = 0;
        switch(FIX2INT(rb_ary_entry(own_imports, i)))
        {
            case _T_POINTER:
                if (NIL_P(str))
                {
                    lParam = 0;
                }
                else if (FIXNUM_P(str))
                {
                    lParam = NUM2OFFT(str);
                }
                else
                {
                    StringValue(str);
                    rb_str_modify(str);
                    lParam = (unsigned long)RSTRING_PTR(str);
                }
                break;
                
            case _T_NUMBER: case _T_INTEGER: default:
                lParam = NUM2OFFT(rb_ary_entry(args, i));
                break;
        }
        params[i] = lParam;
    }
#ifdef __WIN32__
    unsigned long ret = (unsigned long)ApiFunction(param);
#else
    unsigned long ret = (unsigned long)ApiFunction(params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7]);
#endif
    
    switch (FIX2INT(own_exports))
    {
        case _T_NUMBER: case _T_INTEGER:
            return OFFT2NUM(ret);
            
        case _T_POINTER:
            return rb_str_new2((char*)ret);
            
        case _T_VOID: default:
            return OFFT2NUM(0);
    }
}


void
MiniFFIBindingInit()
{
    VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject);
    rb_define_alloc_func(cMiniFFI, MiniFFI_alloc);
    _rb_define_method(cMiniFFI, "initialize", MiniFFI_initialize);
    _rb_define_method(cMiniFFI, "call", MiniFFI_call);
    rb_define_alias(cMiniFFI, "Call", "call");

    // Preferably use MiniFFI, the name Win32API makes no sense
    // on things that aren't Windows but I'm leaving it here
    // for compatibility
    rb_define_const(rb_cObject, "Win32API", cMiniFFI);
}