ffi 0.3.1 → 0.4.0

data/ext/ffi_c/Invoker.c

@@ -6,14 +6,14 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
-#include <unistd.h>
+#ifndef _WIN32
+#  include <unistd.h>
+#  include <pthread.h>
+#endif
 #include <errno.h>
 #include <ruby.h>
 
 #include <ffi.h>
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
-# include <pthread.h>
-#endif
 #include "rbffi.h"
 #include "compat.h"
 
@@ -23,6 +23,8 @@
 #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
@@ -32,17 +34,23 @@
 #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 library;
+    VALUE address;
+    VALUE enums;
     void* function;
     ffi_cif cif;
     int paramCount;
     ffi_type** ffiParamTypes;
     NativeType* paramTypes;
-    NativeType returnType;
+    Type* returnType;
+    VALUE rbReturnType;
     VALUE callbackArray;
     int callbackCount;
     VALUE* callbackParameters;
@@ -72,16 +80,13 @@ struct MethodHandlePool {
     MethodHandle* list;
 };
 #endif /* _WIN32 */
-typedef struct ThreadData {
-    int td_errno;
-} ThreadData;
+
 static VALUE invoker_allocate(VALUE klass);
-static VALUE invoker_initialize(VALUE self, VALUE library, VALUE function, VALUE parameterTypes,
-        VALUE returnType, VALUE convention);
+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_call0(VALUE self);
 static VALUE invoker_arity(VALUE self);
 static void* callback_param(VALUE proc, VALUE cbinfo);
 #ifdef USE_RAW
@@ -96,19 +101,15 @@ static void attached_method_vinvoke(ffi_cif* cif, void* retval, void** parameter
 static MethodHandle* method_handle_alloc(int arity);
 static void method_handle_free(MethodHandle *);
 
-static inline ThreadData* thread_data_get(void);
 
 #ifndef _WIN32
 static int PageSize;
 #endif
-static VALUE classInvoker = Qnil, classVariadicInvoker = Qnil;
-static ID to_ptr;
-
-#if defined(USE_PTHREAD_LOCAL)
-static pthread_key_t threadDataKey;
-#endif
 
-#define threadData (thread_data_get())
+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__
@@ -142,12 +143,19 @@ static VALUE
 invoker_allocate(VALUE klass)
 {
     Invoker *invoker;
-    return Data_Make_Struct(klass, Invoker, invoker_mark, invoker_free, 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 library, VALUE function, VALUE parameterTypes,
-        VALUE returnType, VALUE convention)
+invoker_initialize(VALUE self, VALUE function, VALUE parameterTypes,
+        VALUE rbReturnTypeSymbol, VALUE returnType, VALUE convention, VALUE enums)
 {
     Invoker* invoker = NULL;
     ffi_type* ffiReturnType;
@@ -156,39 +164,45 @@ invoker_initialize(VALUE self, VALUE library, VALUE function, VALUE parameterTyp
     int i;
 
     Check_Type(parameterTypes, T_ARRAY);
-    Check_Type(returnType, T_FIXNUM);
+    Check_Type(rbReturnTypeSymbol, T_SYMBOL);
     Check_Type(convention, T_STRING);
-    Check_Type(library, T_DATA);
     Check_Type(function, T_DATA);
 
     Data_Get_Struct(self, Invoker, invoker);
-    invoker->library = library;
-    invoker->function = rb_FFI_AbstractMemory_cast(function, rb_FFI_Pointer_class)->address;
+    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, rb_FFI_CallbackInfo_class)) {
+        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 {
-            int paramType = FIX2INT(entry);
+        } else if (rb_obj_is_kind_of(entry, rbffi_TypeClass)){
+            int paramType = rbffi_Type_GetIntValue(entry);
             invoker->paramTypes[i] = paramType;
-            invoker->ffiParamTypes[i] = rb_FFI_NativeTypeToFFI(paramType);
+            invoker->ffiParamTypes[i] = rbffi_NativeType_ToFFI(paramType);
         }
         if (invoker->ffiParamTypes[i] == NULL) {
-            rb_raise(rb_eArgError, "Invalid parameter type");
+            rb_raise(rb_eTypeError, "Invalid parameter type");
         }
     }
-    invoker->returnType = FIX2INT(returnType);
-    ffiReturnType = rb_FFI_NativeTypeToFFI(invoker->returnType);
+    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_eArgError, "Invalid return type");
+        rb_raise(rb_eTypeError, "Invalid return type");
     }
 #if defined(_WIN32) || defined(__WIN32__)
     abi = strcmp(StringValueCStr(convention), "stdcall") == 0 ? FFI_STDCALL : FFI_DEFAULT_ABI;
