ffi 0.4.0-x86-mswin32 → 0.5.0-x86-mswin32

data/ext/ffi_c/ArrayType.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * The name of the author or authors may not be used to endorse or promote
+ *   products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <ruby.h>
+#include <ffi.h>
+#include "ArrayType.h"
+
+static VALUE array_type_s_allocate(VALUE klass);
+static VALUE array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength);
+static void array_type_mark(ArrayType *);
+static void array_type_free(ArrayType *);
+
+VALUE rbffi_ArrayTypeClass = Qnil;
+
+static VALUE
+array_type_s_allocate(VALUE klass)
+{
+    ArrayType* array;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, ArrayType, array_type_mark, array_type_free, array);
+
+    array->base.nativeType = NATIVE_ARRAY;
+    array->base.ffiType = xcalloc(1, sizeof(*array->base.ffiType));
+    array->base.ffiType->type = FFI_TYPE_STRUCT;
+    array->base.ffiType->size = 0;
+    array->base.ffiType->alignment = 0;
+    array->rbComponentType = Qnil;
+
+    return obj;
+}
+
+static void
+array_type_mark(ArrayType *array)
+{
+    rb_gc_mark(array->rbComponentType);
+}
+
+static void
+array_type_free(ArrayType *array)
+{
+    xfree(array->base.ffiType);
+    xfree(array->ffiTypes);
+    xfree(array);
+}
+
+
+static VALUE
+array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength)
+{
+    ArrayType* array;
+    int i;
+
+    Data_Get_Struct(self, ArrayType, array);
+
+    array->length = NUM2UINT(rbLength);
+    array->rbComponentType = rbComponentType;
+    Data_Get_Struct(rbComponentType, Type, array->componentType);
+    
+    array->ffiTypes = xcalloc(array->length + 1, sizeof(*array->ffiTypes));
+    array->base.ffiType->elements = array->ffiTypes;
+    array->base.ffiType->size = array->componentType->ffiType->size * array->length;
+    array->base.ffiType->alignment = array->componentType->ffiType->alignment;
+
+    for (i = 0; i < array->length; ++i) {
+        array->ffiTypes[i] = array->componentType->ffiType;
+    }
+
+    return self;
+}
+
+static VALUE
+array_type_length(VALUE self)
+{
+    ArrayType* array;
+
+    Data_Get_Struct(self, ArrayType, array);
+
+    return UINT2NUM(array->length);
+}
+
+static VALUE
+array_type_element_type(VALUE self)
+{
+    ArrayType* array;
+
+    Data_Get_Struct(self, ArrayType, array);
+
+    return array->rbComponentType;
+}
+
+void
+rbffi_ArrayType_Init(VALUE moduleFFI)
+{
+    rbffi_ArrayTypeClass = rb_define_class_under(moduleFFI, "ArrayType", rbffi_TypeClass);
+    rb_global_variable(&rbffi_ArrayTypeClass);
+    rb_define_const(rbffi_TypeClass, "Array", rbffi_ArrayTypeClass);
+
+    rb_define_alloc_func(rbffi_ArrayTypeClass, array_type_s_allocate);
+    rb_define_method(rbffi_ArrayTypeClass, "initialize", array_type_initialize, 2);
+    rb_define_method(rbffi_ArrayTypeClass, "length", array_type_length, 0);
+    rb_define_method(rbffi_ArrayTypeClass, "elem_type", array_type_element_type, 0);
+}
+

data/ext/ffi_c/ArrayType.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * The name of the author or authors may not be used to endorse or promote
+ *   products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef RBFFI_ARRAYTYPE_H
+#define	RBFFI_ARRAYTYPE_H
+
+#include <ruby.h>
+#include <ffi.h>
+#include "Type.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+typedef struct ArrayType_ {
+    Type base;
+    int length;
+    ffi_type** ffiTypes;
+    Type* componentType;
+    VALUE rbComponentType;
+} ArrayType;
+
+extern void rbffi_ArrayType_Init(VALUE moduleFFI);
+extern VALUE rbffi_ArrayTypeClass;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_ARRAYTYPE_H */
+

