ffi 0.6.4 → 1.0.0

data/ext/ffi_c/AbstractMemory.h

@@ -3,27 +3,19 @@
  *
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * This file is part of ruby-ffi.
  *
- * * 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 code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3 only, as
+ * published by the Free Software Foundation.
  *
- * 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.
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+ * version 3 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef RBFFI_ABSTRACTMEMORY_H
@@ -44,6 +36,7 @@ extern "C" {
 #define MEM_RD   0x01
 #define MEM_WR   0x02
 #define MEM_CODE 0x04
+#define MEM_SWAP 0x08
 
 typedef struct AbstractMemory_ AbstractMemory;
 
@@ -72,7 +65,7 @@ typedef struct {
 struct AbstractMemory_ {
     char* address; // Use char* instead of void* to ensure adding to it works correctly
     long size;
-    int access;
+    int flags;
     int typeSize;
 };
 
@@ -98,7 +91,7 @@ checkBounds(AbstractMemory* mem, long off, long len)
 static inline void
 checkRead(AbstractMemory* mem)
 {
-    if (unlikely((mem->access & MEM_RD) == 0)) {
+    if (unlikely((mem->flags & MEM_RD) == 0)) {
         rbffi_AbstractMemory_Error(mem, MEM_RD);
     }
 }
@@ -106,7 +99,7 @@ checkRead(AbstractMemory* mem)
 static inline void
 checkWrite(AbstractMemory* mem)
 {
-    if (unlikely((mem->access & MEM_WR) == 0)) {
+    if (unlikely((mem->flags & MEM_WR) == 0)) {
         rbffi_AbstractMemory_Error(mem, MEM_WR);
     }
 }

data/ext/ffi_c/Buffer.c

@@ -1,28 +1,21 @@
 /*
- * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2008-2010 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:
+ * This file is part of ruby-ffi.
  *
- * * 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 code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3 only, as
+ * published by the Free Software Foundation.
  *
- * 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.
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+ * version 3 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <stdbool.h>
@@ -54,7 +47,7 @@ buffer_allocate(VALUE klass)
 
     obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
     buffer->rbParent = Qnil;
-    buffer->memory.access = MEM_RD | MEM_WR;
+    buffer->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
 }
@@ -122,7 +115,7 @@ slice(VALUE self, long offset, long len)
     obj = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, result);
     result->memory.address = ptr->memory.address + offset;
     result->memory.size = len;
-    result->memory.access = ptr->memory.access;
+    result->memory.flags = ptr->memory.flags;
     result->memory.typeSize = ptr->memory.typeSize;
     result->rbParent = self;
 
@@ -159,6 +152,51 @@ buffer_inspect(VALUE self)
     return rb_str_new2(tmp);
 }
 
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+# define SWAPPED_ORDER BIG_ENDIAN
+#else
+# define SWAPPED_ORDER LITTLE_ENDIAN
+#endif
+
+static VALUE
+buffer_order(int argc, VALUE* argv, VALUE self)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+    if (argc == 0) {
+        int order = (ptr->memory.flags & MEM_SWAP) == 0 ? BYTE_ORDER : SWAPPED_ORDER;
+        return order == BIG_ENDIAN ? ID2SYM(rb_intern("big")) : ID2SYM(rb_intern("little"));
+    } else {
+        VALUE rbOrder = Qnil;
+        int order = BYTE_ORDER;
+
+        if (rb_scan_args(argc, argv, "1", &rbOrder) < 1) {
+            rb_raise(rb_eArgError, "need byte order");
+        }
+        if (SYMBOL_P(rbOrder)) {
+            ID id = SYM2ID(rbOrder);
+            if (id == rb_intern("little")) {
+                order = LITTLE_ENDIAN;
+
+            } else if (id == rb_intern("big") || id == rb_intern("network")) {
+                order = BIG_ENDIAN;
+            }
+        }
+        if (order != BYTE_ORDER) {
+            Buffer* p2;
+            VALUE retval = slice(self, 0, ptr->memory.size);
+
+            Data_Get_Struct(retval, Buffer, p2);
+            p2->memory.flags |= MEM_SWAP;
+            return retval;
+        }
+
+        return self;
+    }
+}
+
 /* Only used to free the buffer if the yield in the initializer throws an exception */
 static VALUE
 buffer_free(VALUE self)
@@ -196,6 +234,7 @@ rbffi_Buffer_Init(VALUE moduleFFI)
     rb_define_alias(rb_singleton_class(BufferClass), "new_inout", "alloc_inout");
     
     rb_define_method(BufferClass, "initialize", buffer_initialize, -1);
+    rb_define_method(BufferClass, "order", buffer_order, -1);
     rb_define_method(BufferClass, "inspect", buffer_inspect, 0);
     rb_define_alias(BufferClass, "length", "total");
     rb_define_method(BufferClass, "+", buffer_plus, 1);

data/ext/ffi_c/Call.c

@@ -5,27 +5,19 @@
  * 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:
+ * This file is part of ruby-ffi.
  *
- * * 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 code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3 only, as
+ * published by the Free Software Foundation.
  *
- * 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.
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+ * version 3 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <sys/param.h>
@@ -50,6 +42,7 @@
 #include "Type.h"
 #include "LastError.h"
 #include "Call.h"
+#include "MappedType.h"
 
 #ifdef USE_RAW
 #  ifndef __i386__
@@ -74,30 +67,13 @@
 #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;
+static ID id_to_ptr, id_map_symbol, id_to_native;
 
 void
-rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTypes,
+rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         FFIStorage* paramStorage, void** ffiValues,
         VALUE* callbackParameters, int callbackCount, VALUE enums)
 {
@@ -105,7 +81,7 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
     FFIStorage* param = &paramStorage[0];
     int i, argidx, cbidx, argCount;
 
-    if (paramCount != -1 && paramCount != argc) {
+    if (unlikely(paramCount != -1 && paramCount != argc)) {
         if (argc == (paramCount - 1) && callbackCount == 1 && rb_block_given_p()) {
             callbackProc = rb_block_proc();
         } else {
@@ -116,26 +92,45 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
     argCount = paramCount != -1 ? paramCount : argc;
 
     for (i = 0, argidx = 0, cbidx = 0; i < argCount; ++i) {
-        int type = argidx < argc ? TYPE(argv[argidx]) : T_NONE;
+        Type* paramType = paramTypes[i];
+        int type;
+
+        
+        if (unlikely(paramType->nativeType == NATIVE_MAPPED)) {
+            VALUE values[] = { argv[argidx], Qnil };
+            argv[argidx] = rb_funcall2(((MappedType *) paramType)->rbConverter, id_to_native, 2, values);
+            paramType = ((MappedType *) paramType)->type;
+        }
+
+        type = argidx < argc ? TYPE(argv[argidx]) : T_NONE;
         ffiValues[i] = param;
 
-        switch (paramTypes[i]) {
+        switch (paramType->nativeType) {
 
             case NATIVE_INT8:
-                param->s8 = getSignedInt(argv[argidx++], type, -128, 127, "char", Qnil);
+                param->s8 = NUM2INT(argv[argidx]);
+                ++argidx;
                 ADJ(param, INT8);
                 break;
 
 
             case NATIVE_INT16:
-                param->s16 = getSignedInt(argv[argidx++], type, -0x8000, 0x7fff, "short", Qnil);
+                param->s16 = NUM2INT(argv[argidx]);
+                ++argidx;
                 ADJ(param, INT16);
                 break;
 
 
             case NATIVE_INT32:
-            case NATIVE_ENUM:
-                param->s32 = getSignedInt(argv[argidx++], type, -0x80000000, 0x7fffffff, "int", enums);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->s32 = NUM2INT(value);
+
+                } else {
+                    param->s32 = NUM2INT(argv[argidx]);
+                }
+
+                ++argidx;
                 ADJ(param, INT32);
                 break;
 
@@ -150,28 +145,27 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
 
 
             case NATIVE_UINT8:
-                param->u8 = getUnsignedInt(argv[argidx++], type, 0xff, "unsigned char");
+                param->u8 = NUM2UINT(argv[argidx]);
                 ADJ(param, INT8);
+                ++argidx;
                 break;
 
 
             case NATIVE_UINT16:
-                param->u16 = getUnsignedInt(argv[argidx++], type, 0xffff, "unsigned short");
+                param->u16 = NUM2UINT(argv[argidx]);
                 ADJ(param, INT16);
+                ++argidx;
                 break;
 
 
             case NATIVE_UINT32:
-                /* Special handling/checking for unsigned 32 bit integers */
-                param->u32 = getUnsignedInt32(argv[argidx++], type);
+                param->u32 = NUM2UINT(argv[argidx]);
                 ADJ(param, INT32);
+                ++argidx;
                 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;
@@ -179,9 +173,6 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
 
 
             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;
@@ -200,18 +191,12 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
                 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;
@@ -248,7 +233,7 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
                 break;
 
             default:
-                rb_raise(rb_eArgError, "Invalid parameter type: %d", paramTypes[i]);
+                rb_raise(rb_eArgError, "Invalid parameter type: %d", paramType->nativeType);
         }
     }
 }
@@ -286,7 +271,7 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
 
     rbffi_SetupCallParams(argc, argv,
-        fnInfo->parameterCount, fnInfo->nativeParameterTypes, params, ffiValues,
+        fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
         fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
 
 #if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
@@ -306,7 +291,7 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
 #endif
 
-    if (!fnInfo->ignoreErrno) {
+    if (unlikely(!fnInfo->ignoreErrno)) {
         rbffi_save_errno();
     }
 
@@ -314,68 +299,10 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
         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)) {
+    if (likely(type == T_DATA && rb_obj_is_kind_of(value, rbffi_AbstractMemoryClass))) {
 
         return ((AbstractMemory *) DATA_PTR(value))->address;
 
@@ -430,431 +357,15 @@ getString(VALUE value, int type)
 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:
-        case NATIVE_LONG:
-        case NATIVE_ULONG:
-#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:
-            case NATIVE_LONG:
-            case NATIVE_ULONG:
-#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);
-
-        case NATIVE_LONG:
-            return NUM2LONG(value);
-
-        case NATIVE_ULONG:
-            return NUM2ULONG(value);
-
-#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_LONG:
-          return LONG2NUM(*(signed long *) 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);
-
-        case NATIVE_ULONG:
-          return ULONG2NUM(*(unsigned long *) 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) {
+    if (unlikely(proc == Qnil)) {
         return NULL ;
     }
 
@@ -876,6 +387,7 @@ void
 rbffi_Call_Init(VALUE moduleFFI)
 {
     id_to_ptr = rb_intern("to_ptr");
+    id_to_native = rb_intern("to_native");
     id_map_symbol = rb_intern("__map_symbol");
 }