@@ -213,25 +227,31 @@ invoker_initialize(VALUE self, VALUE library, VALUE function, VALUE parameterTyp
 }
 
 static VALUE
-variadic_invoker_new(VALUE klass, VALUE library, VALUE function, VALUE returnType, VALUE convention)
+variadic_invoker_new(VALUE klass, VALUE function, VALUE rbReturnTypeSymbol, VALUE returnType, VALUE convention, VALUE enums)
 {
     Invoker* invoker = NULL;
     VALUE retval = Qnil;
 
-    Check_Type(returnType, T_FIXNUM);
+    Check_Type(rbReturnTypeSymbol, T_SYMBOL);
     Check_Type(convention, T_STRING);
-    Check_Type(library, T_DATA);
     Check_Type(function, T_DATA);
 
     retval = Data_Make_Struct(klass, Invoker, invoker_mark, invoker_free, invoker);
-    invoker->library = library;
-    invoker->function = rb_FFI_AbstractMemory_cast(function, rb_FFI_Pointer_class)->address;
+    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->returnType = FIX2INT(returnType);
+
+    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;
 }
@@ -420,7 +440,7 @@ method_handle_free(MethodHandle* method)
 #endif /* _WIN32 */
 
 typedef union {
-#if BYTE_ORDER == LITTLE_ENDIAN
+#ifdef USE_RAW
     signed int s8, s16, s32;
     unsigned int u8, u16, u32;
 #else
@@ -439,10 +459,16 @@ typedef union {
 } FFIStorage;
 
 static inline int
-getSignedInt(VALUE value, int type, int minValue, int maxValue, const char* typeName)
+getSignedInt(VALUE value, int type, int minValue, int maxValue, const char* typeName, VALUE enums)
 {
     int i;
-    if (type != T_FIXNUM && type != T_BIGNUM) {
+    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);
@@ -500,18 +526,25 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
     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");
+                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");
+                param->s16 = getSignedInt(argv[argidx++], type, -0x8000, 0x7fff, "short", Qnil);
                 ADJ(param, INT16);
                 break;
             case NATIVE_INT32:
-                param->s32 = getSignedInt(argv[argidx++], type, -0x80000000, 0x7fffffff, "int");
+            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:
@@ -577,9 +610,9 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
             case NATIVE_BUFFER_IN:
             case NATIVE_BUFFER_OUT:
             case NATIVE_BUFFER_INOUT:
-                if (type == T_DATA && rb_obj_is_kind_of(argv[argidx], rb_FFI_AbstractMemory_class)) {
+                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], rb_FFI_Struct_class)) {
+                } 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) {
@@ -591,7 +624,7 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
                     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, rb_FFI_AbstractMemory_class) && TYPE(ptr) == T_DATA) {
+                    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");
@@ -618,81 +651,48 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
     }
 }
 static inline VALUE
-ffi_invoke(ffi_cif* cif, void* function, NativeType returnType, void** ffiValues)
+ffi_invoke(ffi_cif* cif, Invoker* invoker, void** ffiValues)
 {
     FFIStorage retval;
-    int error = 0;
 
 #ifdef USE_RAW
-    ffi_raw_call(cif, FFI_FN(function), &retval, (ffi_raw *) ffiValues[0]);
-#else
-    ffi_call(cif, FFI_FN(function), &retval, ffiValues);
-#endif
-#if defined(_WIN32) || defined(__WIN32__)
-    error = GetLastError();
+    ffi_raw_call(cif, FFI_FN(invoker->function), &retval, (ffi_raw *) ffiValues[0]);
 #else
-    error = errno;
+    ffi_call(cif, FFI_FN(invoker->function), &retval, ffiValues);
 #endif
-    threadData->td_errno = error;
+    rbffi_save_errno();
 
-    return rb_FFI_NativeValueToRuby(returnType, &retval);
+    return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, &retval,
+        invoker->enums);
 }