data/ext/ffi_c/AutoPointer.c

@@ -26,6 +26,7 @@ autoptr_allocate(VALUE klass)
     VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, -1, p);
     p->parent = Qnil;
     p->memory.ops = &rbffi_AbstractMemoryOps;
+    p->memory.access = MEM_RD | MEM_WR;
 
     return obj;
 }

data/ext/ffi_c/Buffer.c

@@ -1,3 +1,30 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * The name of the author or authors may not be used to endorse or promote
+ *   products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <limits.h>
@@ -8,8 +35,7 @@
 typedef struct Buffer {
     AbstractMemory memory;
     char* storage; /* start of malloc area */
-    int type_size;
-    VALUE parent;
+    VALUE rbParent;
 } Buffer;
 
 static VALUE buffer_allocate(VALUE klass);
@@ -19,7 +45,6 @@ static void buffer_mark(Buffer* ptr);
 static VALUE buffer_free(VALUE self);
 
 static VALUE BufferClass = Qnil;
-#define BUFFER(obj)  ((Buffer *) rbffi_AbstractMemory_Cast((obj), BufferClass))
 
 static VALUE
 buffer_allocate(VALUE klass)
@@ -28,8 +53,9 @@ buffer_allocate(VALUE klass)
     VALUE obj;
 
     obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
-    buffer->parent = Qnil;
+    buffer->rbParent = Qnil;
     buffer->memory.ops = &rbffi_AbstractMemoryOps;
+    buffer->memory.access = MEM_RD | MEM_WR;
 
     return obj;
 }
@@ -38,7 +64,7 @@ static void
 buffer_release(Buffer* ptr)
 {
     if (ptr->storage != NULL) {
-        free(ptr->storage);
+        xfree(ptr->storage);
         ptr->storage = NULL;
     }
     
@@ -48,17 +74,17 @@ buffer_release(Buffer* ptr)
 static VALUE
 buffer_initialize(int argc, VALUE* argv, VALUE self)
 {
-    VALUE size = Qnil, count = Qnil, clear = Qnil;
+    VALUE rbSize = Qnil, rbCount = Qnil, rbClear = Qnil;
     Buffer* p;
     int nargs;
 
     Data_Get_Struct(self, Buffer, p);
 
-    nargs = rb_scan_args(argc, argv, "12", &size, &count, &clear);
-    p->type_size = rbffi_type_size(size);
-    p->memory.size = p->type_size * (nargs > 1 ? NUM2LONG(count) : 1);
+    nargs = rb_scan_args(argc, argv, "12", &rbSize, &rbCount, &rbClear);
+    p->memory.typeSize = rbffi_type_size(rbSize);
+    p->memory.size = p->memory.typeSize * (nargs > 1 ? NUM2LONG(rbCount) : 1);
 
-    p->storage = malloc(p->memory.size + 7);
+    p->storage = xmalloc(p->memory.size + 7);
     if (p->storage == NULL) {
         rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", p->memory.size);
     }
@@ -66,7 +92,7 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
     /* ensure the memory is aligned on at least a 8 byte boundary */
     p->memory.address = (void *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);
     
-    if (nargs > 2 && (RTEST(clear) || clear == Qnil) && p->memory.size > 0) {
+    if (nargs > 2 && (RTEST(rbClear) || rbClear == Qnil) && p->memory.size > 0) {
         memset(p->memory.address, 0, p->memory.size);
     }
 
@@ -84,48 +110,36 @@ buffer_alloc_inout(int argc, VALUE* argv, VALUE klass)
 }
 
 static VALUE
-buffer_plus(VALUE self, VALUE offset)
-{
-    Buffer* ptr = BUFFER(self);
-    Buffer* p;
-    VALUE retval;
-    long off = NUM2LONG(offset);
-
-    checkBounds(&ptr->memory, off, 1);
-
-    retval = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, p);
-    p->memory.address = ptr->memory.address + off;
-    p->memory.size = ptr->memory.size - off;
-    p->memory.ops = &rbffi_AbstractMemoryOps;
-    p->parent = self;
-
-    return retval;
-}
-
-static VALUE
-buffer_aref(VALUE self, VALUE offset)
+buffer_plus(VALUE self, VALUE rbOffset)
 {
     Buffer* ptr;
+    Buffer* result;
+    VALUE obj = Qnil;
+    long offset = NUM2LONG(rbOffset);
 
     Data_Get_Struct(self, Buffer, ptr);
-    return buffer_plus(self, INT2FIX(ptr->type_size * NUM2INT(offset)));
-}
+    checkBounds(&ptr->memory, offset, 1);
 
-static VALUE
-buffer_type_size(VALUE self)
-{
-    Buffer* ptr;
+    obj = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, result);
+    result->memory.address = ptr->memory.address + offset;
+    result->memory.size = ptr->memory.size - offset;
+    result->memory.ops = ptr->memory.ops;
+    result->memory.access = ptr->memory.access;
+    result->memory.typeSize = ptr->memory.typeSize;
+    result->rbParent = self;
 
-    Data_Get_Struct(self, Buffer, ptr);
-    return INT2NUM(ptr->type_size);
+    return obj;
 }
 
 static VALUE
 buffer_inspect(VALUE self)
 {
     char tmp[100];
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
 
-    snprintf(tmp, sizeof(tmp), "#<Buffer size=%ld>", BUFFER(self)->memory.size);
+    snprintf(tmp, sizeof(tmp), "#<FFI:Buffer:%p address=%p size=%ld>", ptr, ptr->memory.address, ptr->memory.size);
     
     return rb_str_new2(tmp);
 }
