minilab 1.1.0-x86-mswin32-60

data/vendor/ffi-0.4.0-x86-mswin32/ext/ffi_c/Callback.h

@@ -0,0 +1,47 @@
+#ifndef _CALLBACK_H
+#define	_CALLBACK_H
+
+#include "Types.h"
+#include "Type.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+#include <ffi.h>
+    
+typedef struct {
+    Type type; // The native type of a CallbackInfo object
+    VALUE rbReturnType;
+    VALUE rbParameterTypes;
+
+    Type* returnType;
+    Type** parameterTypes;
+    ffi_type* ffiReturnType;
+    ffi_type** ffiParameterTypes;
+    ffi_cif ffi_cif;
+    int parameterCount;
+    int flags;
+    ffi_abi abi;
+} CallbackInfo;
+
+typedef struct {
+    void* code;
+    ffi_closure* ffi_closure;
+    ffi_cif ffi_cif;
+    int flags;
+    CallbackInfo* cbInfo;
+    VALUE rbCallbackInfo;
+    VALUE rbProc;
+} NativeCallback;
+
+extern VALUE rbffi_CallbackInfoClass;
+extern void rbffi_Callback_Init(VALUE ffiModule);
+extern VALUE rbffi_NativeCallback_NewInstance(VALUE, VALUE);
+extern VALUE rbffi_NativeCallback_ForProc(VALUE proc, VALUE cbInfo);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _CALLBACK_H */
+

data/vendor/ffi-0.4.0-x86-mswin32/ext/ffi_c/DynamicLibrary.c

@@ -0,0 +1,213 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#if defined(_WIN32) || defined(__WIN32__)
+# include <windows.h>
+#else
+# include <dlfcn.h>
+#endif
+#include <ruby.h>
+
+#include <ffi.h>
+
+#include "rbffi.h"
+#include "compat.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "DynamicLibrary.h"
+
+typedef struct LibrarySymbol_ {
+    AbstractMemory memory;
+    VALUE library;
+    VALUE name;
+} LibrarySymbol;
+
+static VALUE library_initialize(VALUE self, VALUE libname, VALUE libflags);
+static void library_free(Library* lib);
+
+
+static VALUE symbol_allocate(VALUE klass);
+static VALUE symbol_new(VALUE library, void* address, VALUE name);
+static void symbol_mark(LibrarySymbol* sym);
+
+static VALUE LibraryClass = Qnil, SymbolClass = Qnil;
+
+#if defined(_WIN32) || defined(__WIN32__)
+static void* dl_open(const char* name, int flags);
+static void dl_error(char* buf, int size);
+#define dl_sym(handle, name) GetProcAddress(handle, name)
+#define dl_close(handle) FreeLibrary(handle)
+enum { RTLD_LAZY=1, RTLD_NOW, RTLD_GLOBAL, RTLD_LOCAL };
+#else
+# define dl_open(name, flags) dlopen(name, flags != 0 ? flags : RTLD_LAZY)
+# define dl_error(buf, size) do { snprintf(buf, size, "%s", dlerror()); } while(0)
+# define dl_sym(handle, name) dlsym(handle, name)
+# define dl_close(handle) dlclose(handle)
+#ifndef RTLD_LOCAL
+# define RTLD_LOCAL 8
+#endif
+#endif
+
+static VALUE
+library_allocate(VALUE klass)
+{
+    Library* library;
+    return Data_Make_Struct(klass, Library, NULL, library_free, library);
+}
+
+static VALUE
+library_open(VALUE klass, VALUE libname, VALUE libflags)
+{
+    return library_initialize(library_allocate(klass), libname, libflags);
+}
+
+static VALUE
+library_initialize(VALUE self, VALUE libname, VALUE libflags)
+{
+    Library* library;
+    int flags;
+
+    Check_Type(libflags, T_FIXNUM);
+
+    Data_Get_Struct(self, Library, library);
+    flags = libflags != Qnil ? NUM2UINT(libflags) : 0;
+    
+    library->handle = dl_open(libname != Qnil ? StringValueCStr(libname) : NULL, flags);
+    if (library->handle == NULL) {
+        char errmsg[1024];
+        dl_error(errmsg, sizeof(errmsg));
+        rb_raise(rb_eLoadError, "Could not open library '%s': %s",
+                libname != Qnil ? StringValueCStr(libname) : "[current process]",
+                errmsg);
+    }
+    rb_iv_set(self, "@name", libname != Qnil ? libname : rb_str_new2("[current process]"));
+    return self;
+}
+
+static VALUE
+library_dlsym(VALUE self, VALUE name)
+{
+    Library* library;
+    void* address = NULL;
+    Check_Type(name, T_STRING);
+
+    Data_Get_Struct(self, Library, library);
+    address = dl_sym(library->handle, StringValueCStr(name));
+    
+    return address != NULL ? symbol_new(self, address, name) : Qnil;
+}
+
+static VALUE
+library_dlerror(VALUE self)
+{
+    char errmsg[1024];
+    dl_error(errmsg, sizeof(errmsg));
+    return rb_tainted_str_new2(errmsg);
+}
+
+static void
+library_free(Library* library)
+{
+    // dlclose() on MacOS tends to segfault - avoid it
+#ifndef __APPLE__
+    if (library->handle != NULL) {
+        dl_close(library->handle);
+    }
+#endif
+    xfree(library);
+}
+
+#if defined(_WIN32) || defined(__WIN32__)
+static void*
+dl_open(const char* name, int flags)
+{
+    if (name == NULL) {
+        return GetModuleHandle(NULL);
+    } else {
+        return LoadLibraryEx(name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+    }
+}
+
+static void
+dl_error(char* buf, int size)
+{
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
+            0, buf, size, NULL);
+}
+#endif
+
+static VALUE
+symbol_allocate(VALUE klass)
+{
+    LibrarySymbol* sym;
+    VALUE obj = Data_Make_Struct(klass, LibrarySymbol, NULL, -1, sym);
+    sym->name = Qnil;
+    sym->library = Qnil;
+
+    return obj;
+}
+
+static VALUE
+symbol_new(VALUE library, void* address, VALUE name)
+{
+    LibrarySymbol* sym;
+    VALUE obj = Data_Make_Struct(SymbolClass, LibrarySymbol, symbol_mark, -1, sym);
+
+    sym->memory.address = address;
+    sym->memory.size = LONG_MAX;
+    sym->library = library;
+    sym->name = name;
+
+    return obj;
+}
+
+static void
+symbol_mark(LibrarySymbol* sym)
+{
+    rb_gc_mark(sym->library);
+    rb_gc_mark(sym->name);
+}
+
+static VALUE
+symbol_inspect(VALUE self)
+{
+    LibrarySymbol* sym;
+    char buf[256];
+
+    Data_Get_Struct(self, LibrarySymbol, sym);
+    snprintf(buf, sizeof(buf), "#<FFI::Library::Symbol name=%s address=%p>",
+             StringValueCStr(sym->name), sym->memory.address);
+    return rb_str_new2(buf);
+}
+
+void
+rbffi_DynamicLibrary_Init(VALUE moduleFFI)
+{
+    LibraryClass = rb_define_class_under(moduleFFI, "DynamicLibrary", rb_cObject);
+    rb_global_variable(&LibraryClass);
+    SymbolClass = rb_define_class_under(LibraryClass, "Symbol", rbffi_PointerClass);
+    rb_global_variable(&SymbolClass);
+
+    rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); // backwards compat library
+    rb_define_alloc_func(LibraryClass, library_allocate);
+    rb_define_singleton_method(LibraryClass, "open", library_open, 2);
+    rb_define_singleton_method(LibraryClass, "last_error", library_dlerror, 0);
+    rb_define_method(LibraryClass, "initialize", library_initialize, 2);
+    rb_define_method(LibraryClass, "find_symbol", library_dlsym, 1);
+    rb_define_method(LibraryClass, "find_function", library_dlsym, 1);
+    rb_define_method(LibraryClass, "find_variable", library_dlsym, 1);
+    rb_define_method(LibraryClass, "last_error", library_dlerror, 0);
+    rb_define_attr(LibraryClass, "name", 1, 0);
+
+    rb_define_alloc_func(SymbolClass, symbol_allocate);
+    rb_undef_method(SymbolClass, "new");
+    rb_define_method(SymbolClass, "inspect", symbol_inspect, 0);
+
+#define DEF(x) rb_define_const(LibraryClass, "RTLD_" #x, UINT2NUM(RTLD_##x))
+    DEF(LAZY);
+    DEF(NOW);
+    DEF(GLOBAL);
+    DEF(LOCAL);
+
+}
+