+
 static VALUE
 invoker_call(int argc, VALUE* argv, VALUE self)
 {
     Invoker* invoker;
-    FFIStorage params[MAX_PARAMETERS];
-    void* ffiValues[MAX_PARAMETERS];
+    int argCount;
+    FFIStorage params_[MAX_FIXED_ARITY], *params = &params_[0];
+    void* ffiValues_[MAX_FIXED_ARITY], **ffiValues = &ffiValues_[0];
 
     Data_Get_Struct(self, Invoker, invoker);
-    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
-    return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
-}
 
-static inline VALUE
-invoker_callN(VALUE self, int argc, VALUE* argv)
-{
-    Invoker* invoker;
-    FFIStorage params[3];
-    void* ffiValues[3];
-
-    Data_Get_Struct(self, Invoker, invoker);
-    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
-    return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
-}
-
-static VALUE
-invoker_call0(VALUE self)
-{
-    Invoker* invoker;
-    FFIStorage arg0;
-    void* ffiValues[] = { &arg0 };
-    
-    Data_Get_Struct(self, Invoker, invoker);
-    return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
-}
+    argCount = invoker->paramCount != -1 ? invoker->paramCount : argc;
 
-static VALUE
-invoker_call1(VALUE self, VALUE arg1)
-{
-    return invoker_callN(self, 1, &arg1);
-}
+    if (argCount > MAX_FIXED_ARITY) {
+        params = ALLOCA_N(FFIStorage, argCount);
+        ffiValues = ALLOCA_N(void *, argCount);
+    }
 
-static VALUE
-invoker_call2(VALUE self, VALUE arg1, VALUE arg2)
-{
-    VALUE argv[] = { arg1, arg2 };
-    return invoker_callN(self, 2, argv);
-}
+    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
 
-static VALUE
-invoker_call3(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3)
-{
-    VALUE argv[] = { arg1, arg2, arg3 };
-    return invoker_callN(self, 3, argv);
+    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)
 {
@@ -705,9 +705,12 @@ attached_method_invoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* us
         ffi_arg_setup(invoker, invoker->paramCount, (VALUE *)&parameters[1],
                 invoker->paramTypes, params, ffiValues);
     }
-    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, 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)
 {
@@ -719,7 +722,7 @@ attached_method_vinvoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* u
     VALUE* argv = *(VALUE **) &parameters[1];
 
     ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
-    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker, ffiValues);
 }
 
 #else
@@ -740,7 +743,7 @@ attached_method_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
     if (invoker->paramCount > 0) {
         ffi_arg_setup(invoker, invoker->paramCount, argv, invoker->paramTypes, params, ffiValues);
     }
-    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker, ffiValues);
 }
 #endif /* _WIN32 */
 static void
@@ -754,21 +757,29 @@ attached_method_vinvoke(ffi_cif* cif, void* retval, void** parameters, void* use
     VALUE* argv = *(VALUE **) parameters[1];
 
     ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
-    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, 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, StringValuePtr(name), 
+    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
@@ -785,8 +796,14 @@ invoker_mark(Invoker *invoker)
     if (invoker->callbackCount > 0) {
         rb_gc_mark_locations(&invoker->callbackParameters[0], &invoker->callbackParameters[invoker->callbackCount]);
     }
-    if (invoker->library != Qnil) {
-        rb_gc_mark(invoker->library);
+    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);
     }
 }
 
@@ -840,11 +857,12 @@ variadic_invoker_call(VALUE self, VALUE parameterTypes, VALUE parameterValues)
 
     for (i = 0; i < paramCount; ++i) {
         VALUE entry = rb_ary_entry(parameterTypes, i);
-        int paramType = FIX2INT(entry);
+        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:
@@ -857,14 +875,14 @@ variadic_invoker_call(VALUE self, VALUE parameterTypes, VALUE parameterValues)
                 break;
         }
         paramTypes[i] = paramType;
-        ffiParamTypes[i] = rb_FFI_NativeTypeToFFI(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 = rb_FFI_NativeTypeToFFI(invoker->returnType);
+    ffiReturnType = invoker->returnType->ffiType;
     if (ffiReturnType == NULL) {
         rb_raise(rb_eArgError, "Invalid return type");
     }
@@ -880,7 +898,7 @@ variadic_invoker_call(VALUE self, VALUE parameterTypes, VALUE parameterValues)
             rb_raise(rb_eArgError, "Unknown FFI error");
     }
     ffi_arg_setup(invoker, paramCount, argv, paramTypes, params, ffiValues);