@@ -148,7 +162,7 @@ buffer_free(VALUE self)
 static void
 buffer_mark(Buffer* ptr)
 {
-    rb_gc_mark(ptr->parent);
+    rb_gc_mark(ptr->rbParent);
 }
 
 void
@@ -162,10 +176,12 @@ rbffi_Buffer_Init(VALUE moduleFFI)
     rb_define_singleton_method(BufferClass, "alloc_inout", buffer_alloc_inout, -1);
     rb_define_singleton_method(BufferClass, "alloc_out", buffer_alloc_inout, -1);
     rb_define_singleton_method(BufferClass, "alloc_in", buffer_alloc_inout, -1);
+    rb_define_alias(rb_singleton_class(BufferClass), "new_in", "alloc_in");
+    rb_define_alias(rb_singleton_class(BufferClass), "new_out", "alloc_out");
+    rb_define_alias(rb_singleton_class(BufferClass), "new_inout", "alloc_inout");
     
     rb_define_method(BufferClass, "initialize", buffer_initialize, -1);
     rb_define_method(BufferClass, "inspect", buffer_inspect, 0);
-    rb_define_method(BufferClass, "type_size", buffer_type_size, 0);
-    rb_define_method(BufferClass, "[]", buffer_aref, 1);
+    rb_define_alias(BufferClass, "length", "total");
     rb_define_method(BufferClass, "+", buffer_plus, 1);
 }

data/ext/ffi_c/Call.c