data/vendor/ffi-0.4.0-x86-mswin32/ext/ffi_c/DynamicLibrary.h

@@ -0,0 +1,22 @@
+
+#ifndef _LIBRARY_H
+#define	_LIBRARY_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+
+typedef struct Library {
+    void* handle;
+} Library;
+
+extern void rbffi_DynamicLibrary_Init(VALUE ffiModule);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _LIBRARY_H */
+

data/vendor/ffi-0.4.0-x86-mswin32/ext/ffi_c/Invoker.c

@@ -0,0 +1,962 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#ifndef _WIN32
+#  include <sys/mman.h>
+#endif
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#ifndef _WIN32
+#  include <unistd.h>
+#  include <pthread.h>
+#endif
+#include <errno.h>
+#include <ruby.h>
+
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "Struct.h"
+#include "Platform.h"
+#include "Callback.h"
+#include "Types.h"
+#include "Type.h"
+#include "LastError.h"
+
+#if defined(__i386__) && !defined(_WIN32) && !defined(__WIN32__)
+#  define USE_RAW
+#endif
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
+#  define USE_PTHREAD_LOCAL
+#endif
+#define MAX_FIXED_ARITY (3)
+
+#ifndef roundup
+#  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
+#endif
+
+typedef struct MethodHandle MethodHandle;
+typedef struct Invoker Invoker;
+
+struct Invoker {
+    VALUE address;
+    VALUE enums;
+    void* function;
+    ffi_cif cif;
+    int paramCount;
+    ffi_type** ffiParamTypes;
+    NativeType* paramTypes;
+    Type* returnType;
+    VALUE rbReturnType;
+    VALUE callbackArray;
+    int callbackCount;
+    VALUE* callbackParameters;
+    ffi_abi abi;
+    MethodHandle* methodHandle;
+};
+#ifdef USE_RAW
+#  define METHOD_CLOSURE ffi_raw_closure
+#else
+#  define METHOD_CLOSURE ffi_closure
+#endif
+typedef struct MethodHandlePool MethodHandlePool;
+struct MethodHandle {
+    Invoker* invoker;
+    int arity;
+    METHOD_CLOSURE* closure;
+    void* code;
+    ffi_cif cif;
+    struct MethodHandlePool* pool;
+    MethodHandle* next;
+};
+#if !defined(_WIN32) && !defined(__WIN32__)
+struct MethodHandlePool {
+#ifdef HAVE_NATIVETHREAD
+    pthread_mutex_t mutex;
+#endif
+    MethodHandle* list;
+};
+#endif /* _WIN32 */
+
+static VALUE invoker_allocate(VALUE klass);
+static VALUE invoker_initialize(VALUE self, VALUE function, VALUE parameterTypes,
+        VALUE rbReturnType, VALUE returnType, VALUE convention, VALUE enums);
+static void invoker_mark(Invoker *);
+static void invoker_free(Invoker *);
+static VALUE invoker_call(int argc, VALUE* argv, VALUE self);
+static VALUE invoker_arity(VALUE self);
+static void* callback_param(VALUE proc, VALUE cbinfo);
+#ifdef USE_RAW
+static void attached_method_invoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data);
+static void attached_method_vinvoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data);
+#else
+#ifndef _WIN32
+static void attached_method_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+#endif /* _WIN32 */
+static void attached_method_vinvoke(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+#endif
+static MethodHandle* method_handle_alloc(int arity);
+static void method_handle_free(MethodHandle *);
+
+
+#ifndef _WIN32
+static int PageSize;
+#endif
+
+VALUE rbffi_InvokerClass = Qnil;
+static VALUE classInvoker = Qnil, classVariadicInvoker = Qnil;
+static ID to_ptr = 0;
+static ID map_symbol_id = 0;
+
+#ifdef USE_RAW
+#  ifndef __i386__
+#    error "RAW argument packing only supported on i386"
+#  endif
+
+#define INT8_SIZE (sizeof(char))
+#define INT16_SIZE (sizeof(short))
+#define INT32_SIZE (sizeof(int))
+#define INT64_SIZE (sizeof(long long))
+#define FLOAT32_SIZE (sizeof(float))
+#define FLOAT64_SIZE (sizeof(double))
+#define ADDRESS_SIZE (sizeof(void *))
+#define INT8_ADJ (4)
+#define INT16_ADJ (4)
+#define INT32_ADJ (4)
+#define INT64_ADJ (8)
+#define FLOAT32_ADJ (4)
+#define FLOAT64_ADJ (8)
+#define ADDRESS_ADJ (sizeof(void *))
+
+#endif /* USE_RAW */
+
+#ifdef USE_RAW
+#  define ADJ(p, a) ((p) = (FFIStorage*) (((char *) p) + a##_ADJ))
+#else
+#  define ADJ(p, a) (++(p))
+#endif
+
+static VALUE
+invoker_allocate(VALUE klass)
+{
+    Invoker *invoker;
+    VALUE obj = Data_Make_Struct(klass, Invoker, invoker_mark, invoker_free, invoker);
+
+    invoker->rbReturnType = Qnil;
+    invoker->callbackArray = Qnil;
+    invoker->address = Qnil;
+    invoker->enums = Qnil;
+
+    return obj;
+}
+
+static VALUE
+invoker_initialize(VALUE self, VALUE function, VALUE parameterTypes,
+        VALUE rbReturnTypeSymbol, VALUE returnType, VALUE convention, VALUE enums)
+{
+    Invoker* invoker = NULL;
+    ffi_type* ffiReturnType;
+    ffi_abi abi;
+    ffi_status ffiStatus;
+    int i;
+
+    Check_Type(parameterTypes, T_ARRAY);
+    Check_Type(rbReturnTypeSymbol, T_SYMBOL);
+    Check_Type(convention, T_STRING);
+    Check_Type(function, T_DATA);
+
+    Data_Get_Struct(self, Invoker, invoker);
+    invoker->enums = enums;
+    invoker->address = function;
+    invoker->function = rbffi_AbstractMemory_Cast(function, rbffi_PointerClass)->address;
+    invoker->paramCount = RARRAY_LEN(parameterTypes);
+    invoker->paramTypes = ALLOC_N(NativeType, invoker->paramCount);
+    invoker->ffiParamTypes = ALLOC_N(ffi_type *, invoker->paramCount);
+
+    for (i = 0; i < invoker->paramCount; ++i) {
+        VALUE entry = rb_ary_entry(parameterTypes, i);
+        if (rb_obj_is_kind_of(entry, rbffi_CallbackInfoClass)) {
+            invoker->callbackParameters = REALLOC_N(invoker->callbackParameters, VALUE,
+                    invoker->callbackCount + 1);
+            invoker->callbackParameters[invoker->callbackCount++] = entry;
+            invoker->paramTypes[i] = NATIVE_CALLBACK;
+            invoker->ffiParamTypes[i] = &ffi_type_pointer;
+        } else if (rb_obj_is_kind_of(entry, rbffi_TypeClass)){
+            int paramType = rbffi_Type_GetIntValue(entry);
+            invoker->paramTypes[i] = paramType;
+            invoker->ffiParamTypes[i] = rbffi_NativeType_ToFFI(paramType);
+        }
+        if (invoker->ffiParamTypes[i] == NULL) {
+            rb_raise(rb_eTypeError, "Invalid parameter type");
+        }
+    }
+    if (!rb_obj_is_kind_of(returnType, rbffi_TypeClass)) {
+        rb_raise(rb_eTypeError, "Invalid return type");
+    }
+    Data_Get_Struct(returnType, Type, invoker->returnType);
+    invoker->rbReturnType = rb_obj_is_kind_of(returnType, rbffi_CallbackInfoClass)
+        ? returnType : rbReturnTypeSymbol;
+    
+    ffiReturnType = invoker->returnType->ffiType;
+    if (ffiReturnType == NULL) {
+        rb_raise(rb_eTypeError, "Invalid return type");
+    }
+#if defined(_WIN32) || defined(__WIN32__)
+    abi = strcmp(StringValueCStr(convention), "stdcall") == 0 ? FFI_STDCALL : FFI_DEFAULT_ABI;
+#else
+    abi = FFI_DEFAULT_ABI;
+#endif
+    ffiStatus = ffi_prep_cif(&invoker->cif, abi, invoker->paramCount,
+            ffiReturnType, invoker->ffiParamTypes);
+    switch (ffiStatus) {
+        case FFI_BAD_ABI:
+            rb_raise(rb_eArgError, "Invalid ABI specified");
+        case FFI_BAD_TYPEDEF:
+            rb_raise(rb_eArgError, "Invalid argument type specified");
+        case FFI_OK:
+            break;
+        default:
+            rb_raise(rb_eArgError, "Unknown FFI error");
+    }
+    invoker->methodHandle = method_handle_alloc(invoker->callbackCount < 1 ? invoker->paramCount : -1);
+    invoker->methodHandle->invoker = invoker;
+    return self;
+}
+
+static VALUE
+variadic_invoker_new(VALUE klass, VALUE function, VALUE rbReturnTypeSymbol, VALUE returnType, VALUE convention, VALUE enums)
+{
+    Invoker* invoker = NULL;
+    VALUE retval = Qnil;
+
+    Check_Type(rbReturnTypeSymbol, T_SYMBOL);
+    Check_Type(convention, T_STRING);
+    Check_Type(function, T_DATA);
+
+    retval = Data_Make_Struct(klass, Invoker, invoker_mark, invoker_free, invoker);
+    invoker->enums = enums;
+    invoker->address = function;
+    invoker->function = rbffi_AbstractMemory_Cast(function, rbffi_PointerClass)->address;
+#if defined(_WIN32) || defined(__WIN32__)
+    invoker->abi = strcmp(StringValueCStr(convention), "stdcall") == 0 ? FFI_STDCALL : FFI_DEFAULT_ABI;
+#else
+    invoker->abi = FFI_DEFAULT_ABI;
+#endif
+
+    invoker->rbReturnType = rb_obj_is_kind_of(returnType, rbffi_CallbackInfoClass)
+        ? returnType : rbReturnTypeSymbol;
+    if (!rb_obj_is_kind_of(returnType, rbffi_TypeClass)) {
+        rb_raise(rb_eTypeError, "Invalid return type");
+    }
+    Data_Get_Struct(returnType, Type, invoker->returnType);
+    invoker->paramCount = -1;
+    return retval;
+}
+
+static ffi_type* methodHandleParamTypes[MAX_FIXED_ARITY + 2];
+static ffi_type* methodHandleVarargParamTypes[]= {
+    &ffi_type_sint,
+    &ffi_type_pointer,
+    NULL,
+};
+
+#if defined(_WIN32) || defined(__WIN32__)
+static MethodHandle*
+method_handle_alloc(int arity)
+{
+    char errmsg[1024];
+    ffi_type* ffiReturnType = (sizeof (VALUE) == sizeof (long))
+            ? &ffi_type_ulong : &ffi_type_uint64;
+    int ffiParamCount, ffiStatus;
+    MethodHandle* method = NULL;
+    ffi_type** ffiParamTypes;
+    void (*fn)(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+
+    ffiParamCount = 3;
+    ffiParamTypes = methodHandleVarargParamTypes;
+    fn = attached_method_vinvoke;
+    method = ALLOC_N(MethodHandle, 1);
+    memset(method, 0, sizeof(*method));
+    method->arity = -1;
+    ffiStatus = ffi_prep_cif(&method->cif, FFI_DEFAULT_ABI, ffiParamCount,
+            ffiReturnType, ffiParamTypes);
+    if (ffiStatus != FFI_OK) {
+        snprintf(errmsg, sizeof (errmsg), "ffi_prep_cif failed.  status=%#x", ffiStatus);
+        goto error;
+    }
+    method->closure = ffi_closure_alloc(sizeof(*method->closure), &method->code);
+    if (method->closure == NULL) {
+        snprintf(errmsg, sizeof(errmsg), "ffi_closure_alloc failed");
+        goto error;
+    }
+    ffiStatus = ffi_prep_closure_loc(method->closure, &method->cif, fn, method, method->code);
+    if (ffiStatus != FFI_OK) {
+        snprintf(errmsg, sizeof (errmsg), "ffi_prep_closure failed.  status=%#x", ffiStatus);
+        goto error;
+    }
+    return method;
+error:
+    if (method != NULL) {
+        if (method->closure != NULL) {
+            ffi_closure_free(method->closure);
+        }
+        xfree(method);
+    }
+    rb_raise(rb_eRuntimeError, "%s", errmsg);
+}
+static void
+method_handle_free(MethodHandle* method)
+{
+    if (method->closure != NULL) {
+        ffi_closure_free(method->closure);
+    }
+    xfree(method);
+}
+#else
+static MethodHandlePool methodHandlePool[MAX_FIXED_ARITY + 1], defaultMethodHandlePool;
+
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
+#  define pool_lock(p) pthread_mutex_lock(&(p)->mutex)
+#  define pool_unlock(p)  pthread_mutex_unlock(&(p)->mutex)
+#else
+#  define pool_lock(p)
+#  define pool_unlock(p)
+#endif
+static MethodHandle*
+method_handle_alloc(int arity)
+{
+    MethodHandle* method, *list = NULL;
+    MethodHandlePool* pool;
+    ffi_type** ffiParamTypes;
+    ffi_type* ffiReturnType;
+    caddr_t page;
+    int ffiParamCount, ffiStatus;
+    int nclosures, closureSize, methodArity;
+    int i;
+#ifdef USE_RAW
+    void (*fn)(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data);
+#else
+    void (*fn)(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+#endif
+    
+    
+    pool = (arity >= 0 && arity <= MAX_FIXED_ARITY) ? &methodHandlePool[arity] : &defaultMethodHandlePool;
+    pool_lock(pool);
+    if (pool->list != NULL) {
+        method = pool->list;
+        pool->list = pool->list->next;
+        pool_unlock(pool);
+        return method;
+    }
+    ffiReturnType = (sizeof (VALUE) == sizeof (long))
+            ? &ffi_type_ulong : &ffi_type_uint64;
+    closureSize = roundup(sizeof(METHOD_CLOSURE), 8);
+    nclosures = PageSize / closureSize;
+    page = mmap(NULL, PageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (page == (caddr_t) -1) {
+        pool_unlock(pool);
+        rb_raise(rb_eRuntimeError, "mmap failed. errno=%d (%s)", errno, strerror(errno));
+    }
+
+    /* figure out whichh function to bounce the execution through */
+    if (arity >= 0 && arity <= MAX_FIXED_ARITY) {
+        ffiParamCount = arity + 1;
+        ffiParamTypes = methodHandleParamTypes;
+        fn = attached_method_invoke;
+        methodArity = arity;
+    } else {
+        ffiParamCount = 3;
+        ffiParamTypes = methodHandleVarargParamTypes;
+        fn = attached_method_vinvoke;
+        methodArity = -1;
+    }
+
+    for (i = 0; i < nclosures; ++i) {
+        char errmsg[256];
+        method = calloc(1, sizeof(MethodHandle));
+        if (method == NULL) {
+            snprintf(errmsg, sizeof(errmsg), "malloc failed: %s", strerror(errno));
+            goto error;
+        }
+        method->next = list;
+        list = method;
+        method->pool = pool;
+        method->code = method->closure = (METHOD_CLOSURE *) (page + (i * closureSize));
+
+        ffiStatus = ffi_prep_cif(&method->cif, FFI_DEFAULT_ABI, ffiParamCount,
+                    ffiReturnType, ffiParamTypes);
+        if (ffiStatus != FFI_OK) {
+            snprintf(errmsg, sizeof(errmsg), "ffi_prep_cif failed.  status=%#x", ffiStatus);
+            goto error;
+        }
+
+#ifdef USE_RAW
+        ffiStatus = ffi_prep_raw_closure(method->closure, &method->cif, fn, method);
+#else
+        ffiStatus = ffi_prep_closure(method->closure, &method->cif, fn, method);
+#endif
+        if (ffiStatus != FFI_OK) {
+            snprintf(errmsg, sizeof(errmsg), "ffi_prep_closure failed.  status=%#x", ffiStatus);
+            goto error;
+        }
+        method->arity = methodArity;
+        continue;
+error:
+        while (list != NULL) {
+            method = list;
+            list = list->next;
+            free(method);
+        }
+        munmap(page, PageSize);
+        pool_unlock(pool);
+        rb_raise(rb_eRuntimeError, "%s", errmsg);
+    }
+    mprotect(page, PageSize, PROT_READ | PROT_EXEC);
+
+    /* take the first member of the list for this handle */
+    method = list;
+    list = list->next;
+
+    /* now add the new block of MethodHandles to the pool */
+    if (list != NULL) {
+        list->next = pool->list;
+        pool->list = list;
+    }
+    pool_unlock(pool);
+    return method;
+}
+static void
+method_handle_free(MethodHandle* method)
+{
+    MethodHandlePool* pool = method->pool;
+    pool_lock(pool);
+    method->next = pool->list;
+    pool->list = method;
+    pool_unlock(pool);
+}
+#endif /* _WIN32 */
+
+typedef union {
+#ifdef USE_RAW
+    signed int s8, s16, s32;
+    unsigned int u8, u16, u32;
+#else
+    signed char s8;
+    unsigned char u8;
+    signed short s16;
+    unsigned short u16;
+    signed int s32;
+    unsigned int u32;
+#endif
+    signed long long i64;
+    unsigned long long u64;
+    void* ptr;
+    float f32;
+    double f64;
+} FFIStorage;
+
+static inline int
+getSignedInt(VALUE value, int type, int minValue, int maxValue, const char* typeName, VALUE enums)
+{
+    int i;
+    if (type == T_SYMBOL && enums != Qnil) {
+        value = rb_funcall(enums, map_symbol_id, 1, value);
+        if (value == Qnil) {
+            rb_raise(rb_eTypeError, "Expected a valid enum constant");
+        }
+    }
+    else if (type != T_FIXNUM && type != T_BIGNUM) {
+        rb_raise(rb_eTypeError, "Expected an Integer parameter");
+    }
+    i = NUM2INT(value);
+    if (i < minValue || i > maxValue) {
+        rb_raise(rb_eRangeError, "Value %d outside %s range", i, typeName);
+    }
+    return i;
+}
+
+static inline int
+getUnsignedInt(VALUE value, int type, int maxValue, const char* typeName)
+{
+    int i;
+    if (type != T_FIXNUM && type != T_BIGNUM) {
+        rb_raise(rb_eTypeError, "Expected an Integer parameter");
+    }
+    i = NUM2INT(value);
+    if (i < 0 || i > maxValue) {
+        rb_raise(rb_eRangeError, "Value %d outside %s range", i, typeName);
+    }
+    return i;
+}
+
+/* Special handling/checking for unsigned 32 bit integers */
+static inline unsigned int
+getUnsignedInt32(VALUE value, int type)
+{
+    long long i;
+    if (type != T_FIXNUM && type != T_BIGNUM) {
+        rb_raise(rb_eTypeError, "Expected an Integer parameter");
+    }
+    i = NUM2LL(value);
+    if (i < 0L || i > 0xffffffffL) {
+        rb_raise(rb_eRangeError, "Value %lld outside unsigned int range", i);
+    }
+    return (unsigned int) i;
+}
+
+static void
+ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTypes,
+        FFIStorage* paramStorage, void** ffiValues)
+{
+    VALUE callbackProc = Qnil;
+    FFIStorage* param = &paramStorage[0];
+    int i, argidx, cbidx, argCount;
+
+    if (invoker->paramCount != -1 && invoker->paramCount != argc) {
+        if (argc == (invoker->paramCount - 1) && invoker->callbackCount == 1 && rb_block_given_p()) {
+            callbackProc = rb_block_proc();
+        } else {
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, invoker->paramCount);
+        }
+    }
+    argCount = invoker->paramCount != -1 ? invoker->paramCount : argc;
+    for (i = 0, argidx = 0, cbidx = 0; i < argCount; ++i) {
+        int type = argidx < argc ? TYPE(argv[argidx]) : T_NONE;
+        ffiValues[i] = param;
+        switch (paramTypes[i]) {
+            case NATIVE_INT8:
+                param->s8 = getSignedInt(argv[argidx++], type, -128, 127, "char", Qnil);
+                ADJ(param, INT8);
+                break;
+            case NATIVE_INT16:
+                param->s16 = getSignedInt(argv[argidx++], type, -0x8000, 0x7fff, "short", Qnil);
+                ADJ(param, INT16);
+                break;
+            case NATIVE_INT32:
+            case NATIVE_ENUM:
+                param->s32 = getSignedInt(argv[argidx++], type, -0x80000000, 0x7fffffff, "int", invoker->enums);
+                ADJ(param, INT32);
+                break;
+            case NATIVE_BOOL:
+                if (type != T_TRUE && type != T_FALSE) {
+                    rb_raise(rb_eTypeError, "Expected a Boolean parameter");
+                }
+                param->s32 = argv[argidx++] == Qtrue;
+                ADJ(param, INT32);
+                break;
+            case NATIVE_UINT8:
+                param->u8 = getUnsignedInt(argv[argidx++], type, 0xff, "unsigned char");
+                ADJ(param, INT8);
+                break;
+            case NATIVE_UINT16:
+                param->u16 = getUnsignedInt(argv[argidx++], type, 0xffff, "unsigned short");
+                ADJ(param, INT16);
+                break;
+            case NATIVE_UINT32:
+                /* Special handling/checking for unsigned 32 bit integers */
+                param->u32 = getUnsignedInt32(argv[argidx++], type);
+                ADJ(param, INT32);
+                break;
+            case NATIVE_INT64:
+                if (type != T_FIXNUM && type != T_BIGNUM) {
+                    rb_raise(rb_eTypeError, "Expected an Integer parameter");
+                }
+                param->i64 = NUM2LL(argv[argidx]);
+                ADJ(param, INT64);
+                ++argidx;
+                break;
+            case NATIVE_UINT64:
+                if (type != T_FIXNUM && type != T_BIGNUM) {
+                    rb_raise(rb_eTypeError, "Expected an Integer parameter");
+                }
+                param->u64 = NUM2ULL(argv[argidx]);
+                ADJ(param, INT64);
+                ++argidx;
+                break;
+            case NATIVE_FLOAT32:
+                if (type != T_FLOAT && type != T_FIXNUM) {
+                    rb_raise(rb_eTypeError, "Expected a Float parameter");
+                }
+                param->f32 = (float) NUM2DBL(argv[argidx]);
+                ADJ(param, FLOAT32);
+                ++argidx;
+                break;
+            case NATIVE_FLOAT64:
+                if (type != T_FLOAT && type != T_FIXNUM) {
+                    rb_raise(rb_eTypeError, "Expected a Float parameter");
+                }
+                param->f64 = NUM2DBL(argv[argidx]);
+                ADJ(param, FLOAT64);
+                ++argidx;
+                break;
+            case NATIVE_STRING:
+                if (type == T_STRING) {
+                    if (rb_safe_level() >= 1 && OBJ_TAINTED(argv[argidx])) {
+                        rb_raise(rb_eSecurityError, "Unsafe string parameter");
+                    }
+                    param->ptr = StringValueCStr(argv[argidx]);
+                } else if (type == T_NIL) {
+                    param->ptr = NULL;
+                } else {
+                    rb_raise(rb_eArgError, "Invalid String value");
+                }
+                ADJ(param, ADDRESS);
+                ++argidx;
+                break;
+            case NATIVE_POINTER:
+            case NATIVE_BUFFER_IN:
+            case NATIVE_BUFFER_OUT:
+            case NATIVE_BUFFER_INOUT:
+                if (type == T_DATA && rb_obj_is_kind_of(argv[argidx], rbffi_AbstractMemoryClass)) {
+                    param->ptr = ((AbstractMemory *) DATA_PTR(argv[argidx]))->address;
+                } else if (type == T_DATA && rb_obj_is_kind_of(argv[argidx], rbffi_StructClass)) {
+                    AbstractMemory* memory = ((Struct *) DATA_PTR(argv[argidx]))->pointer;
+                    param->ptr = memory != NULL ? memory->address : NULL;
+                } else if (type == T_STRING) {
+                    if (rb_safe_level() >= 1 && OBJ_TAINTED(argv[argidx])) {
+                        rb_raise(rb_eSecurityError, "Unsafe string parameter");
+                    }
+                    param->ptr = StringValuePtr(argv[argidx]);
+                } else if (type == T_NIL) {
+                    param->ptr = NULL;
+                } else if (rb_respond_to(argv[argidx], to_ptr)) {
+                    VALUE ptr = rb_funcall2(argv[argidx], to_ptr, 0, NULL);
+                    if (rb_obj_is_kind_of(ptr, rbffi_AbstractMemoryClass) && TYPE(ptr) == T_DATA) {
+                        param->ptr = ((AbstractMemory *) DATA_PTR(ptr))->address;
+                    } else {
+                        rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
+                    }
+
+                } else {
+                    rb_raise(rb_eArgError, ":pointer argument is not a valid pointer");
+                }
+                ADJ(param, ADDRESS);
+                ++argidx;
+                break;
+            case NATIVE_CALLBACK:
+                if (callbackProc != Qnil) {
+                    param->ptr = callback_param(callbackProc, invoker->callbackParameters[cbidx++]);
+                } else {
+                    param->ptr = callback_param(argv[argidx], invoker->callbackParameters[cbidx++]);
+                    ++argidx;
+                }
+                ADJ(param, ADDRESS);
+                break;
+            default:
+                rb_raise(rb_eArgError, "Invalid parameter type: %d", paramTypes[i]);
+        }
+    }
+}
+static inline VALUE
+ffi_invoke(ffi_cif* cif, Invoker* invoker, void** ffiValues)
+{
+    FFIStorage retval;
+
+#ifdef USE_RAW
+    ffi_raw_call(cif, FFI_FN(invoker->function), &retval, (ffi_raw *) ffiValues[0]);
+#else
+    ffi_call(cif, FFI_FN(invoker->function), &retval, ffiValues);
+#endif
+    rbffi_save_errno();
+
+    return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, &retval,
+        invoker->enums);
+}
+
+static VALUE
+invoker_call(int argc, VALUE* argv, VALUE self)
+{
+    Invoker* invoker;
+    int argCount;
+    FFIStorage params_[MAX_FIXED_ARITY], *params = &params_[0];
+    void* ffiValues_[MAX_FIXED_ARITY], **ffiValues = &ffiValues_[0];
+
+    Data_Get_Struct(self, Invoker, invoker);
+
+    argCount = invoker->paramCount != -1 ? invoker->paramCount : argc;
+
+    if (argCount > MAX_FIXED_ARITY) {
+        params = ALLOCA_N(FFIStorage, argCount);
+        ffiValues = ALLOCA_N(void *, argCount);
+    }
+
+    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
+
+    return ffi_invoke(&invoker->cif, invoker, ffiValues);
+}
+
+#ifdef USE_RAW
+
+/*
+ * attached_method_invoke is used as the <= 3 argument fixed-arity fast path
+ */
+static void
+attached_method_invoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void* ffiValues[MAX_FIXED_ARITY];
+    FFIStorage params[MAX_FIXED_ARITY];
+
+    if (invoker->paramCount > 0) {
+        ffi_arg_setup(invoker, invoker->paramCount, (VALUE *)&parameters[1],
+                invoker->paramTypes, params, ffiValues);
+    }
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker, ffiValues);
+}
+
+/*
+ * attached_method_vinvoke is used functions with more than 3 parameters
+ */
+static void
+attached_method_vinvoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void** ffiValues = ALLOCA_N(void *, invoker->paramCount);
+    FFIStorage* params = ALLOCA_N(FFIStorage, invoker->paramCount);
+    int argc = parameters[0].sint;
+    VALUE* argv = *(VALUE **) &parameters[1];
+
+    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker, ffiValues);
+}
+
+#else
+#ifndef _WIN32
+static void
+attached_method_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void* ffiValues[MAX_FIXED_ARITY];
+    FFIStorage params[MAX_FIXED_ARITY];
+    VALUE argv[MAX_FIXED_ARITY];
+    int i;
+    //printf("Attached method invoke nargs=%d paramCount=%d\n", cif->nargs, invoker->paramCount); fflush(stdout);
+    for (i = 0; i < invoker->paramCount; ++i) {
+        memcpy(&argv[i], parameters[i + 1], sizeof(argv[i]));
+    }
+    if (invoker->paramCount > 0) {
+        ffi_arg_setup(invoker, invoker->paramCount, argv, invoker->paramTypes, params, ffiValues);
+    }
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker, ffiValues);
+}
+#endif /* _WIN32 */
+static void
+attached_method_vinvoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void** ffiValues = ALLOCA_N(void *, invoker->paramCount);
+    FFIStorage* params = ALLOCA_N(FFIStorage, invoker->paramCount);
+    int argc = *(int *) parameters[0];
+    VALUE* argv = *(VALUE **) parameters[1];
+
+    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker, ffiValues);
+}
+#endif
+
+static VALUE
+invoker_attach(VALUE self, VALUE module, VALUE name)
+{
+    Invoker* invoker;
+    MethodHandle* handle;
+    char var[1024];
+
+    Data_Get_Struct(self, Invoker, invoker);
+    if (invoker->paramCount == -1) {
+        rb_raise(rb_eRuntimeError, "Cannot attach variadic invokers");
+    }
+
+    handle = invoker->methodHandle;
+    rb_define_module_function(module, StringValueCStr(name), 
+            handle->code, handle->arity);
+    snprintf(var, sizeof(var), "@@%s", StringValueCStr(name));
+    rb_cv_set(module, var, self);
+    rb_define_method(module, StringValueCStr(name), 
+            handle->code, handle->arity);
+    return self;
+}
+static VALUE
+invoker_arity(VALUE self)
+{
+    Invoker* invoker;
+    Data_Get_Struct(self, Invoker, invoker);
+    return INT2FIX(invoker->paramCount);
+}
+
+static void
+invoker_mark(Invoker *invoker)
+{
+    if (invoker->callbackCount > 0) {
+        rb_gc_mark_locations(&invoker->callbackParameters[0], &invoker->callbackParameters[invoker->callbackCount]);
+    }
+    if (invoker->address != Qnil) {
+        rb_gc_mark(invoker->address);
+    }
+    if (invoker->enums != Qnil) {
+        rb_gc_mark(invoker->enums);
+    }
+    if (invoker->rbReturnType != Qnil) {
+        rb_gc_mark(invoker->rbReturnType);
+    }
+}
+
+static void
+invoker_free(Invoker *invoker)
+{
+    if (invoker != NULL) {
+        if (invoker->paramTypes != NULL) {
+            xfree(invoker->paramTypes);
+            invoker->paramTypes = NULL;
+        }
+        if (invoker->ffiParamTypes != NULL) {
+            xfree(invoker->ffiParamTypes);
+            invoker->ffiParamTypes = NULL;
+        }
+        if (invoker->callbackParameters != NULL) {
+            xfree(invoker->callbackParameters);
+            invoker->callbackParameters = NULL;
+        }
+        if (invoker->methodHandle != NULL) {
+            method_handle_free(invoker->methodHandle);
+        }
+        xfree(invoker);
+    }
+}
+
+static VALUE
+variadic_invoker_call(VALUE self, VALUE parameterTypes, VALUE parameterValues)
+{
+    Invoker* invoker;
+    FFIStorage* params;
+    ffi_cif cif;
+    void** ffiValues;
+    ffi_type** ffiParamTypes;
+    ffi_type* ffiReturnType;
+    NativeType* paramTypes;
+    VALUE* argv;
+    int paramCount = 0, i;
+    ffi_status ffiStatus;
+
+    Check_Type(parameterTypes, T_ARRAY);
+    Check_Type(parameterValues, T_ARRAY);
+
+    Data_Get_Struct(self, Invoker, invoker);
+    paramCount = RARRAY_LEN(parameterTypes);
+    paramTypes = ALLOCA_N(NativeType, paramCount);
+    ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
+    params = ALLOCA_N(FFIStorage, paramCount);
+    ffiValues = ALLOCA_N(void*, paramCount);
+    argv = ALLOCA_N(VALUE, paramCount);
+
+    for (i = 0; i < paramCount; ++i) {
+        VALUE entry = rb_ary_entry(parameterTypes, i);
+        int paramType = rbffi_Type_GetIntValue(entry);
+        switch (paramType) {
+            case NATIVE_INT8:
+            case NATIVE_INT16:
+            case NATIVE_INT32:
+            case NATIVE_ENUM:
+                paramType = NATIVE_INT32;
+                break;
+            case NATIVE_UINT8:
+            case NATIVE_UINT16:
+            case NATIVE_UINT32:
+                paramType = NATIVE_UINT32;
+                break;
+            case NATIVE_FLOAT32:
+                paramType = NATIVE_FLOAT64;
+                break;
+        }
+        paramTypes[i] = paramType;
+        ffiParamTypes[i] = rbffi_NativeType_ToFFI(paramType);
+        if (ffiParamTypes[i] == NULL) {
+            rb_raise(rb_eArgError, "Invalid parameter type #%x", paramType);
+        }
+        argv[i] = rb_ary_entry(parameterValues, i);
+    }
+
+    ffiReturnType = invoker->returnType->ffiType;
+    if (ffiReturnType == NULL) {
+        rb_raise(rb_eArgError, "Invalid return type");
+    }
+    ffiStatus = ffi_prep_cif(&cif, invoker->abi, paramCount, ffiReturnType, ffiParamTypes);
+    switch (ffiStatus) {
+        case FFI_BAD_ABI:
+            rb_raise(rb_eArgError, "Invalid ABI specified");
+        case FFI_BAD_TYPEDEF:
+            rb_raise(rb_eArgError, "Invalid argument type specified");
+        case FFI_OK:
+            break;
+        default:
+            rb_raise(rb_eArgError, "Unknown FFI error");
+    }
+    ffi_arg_setup(invoker, paramCount, argv, paramTypes, params, ffiValues);
+    return ffi_invoke(&cif, invoker, ffiValues);
+}
+
+static void* 
+callback_param(VALUE proc, VALUE cbInfo)
+{
+    VALUE callback ;
+    if (proc == Qnil) {
+        return NULL ;
+    }
+    callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
+    return ((NativeCallback *) DATA_PTR(callback))->code;
+}
+
+void 
+rbffi_Invoker_Init(VALUE moduleFFI)
+{
+    ffi_type* ffiValueType;
+    int i;
+
+    rbffi_InvokerClass = classInvoker = rb_define_class_under(moduleFFI, "Invoker", rb_cObject);
+    rb_global_variable(&rbffi_InvokerClass);
+    rb_global_variable(&classInvoker);
+
+    rb_define_alloc_func(classInvoker, invoker_allocate);
+    rb_define_method(classInvoker, "initialize", invoker_initialize, 6);
+    rb_define_method(classInvoker, "call", invoker_call, -1);
+    rb_define_alias(classInvoker, "call0", "call");
+    rb_define_alias(classInvoker, "call1", "call");
+    rb_define_alias(classInvoker, "call2", "call");
+    rb_define_alias(classInvoker, "call3", "call");
+    rb_define_method(classInvoker, "arity", invoker_arity, 0);
+    rb_define_method(classInvoker, "attach", invoker_attach, 2);
+    classVariadicInvoker = rb_define_class_under(moduleFFI, "VariadicInvoker", rb_cObject);
+    rb_global_variable(&classVariadicInvoker);
+    
+    rb_define_singleton_method(classVariadicInvoker, "__new", variadic_invoker_new, 5);
+    rb_define_method(classVariadicInvoker, "invoke", variadic_invoker_call, 2);
+    rb_define_alias(classVariadicInvoker, "call", "invoke");
+
+    to_ptr = rb_intern("to_ptr");
+    map_symbol_id = rb_intern("__map_symbol");
+    
+    ffiValueType = (sizeof (VALUE) == sizeof (long))
+            ? &ffi_type_ulong : &ffi_type_uint64;
+    for (i = 0; i <= MAX_FIXED_ARITY + 1; ++i) {
+        methodHandleParamTypes[i] = ffiValueType;
+    }
+    methodHandleVarargParamTypes[2] = ffiValueType;
+
+#ifndef _WIN32
+    PageSize = sysconf(_SC_PAGESIZE);
+#endif /* _WIN32 */
+
+#if defined(USE_PTHREAD_LOCAL)
+    for (i = 0; i < 4; ++i) {
+        pthread_mutex_init(&methodHandlePool[i].mutex, NULL);
+    }
+    pthread_mutex_init(&defaultMethodHandlePool.mutex, NULL);
+#endif /* USE_PTHREAD_LOCAL */
+
+}