-    return ffi_invoke(&cif, invoker->function, invoker->returnType, ffiValues);
+    return ffi_invoke(&cif, invoker, ffiValues);
 }
 
 static void* 
@@ -890,94 +908,39 @@ callback_param(VALUE proc, VALUE cbInfo)
     if (proc == Qnil) {
         return NULL ;
     }
-    callback = rb_FFI_NativeCallback_for_proc(proc, cbInfo);
+    callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
     return ((NativeCallback *) DATA_PTR(callback))->code;
 }
 
-#if defined(USE_PTHREAD_LOCAL)
-static ThreadData*
-thread_data_init()
-{
-    ThreadData* td = ALLOC_N(ThreadData, 1);
-    memset(td, 0, sizeof(*td));
-    pthread_setspecific(threadDataKey, td);
-    return td;
-}
-
-static inline ThreadData*
-thread_data_get()
-{
-    ThreadData* td = pthread_getspecific(threadDataKey);
-    return td != NULL ? td : thread_data_init();
-}
-
-static void
-thread_data_free(void *ptr)
-{
-    xfree(ptr);
-}
-
-#else
-static ID thread_data_id;
-
-static ThreadData*
-thread_data_init()
-{
-    ThreadData* td;
-    VALUE obj;
-    obj = Data_Make_Struct(rb_cObject, ThreadData, NULL, -1, td);
-    rb_thread_local_aset(rb_thread_current(), thread_data_id, obj);
-    return td;
-}
-
-static inline ThreadData*
-thread_data_get()
-{
-    VALUE obj = rb_thread_local_aref(rb_thread_current(), thread_data_id);
-
-    if (obj != Qnil && TYPE(obj) == T_DATA) {
-        return (ThreadData *) DATA_PTR(obj);
-    }
-    return thread_data_init();
-}
-
-#endif
-static VALUE
-get_last_error(VALUE self)
-{
-    return INT2NUM(threadData->td_errno);
-}
-static VALUE
-set_last_error(VALUE self, VALUE error)
-{
-    return Qnil;
-}
-
 void 
-rb_FFI_Invoker_Init()
+rbffi_Invoker_Init(VALUE moduleFFI)
 {
     ffi_type* ffiValueType;
     int i;
-    VALUE moduleFFI = rb_define_module("FFI");
-    VALUE moduleError = rb_define_module_under(moduleFFI, "LastError");
-    classInvoker = rb_define_class_under(moduleFFI, "Invoker", rb_cObject);
+
+    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, 5);
+    rb_define_method(classInvoker, "initialize", invoker_initialize, 6);
     rb_define_method(classInvoker, "call", invoker_call, -1);
-    rb_define_method(classInvoker, "call0", invoker_call0, 0);
-    rb_define_method(classInvoker, "call1", invoker_call1, 1);
-    rb_define_method(classInvoker, "call2", invoker_call2, 2);
-    rb_define_method(classInvoker, "call3", invoker_call3, 3);
+    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_define_singleton_method(classVariadicInvoker, "__new", variadic_invoker_new, 4);
+    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");
     
-    rb_define_module_function(moduleError, "error", get_last_error, 0);
-    rb_define_module_function(moduleError, "error=", set_last_error, 1);
-
     ffiValueType = (sizeof (VALUE) == sizeof (long))
             ? &ffi_type_ulong : &ffi_type_uint64;
     for (i = 0; i <= MAX_FIXED_ARITY + 1; ++i) {
@@ -990,13 +953,10 @@ rb_FFI_Invoker_Init()
 #endif /* _WIN32 */
 
 #if defined(USE_PTHREAD_LOCAL)
-    pthread_key_create(&threadDataKey, thread_data_free);
     for (i = 0; i < 4; ++i) {
         pthread_mutex_init(&methodHandlePool[i].mutex, NULL);
     }
     pthread_mutex_init(&defaultMethodHandlePool.mutex, NULL);
-#else
-    thread_data_id = rb_intern("ffi_thread_local_data");
 #endif /* USE_PTHREAD_LOCAL */
 
 }