@@ -0,0 +1,853 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
+ * Copyright (c) 2009, Mike Dalessio <mike.dalessio@gmail.com>
+ * Copyright (c) 2009, Aman Gupta.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * The name of the author or authors may not be used to endorse or promote
+ *   products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <ruby.h>
+#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION) && !defined(_WIN32)
+#  include <signal.h>
+#  include <pthread.h>
+#endif
+#include <ffi.h>
+#include "extconf.h"
+#include "rbffi.h"
+#include "compat.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "Struct.h"
+#include "Function.h"
+#include "Type.h"
+#include "LastError.h"
+#include "Call.h"
+
+#ifdef USE_RAW
+#  ifndef __i386__
+#    error "RAW argument packing only supported on i386"
+#  endif
+
+#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 void* callback_param(VALUE proc, VALUE cbinfo);
+static inline int getSignedInt(VALUE value, int type, int minValue, int maxValue, const char* typeName, VALUE enums);
+static inline int getUnsignedInt(VALUE value, int type, int maxValue, const char* typeName);
+static inline unsigned int getUnsignedInt32(VALUE value, int type);
+static inline void* getPointer(VALUE value, int type);
+static inline char* getString(VALUE value, int type);
+
+
+#ifdef BYPASS_FFI
+static long rbffi_GetLongValue(int idx, VALUE* argv, FunctionType* fnInfo);
+static VALUE rbffi_InvokeVrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+static VALUE rbffi_InvokeLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+static VALUE rbffi_InvokeLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+static VALUE rbffi_InvokeLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+static VALUE rbffi_InvokeLLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+static VALUE rbffi_InvokeLLLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+static VALUE rbffi_InvokeLLLLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+static VALUE rbffi_InvokeLongParams(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+#endif
+
+
+static ID id_to_ptr, id_map_symbol;
+
+void
+rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTypes,
+        FFIStorage* paramStorage, void** ffiValues,
+        VALUE* callbackParameters, int callbackCount, VALUE enums)
+{
+    VALUE callbackProc = Qnil;
+    FFIStorage* param = &paramStorage[0];
+    int i, argidx, cbidx, argCount;
+
+    if (paramCount != -1 && paramCount != argc) {
+        if (argc == (paramCount - 1) && callbackCount == 1 && rb_block_given_p()) {
+            callbackProc = rb_block_proc();
+        } else {
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, paramCount);
+        }
+    }
+
+    argCount = paramCount != -1 ? 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", 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:
+                param->ptr = getString(argv[argidx++], type);
+                ADJ(param, ADDRESS);
+                break;
+
+            case NATIVE_POINTER:
+            case NATIVE_BUFFER_IN:
+            case NATIVE_BUFFER_OUT:
+            case NATIVE_BUFFER_INOUT:
+                param->ptr = getPointer(argv[argidx++], type);
+                ADJ(param, ADDRESS);
+                break;
+
+
+            case NATIVE_FUNCTION:
+            case NATIVE_CALLBACK:
+                if (callbackProc != Qnil) {
+                    param->ptr = callback_param(callbackProc, callbackParameters[cbidx++]);
+                } else {
+                    param->ptr = callback_param(argv[argidx], callbackParameters[cbidx++]);
+                    ++argidx;
+                }
+                ADJ(param, ADDRESS);
+                break;
+
+            case NATIVE_STRUCT:
+                ffiValues[i] = getPointer(argv[argidx++], type);
+                break;
+
+            default:
+                rb_raise(rb_eArgError, "Invalid parameter type: %d", paramTypes[i]);
+        }
+    }
+}
+
+
+#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
+
+typedef struct BlockingCall_ {
+    void* function;
+    FunctionType* info;
+    void **ffiValues;
+    FFIStorage* retval;
+} BlockingCall;
+
+static VALUE
+call_blocking_function(void* data)
+{
+    BlockingCall* b = (BlockingCall *) data;
+
+    ffi_call(&b->info->ffi_cif, FFI_FN(b->function), b->retval, b->ffiValues);
+
+    return Qnil;
+}
+#endif
+
+VALUE
+rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    void* retval;
+    void** ffiValues;
+    FFIStorage* params;
+
+    ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
+    params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
+    retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
+
+    rbffi_SetupCallParams(argc, argv,
+        fnInfo->parameterCount, fnInfo->nativeParameterTypes, params, ffiValues,
+        fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
+
+#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
+    if (unlikely(fnInfo->blocking)) {
+        BlockingCall bc;
+
+        bc.info = fnInfo;
+        bc.function = function;
+        bc.ffiValues = ffiValues;
+        bc.retval = retval;
+
+        rb_thread_blocking_region(call_blocking_function, &bc, (void *) -1, NULL);
+    } else {
+        ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
+    }
+#else
+    ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
+#endif
+
+    if (!fnInfo->ignoreErrno) {
+        rbffi_save_errno();
+    }
+
+    return rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval,
+        fnInfo->rbEnums);
+}
+
+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_funcall2(enums, id_map_symbol, 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 inline void*
+getPointer(VALUE value, int type)
+{
+    if (type == T_DATA && rb_obj_is_kind_of(value, rbffi_AbstractMemoryClass)) {
+
+        return ((AbstractMemory *) DATA_PTR(value))->address;
+
+    } else if (type == T_DATA && rb_obj_is_kind_of(value, rbffi_StructClass)) {
+
+        AbstractMemory* memory = ((Struct *) DATA_PTR(value))->pointer;
+        return memory != NULL ? memory->address : NULL;
+
+    } else if (type == T_STRING) {
+
+        if (rb_safe_level() >= 1 && OBJ_TAINTED(value)) {
+            rb_raise(rb_eSecurityError, "Unsafe string parameter");
+        }
+        return StringValuePtr(value);
+
+    } else if (type == T_NIL) {
+
+        return NULL;
+
+    } else if (rb_respond_to(value, id_to_ptr)) {
+
+        VALUE ptr = rb_funcall2(value, id_to_ptr, 0, NULL);
+        if (rb_obj_is_kind_of(ptr, rbffi_AbstractMemoryClass) && TYPE(ptr) == T_DATA) {
+            return ((AbstractMemory *) DATA_PTR(ptr))->address;
+        }
+        rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
+    }
+
+    rb_raise(rb_eArgError, ":pointer argument is not a valid pointer");
+    return NULL;
+}
+
+static inline char*
+getString(VALUE value, int type)
+{
+    if (type == T_STRING) {
+
+        if (rb_safe_level() >= 1 && OBJ_TAINTED(value)) {
+            rb_raise(rb_eSecurityError, "Unsafe string parameter");
+        }
+
+        return StringValueCStr(value);
+
+    } else if (type == T_NIL) {
+        return NULL;
+    }
+
+    rb_raise(rb_eArgError, "Invalid String value");
+}
+
+
+Invoker
+rbffi_GetInvoker(FunctionType *fnInfo)
+{
+#if defined(BYPASS_FFI) && (defined(__i386__) || defined(__x86_64__))
+    int i;
+    bool fastLong = fnInfo->abi == FFI_DEFAULT_ABI && !fnInfo->blocking && !fnInfo->hasStruct;
+
+    switch (fnInfo->returnType->nativeType) {
+        case NATIVE_VOID:
+        case NATIVE_BOOL:
+        case NATIVE_INT8:
+        case NATIVE_UINT8:
+        case NATIVE_INT16:
+        case NATIVE_UINT16:
+        case NATIVE_INT32:
+        case NATIVE_UINT32:
+#ifdef __x86_64__
+        case NATIVE_INT64:
+        case NATIVE_UINT64:
+#endif
+        case NATIVE_STRING:
+        case NATIVE_POINTER:
+            break;
+        default:
+            fastLong = false;
+            break;
+    }
+
+    for (i = 0; fastLong && i < fnInfo->parameterCount; ++i) {
+        switch (fnInfo->nativeParameterTypes[i]) {
+            case NATIVE_BOOL:
+            case NATIVE_INT8:
+            case NATIVE_UINT8:
+            case NATIVE_INT16:
+            case NATIVE_UINT16:
+            case NATIVE_INT32:
+            case NATIVE_UINT32:
+#ifdef __x86_64__
+            case NATIVE_INT64:
+            case NATIVE_UINT64:
+#endif
+            case NATIVE_STRING:
+            case NATIVE_POINTER:
+            case NATIVE_BUFFER_IN:
+            case NATIVE_BUFFER_OUT:
+            case NATIVE_BUFFER_INOUT:
+            case NATIVE_FUNCTION:
+            case NATIVE_CALLBACK:
+                break;
+            default:
+                fastLong = false;
+                break;
+        }
+    }
+
+    if (fastLong && fnInfo->callbackCount < 1) {
+        switch (fnInfo->parameterCount) {
+            case 0:
+                return rbffi_InvokeVrL;
+            case 1:
+                return rbffi_InvokeLrL;
+            case 2:
+                return rbffi_InvokeLLrL;
+            case 3:
+                return rbffi_InvokeLLLrL;
+            case 4:
+                return rbffi_InvokeLLLLrL;
+            case 5:
+                return rbffi_InvokeLLLLLrL;
+            case 6:
+                return rbffi_InvokeLLLLLLrL;
+
+            default:
+                break;
+        }
+
+    } else if (fastLong && fnInfo->parameterCount <= 6) {
+        return rbffi_InvokeLongParams;
+    }
+#endif
+
+    return rbffi_CallFunction;
+}
+
+#if defined(BYPASS_FFI) && (defined(__i386__) || defined(__x86_64__))
+typedef long L;
+
+static long
+rbffi_GetLongValue(int idx, VALUE* argv, FunctionType* fnInfo)
+{
+    VALUE value = argv[idx];
+    NativeType nativeType = fnInfo->nativeParameterTypes[idx];
+    int type = TYPE(value);
+
+    switch (nativeType) {
+        case NATIVE_INT8:
+            return getSignedInt(value, type, -128, 127, "char", fnInfo->rbEnums);
+
+        case NATIVE_INT16:
+            return getSignedInt(value, type, -0x8000, 0x7fff, "short", fnInfo->rbEnums);
+
+        case NATIVE_INT32:
+        case NATIVE_ENUM:
+            return getSignedInt(value, type, -0x80000000, 0x7fffffff, "int", fnInfo->rbEnums);
+
+        case NATIVE_BOOL:
+            if (type != T_TRUE && type != T_FALSE) {
+                rb_raise(rb_eTypeError, "Expected a Boolean parameter");
+            }
+            return RTEST(value) ? 1 : 0;
+
+        case NATIVE_UINT8:
+            return getUnsignedInt(value, type, 0xff, "unsigned char");
+
+        case NATIVE_UINT16:
+            return getUnsignedInt(value, type, 0xffff, "unsigned short");
+
+        case NATIVE_UINT32:
+            /* Special handling/checking for unsigned 32 bit integers */
+            return getUnsignedInt32(value, type);
+
+#ifdef __x86_64__
+        case NATIVE_INT64:
+            if (type != T_FIXNUM && type != T_BIGNUM) {
+                rb_raise(rb_eTypeError, "Expected an Integer parameter");
+            }
+            return NUM2LL(value);
+
+        case NATIVE_UINT64:
+            if (type != T_FIXNUM && type != T_BIGNUM) {
+                rb_raise(rb_eTypeError, "Expected an Integer parameter");
+            }
+            return NUM2ULL(value);
+#endif
+        case NATIVE_STRING:
+            return (intptr_t) getString(value, type);
+
+        case NATIVE_POINTER:
+        case NATIVE_BUFFER_IN:
+        case NATIVE_BUFFER_OUT:
+        case NATIVE_BUFFER_INOUT:
+            return (intptr_t) getPointer(value, type);
+
+        default:
+            rb_raise(rb_eTypeError, "unsupported integer type %d", nativeType);
+            return 0;
+    }
+}
+
+static inline void
+checkArity(int argc, int arity) {
+    if (unlikely(argc != arity)) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, arity);
+    }
+}
+
+static inline bool
+isLongValue(VALUE value)
+{
+    int type = TYPE(value);
+
+    return type == T_FIXNUM || type == T_BIGNUM
+            || type == T_STRING || type == T_NIL
+            || (type == T_DATA && rb_obj_is_kind_of(value, rbffi_AbstractMemoryClass))
+            || (type == T_DATA && rb_obj_is_kind_of(value, rbffi_StructClass))
+            || rb_respond_to(value, id_to_ptr);
+}
+
+static VALUE
+returnL(FunctionType* fnInfo, L* result)
+{
+    if (unlikely(!fnInfo->ignoreErrno)) {
+        rbffi_save_errno();
+    }
+
+    /*
+     * This needs to do custom boxing of the return value, since a function
+     * may only fill out the lower 8, 16 or 32 bits of %al, %ah, %eax, %rax, and
+     * the upper part will be garbage.  This will truncate the value again, then
+     * sign extend it.
+     */
+    switch (fnInfo->returnType->nativeType) {
+        case NATIVE_VOID:
+            return Qnil;
+
+        case NATIVE_INT8:
+          return INT2NUM(*(signed char *) result);
+
+        case NATIVE_INT16:
+          return INT2NUM(*(signed short *) result);
+
+        case NATIVE_INT32:
+          return INT2NUM(*(signed int *) result);
+
+        case NATIVE_UINT8:
+          return UINT2NUM(*(unsigned char *) result);
+
+        case NATIVE_UINT16:
+          return UINT2NUM(*(unsigned short *) result);
+
+        case NATIVE_UINT32:
+          return UINT2NUM(*(unsigned int *) result);
+
+#ifdef __x86_64__
+        case NATIVE_INT64:
+            return LL2NUM(*(signed long long *) result);
+
+        case NATIVE_UINT64:
+            return ULL2NUM(*(unsigned long long *) result);
+#endif /* __x86_64__ */
+
+        case NATIVE_STRING:
+            return *(void **) result != 0 ? rb_tainted_str_new2(*(char **) result) : Qnil;
+
+        case NATIVE_POINTER:
+            return rbffi_Pointer_NewInstance(*(void **) result);
+
+        case NATIVE_BOOL:
+            return *(char *) result != 0 ? Qtrue : Qfalse;
+
+        default:
+            rb_raise(rb_eRuntimeError, "invalid return type: %d", fnInfo->returnType->nativeType);
+            return Qnil;
+    }
+}
+
+static VALUE
+rbffi_InvokeVrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    L (*fn)(void) = (L (*)(void)) function;
+    L result;
+
+    checkArity(argc, 0);
+
+    result = (*fn)();
+
+    return returnL(fnInfo, &result);
+}
+
+static bool
+checkArgs(int argc, VALUE* argv, FunctionType* fnInfo)
+{
+    int i;
+
+    checkArity(argc, fnInfo->parameterCount);
+    for (i = 0; i < fnInfo->parameterCount; ++i) {
+        if (unlikely(!isLongValue(argv[i]))) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+#define LARG(fnInfo, argv, i) \
+    rbffi_GetLongValue(i, argv, fnInfo)
+
+#define LCALL(fnInfo, argc, argv, fn, a...) ({ \
+    L result; \
+    \
+    if (unlikely(!checkArgs(argc, argv, fnInfo))) { \
+        return rbffi_CallFunction(argc, argv, function, fnInfo); \
+    } \
+    \
+    result = (*(fn))(a); \
+    \
+    returnL(fnInfo, &result); \
+})
+
+static VALUE
+rbffi_InvokeLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    L (*fn)(L) = (L (*)(L)) function;
+    L result;
+
+    checkArity(argc, 1);
+
+    if (unlikely(!isLongValue(argv[0]))) {
+        return rbffi_CallFunction(argc, argv, function, fnInfo);
+    }
+
+    result = (*fn)(LARG(fnInfo, argv, 0));
+
+    return returnL(fnInfo, &result);
+}
+
+static VALUE
+rbffi_InvokeLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    L (*fn)(L, L) = (L (*)(L, L)) function;
+    L result;
+
+    checkArity(argc, 2);
+
+    if (unlikely(!isLongValue(argv[0])) || unlikely(!isLongValue(argv[1]))) {
+        return rbffi_CallFunction(argc, argv, function, fnInfo);
+    }
+
+    result = (*fn)(LARG(fnInfo, argv, 0), LARG(fnInfo, argv, 1));
+
+    return returnL(fnInfo, &result);
+}
+
+static VALUE
+rbffi_InvokeLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    L (*fn)(L, L, L) = (L (*)(L, L, L)) function;
+    L result;
+
+    checkArity(argc, 3);
+
+    if (unlikely(!isLongValue(argv[0])) || unlikely(!isLongValue(argv[1])) || unlikely(!isLongValue(argv[2]))) {
+        return rbffi_CallFunction(argc, argv, function, fnInfo);
+    }
+    
+    result = (*fn)(LARG(fnInfo, argv, 0), LARG(fnInfo, argv, 1), LARG(fnInfo, argv, 2));
+
+    return returnL(fnInfo, &result);
+}
+
+
+static VALUE
+rbffi_InvokeLLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    return LCALL(fnInfo, argc, argv, (L (*)(L, L, L, L)) function,
+        LARG(fnInfo, argv, 0), LARG(fnInfo, argv, 1),
+        LARG(fnInfo, argv, 2), LARG(fnInfo, argv, 3));
+}
+
+static VALUE
+rbffi_InvokeLLLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    return LCALL(fnInfo, argc, argv, (L (*)(L, L, L, L, L)) function,
+        LARG(fnInfo, argv, 0), LARG(fnInfo, argv, 1), LARG(fnInfo, argv, 2),
+        LARG(fnInfo, argv, 3), LARG(fnInfo, argv, 4));
+}
+
+static VALUE
+rbffi_InvokeLLLLLLrL(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    return LCALL(fnInfo, argc, argv, (L (*)(L, L, L, L, L, L)) function,
+        LARG(fnInfo, argv, 0), LARG(fnInfo, argv, 1), LARG(fnInfo, argv, 2),
+        LARG(fnInfo, argv, 3), LARG(fnInfo, argv, 4), LARG(fnInfo, argv, 5));
+}
+
+static VALUE
+rbffi_InvokeLongParams(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
+{
+    void **ffiValues = NULL;
+    FFIStorage* params = NULL;
+    L result;
+
+    if (fnInfo->parameterCount > 0) {
+        ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
+        params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
+
+        rbffi_SetupCallParams(argc, argv,
+            fnInfo->parameterCount, fnInfo->nativeParameterTypes, params, ffiValues,
+            fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
+
+        switch (fnInfo->parameterCount) {
+            case 0:
+                result = ((L(*)(void)) function)();
+                break;
+
+            case 1:
+                result = ((L(*)(L)) function)(*(L *) ffiValues[0]);
+                break;
+
+            case 2:
+                result = ((L(*)(L, L)) function)(*(L *) ffiValues[0],
+                        *(L *) ffiValues[1]);
+                break;
+
+            case 3:
+                result = ((L(*)(L, L, L)) function)(*(L *) ffiValues[0],
+                        *(L *) ffiValues[1], *(L *) ffiValues[2]);
+                break;
+
+            case 4:
+                result = ((L(*)(L, L, L, L)) function)(*(L *) ffiValues[0],
+                        *(L *) ffiValues[1], *(L *) ffiValues[2], *(L *) ffiValues[3]);
+                break;
+
+            case 5:
+                result = ((L(*)(L, L, L, L, L)) function)(*(L *) ffiValues[0],
+                        *(L *) ffiValues[1], *(L *) ffiValues[2], *(L *) ffiValues[3],
+                        *(L *) ffiValues[4]);
+                break;
+
+            case 6:
+                result = ((L(*)(L, L, L, L, L, L)) function)(*(L *) ffiValues[0],
+                        *(L *) ffiValues[1], *(L *) ffiValues[2], *(L *) ffiValues[3],
+                        *(L *) ffiValues[4], *(L *) ffiValues[5]);
+                break;
+
+            default:
+                rb_raise(rb_eRuntimeError, "BUG: should not reach this point");
+                return Qnil;
+        }
+    }
+
+    return returnL(fnInfo, &result);
+}
+
+#endif /* BYPASS_FFI */
+
+static void*
+callback_param(VALUE proc, VALUE cbInfo)
+{
+    VALUE callback ;
+    if (proc == Qnil) {
+        return NULL ;
+    }
+
+    // Handle Function pointers here
+    if (rb_obj_is_kind_of(proc, rbffi_FunctionClass)) {
+        AbstractMemory* ptr;
+        Data_Get_Struct(proc, AbstractMemory, ptr);
+        return ptr->address;
+    }
+
+    //callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
+    callback = rbffi_Function_ForProc(cbInfo, proc);
+
+    return ((AbstractMemory *) DATA_PTR(callback))->address;
+}
+
+
+void
+rbffi_Call_Init(VALUE moduleFFI)
+{
+    id_to_ptr = rb_intern("to_ptr");
+    id_map_symbol = rb_intern("__map_symbol");
+}
+