ffi 1.0.0 → 1.17.1

data/ext/ffi_c/Call.c

@@ -3,31 +3,43 @@
  * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
  * Copyright (c) 2009, Mike Dalessio <mike.dalessio@gmail.com>
  * Copyright (c) 2009, Aman Gupta.
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * 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.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may 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 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/>.
+ * 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 <COPYRIGHT HOLDER> 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 _MSC_VER
 #include <sys/param.h>
+#endif
 #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 <ruby/thread.h>
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
 #  include <signal.h>
 #  include <pthread.h>
 #endif
@@ -43,6 +55,8 @@
 #include "LastError.h"
 #include "Call.h"
 #include "MappedType.h"
+#include "Thread.h"
+#include "LongDouble.h"
 
 #ifdef USE_RAW
 #  ifndef __i386__
@@ -57,6 +71,7 @@
 #define FLOAT32_ADJ (4)
 #define FLOAT64_ADJ (8)
 #define ADDRESS_ADJ (sizeof(void *))
+#define LONGDOUBLE_ADJ (ffi_type_longdouble.alignment > sizeof(long double) ? ffi_type_longdouble.alignment : sizeof(long double))
 
 #endif /* USE_RAW */
 
@@ -68,14 +83,14 @@
 
 static void* callback_param(VALUE proc, VALUE cbinfo);
 static inline void* getPointer(VALUE value, int type);
-static inline char* getString(VALUE value, int type);
 
 static ID id_to_ptr, id_map_symbol, id_to_native;
 
-void
+VALUE
 rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         FFIStorage* paramStorage, void** ffiValues,
-        VALUE* callbackParameters, int callbackCount, VALUE enums)
+        VALUE* callbackParameters, int callbackCount,
+        VALUE enums)
 {
     VALUE callbackProc = Qnil;
     FFIStorage* param = &paramStorage[0];
@@ -95,7 +110,7 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         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);
@@ -108,19 +123,30 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         switch (paramType->nativeType) {
 
             case NATIVE_INT8:
-                param->s8 = NUM2INT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->s8 = NUM2INT(value);
+                } else {
+                    param->s8 = NUM2INT(argv[argidx]);
+                }
+
                 ++argidx;
                 ADJ(param, INT8);
                 break;
 
-
             case NATIVE_INT16:
-                param->s16 = NUM2INT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->s16 = NUM2INT(value);
+
+                } else {
+                    param->s16 = NUM2INT(argv[argidx]);
+                }
+
                 ++argidx;
                 ADJ(param, INT16);
                 break;
 
-
             case NATIVE_INT32:
                 if (unlikely(type == T_SYMBOL && enums != Qnil)) {
                     VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
@@ -134,7 +160,6 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
                 ADJ(param, INT32);
                 break;
 
-
             case NATIVE_BOOL:
                 if (type != T_TRUE && type != T_FALSE) {
                     rb_raise(rb_eTypeError, "wrong argument type  (expected a boolean parameter)");
@@ -143,69 +168,137 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
                 ADJ(param, INT8);
                 break;
 
-
             case NATIVE_UINT8:
-                param->u8 = NUM2UINT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u8 = NUM2UINT(value);
+                } else {
+                    param->u8 = NUM2UINT(argv[argidx]);
+                }
+
                 ADJ(param, INT8);
                 ++argidx;
                 break;
 
-
             case NATIVE_UINT16:
-                param->u16 = NUM2UINT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u16 = NUM2UINT(value);
+                } else {
+                    param->u16 = NUM2UINT(argv[argidx]);
+                }
+
                 ADJ(param, INT16);
                 ++argidx;
                 break;
 
-
             case NATIVE_UINT32:
-                param->u32 = NUM2UINT(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u32 = NUM2UINT(value);
+                } else {
+                    param->u32 = NUM2UINT(argv[argidx]);
+                }
+
                 ADJ(param, INT32);
                 ++argidx;
                 break;
 
-
             case NATIVE_INT64:
-                param->i64 = NUM2LL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->i64 = NUM2LL(value);
+                } else {
+                    param->i64 = NUM2LL(argv[argidx]);
+                }
+
                 ADJ(param, INT64);
                 ++argidx;
                 break;
 
-
             case NATIVE_UINT64:
-                param->u64 = NUM2ULL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->u64 = NUM2ULL(value);
+                } else {
+                    param->u64 = NUM2ULL(argv[argidx]);
+                }
+
                 ADJ(param, INT64);
                 ++argidx;
                 break;
 
             case NATIVE_LONG:
-                *(ffi_sarg *) param = NUM2LONG(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    *(ffi_sarg *) param = NUM2LONG(value);
+                } else {
+                    *(ffi_sarg *) param = NUM2LONG(argv[argidx]);
+                }
+
                 ADJ(param, LONG);
                 ++argidx;
                 break;
 
             case NATIVE_ULONG:
-                *(ffi_arg *) param = NUM2ULONG(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    *(ffi_arg *) param = NUM2ULONG(value);
+                } else {
+                    *(ffi_arg *) param = NUM2ULONG(argv[argidx]);
+                }
+
                 ADJ(param, LONG);
                 ++argidx;
                 break;
 
             case NATIVE_FLOAT32:
-                param->f32 = (float) NUM2DBL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->f32 = (float) NUM2DBL(value);
+                } else {
+                    param->f32 = (float) NUM2DBL(argv[argidx]);
+                }
+
                 ADJ(param, FLOAT32);
                 ++argidx;
                 break;
 
             case NATIVE_FLOAT64:
-                param->f64 = NUM2DBL(argv[argidx]);
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->f64 = NUM2DBL(value);
+                } else {
+                    param->f64 = NUM2DBL(argv[argidx]);
+                }
+
                 ADJ(param, FLOAT64);
                 ++argidx;
                 break;
 
+            case NATIVE_LONGDOUBLE:
+                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
+                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
+                    param->ld = rbffi_num2longdouble(value);
+                } else {
+                    param->ld = rbffi_num2longdouble(argv[argidx]);
+                }
+
+                ADJ(param, LONGDOUBLE);
+                ++argidx;
+                break;
+
 
             case NATIVE_STRING:
-                param->ptr = getString(argv[argidx++], type);
+                if (type == T_NIL) {
+                    param->ptr = NULL;
+
+                } else {
+                    param->ptr = StringValueCStr(argv[argidx]);
+                }
+
                 ADJ(param, ADDRESS);
+                ++argidx;
                 break;
 
             case NATIVE_POINTER:
@@ -218,7 +311,6 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
 
 
             case NATIVE_FUNCTION:
-            case NATIVE_CALLBACK:
                 if (callbackProc != Qnil) {
                     param->ptr = callback_param(callbackProc, callbackParameters[cbidx++]);
                 } else {
@@ -236,28 +328,33 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
                 rb_raise(rb_eArgError, "Invalid parameter type: %d", paramType->nativeType);
         }
     }
+    return callbackProc;
 }
 
+static void *
+call_blocking_function(void* data)
+{
+    rbffi_blocking_call_t* b = (rbffi_blocking_call_t *) data;
+    ffi_call(&b->cif, FFI_FN(b->function), b->retval, b->ffiValues);
 
-#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
-
-typedef struct BlockingCall_ {
-    void* function;
-    FunctionType* info;
-    void **ffiValues;
-    FFIStorage* retval;
-} BlockingCall;
+    return NULL;
+}
 
-static VALUE
-call_blocking_function(void* data)
+VALUE
+rbffi_do_blocking_call(VALUE data)
 {
-    BlockingCall* b = (BlockingCall *) data;
+    rb_thread_call_without_gvl(call_blocking_function, (void*)data, (rb_unblock_function_t *) -1, NULL);
 
-    ffi_call(&b->info->ffi_cif, FFI_FN(b->function), b->retval, b->ffiValues);
+    return Qnil;
+}
 
+VALUE
+rbffi_save_frame_exception(VALUE data, VALUE exc)
+{
+    rbffi_frame_t* frame = (rbffi_frame_t *) data;
+    frame->exc = exc;
     return Qnil;
 }
-#endif
 
 VALUE
 rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
@@ -265,38 +362,63 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     void* retval;
     void** ffiValues;
     FFIStorage* params;
+    VALUE rbReturnValue;
+    rbffi_frame_t frame = { 0 };
+    VALUE callbackProc;
 
-    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->parameterTypes, params, ffiValues,
-        fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
-
-#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
     if (unlikely(fnInfo->blocking)) {
-        BlockingCall bc;
+        rbffi_blocking_call_t* bc;
+
+        /* allocate information passed to the blocking function on the stack */
+        ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
+        params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
+        bc = ALLOCA_N(rbffi_blocking_call_t, 1);
+        bc->retval = retval;
+        bc->cif = fnInfo->ffi_cif;
+        bc->function = function;
+        bc->ffiValues = ffiValues;
+        bc->params = params;
+        bc->frame = &frame;
+
+        callbackProc = rbffi_SetupCallParams(argc, argv,
+            fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
+            fnInfo->callbackParameters, fnInfo->callbackCount,
+            fnInfo->rbEnums);
+
+        rbffi_frame_push(&frame);
+        rb_rescue2(rbffi_do_blocking_call, (VALUE) bc, rbffi_save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
+        rbffi_frame_pop(&frame);
 
-        bc.info = fnInfo;
-        bc.function = function;
-        bc.ffiValues = ffiValues;
-        bc.retval = retval;
-
-        rb_thread_blocking_region(call_blocking_function, &bc, (void *) -1, NULL);
     } else {
+
+        ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
+        params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
+
+        callbackProc = rbffi_SetupCallParams(argc, argv,
+            fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
+            fnInfo->callbackParameters, fnInfo->callbackCount,
+            fnInfo->rbEnums);
+
+        rbffi_frame_push(&frame);
         ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
+        rbffi_frame_pop(&frame);
     }
-#else
-    ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
-#endif
+    RB_GC_GUARD(callbackProc);
 
     if (unlikely(!fnInfo->ignoreErrno)) {
         rbffi_save_errno();
     }
 
-    return rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval,
-        fnInfo->rbEnums);
+    if (RTEST(frame.exc) && frame.exc != Qnil) {
+        rb_exc_raise(frame.exc);
+    }
+
+    RB_GC_GUARD(rbReturnValue) = rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval);
+    RB_GC_GUARD(fnInfo->rbReturnType);
+
+    return rbReturnValue;
 }
 
 static inline void*
@@ -304,18 +426,21 @@ getPointer(VALUE value, int type)
 {
     if (likely(type == T_DATA && rb_obj_is_kind_of(value, rbffi_AbstractMemoryClass))) {
 
-        return ((AbstractMemory *) DATA_PTR(value))->address;
+        AbstractMemory *mem;
+        TypedData_Get_Struct(value, AbstractMemory, &rbffi_abstract_memory_data_type, mem);
+        return mem->address;
 
     } else if (type == T_DATA && rb_obj_is_kind_of(value, rbffi_StructClass)) {
 
-        AbstractMemory* memory = ((Struct *) DATA_PTR(value))->pointer;
+        Struct* s;
+        AbstractMemory* memory;
+
+        TypedData_Get_Struct(value, Struct, &rbffi_struct_data_type, s);
+        memory = s->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) {
@@ -326,7 +451,9 @@ getPointer(VALUE value, int type)
 
         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;
+            AbstractMemory *mem;
+            TypedData_Get_Struct(ptr, AbstractMemory, &rbffi_abstract_memory_data_type, mem);
+            return mem->address;
         }
         rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
     }
@@ -335,25 +462,6 @@ getPointer(VALUE value, int type)
     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)
 {
@@ -364,22 +472,25 @@ rbffi_GetInvoker(FunctionType *fnInfo)
 static void*
 callback_param(VALUE proc, VALUE cbInfo)
 {
-    VALUE callback ;
+    VALUE callback;
+    AbstractMemory *mem;
+
     if (unlikely(proc == Qnil)) {
         return NULL ;
     }
 
-    // Handle Function pointers here
+    /* Handle Function pointers here */
     if (rb_obj_is_kind_of(proc, rbffi_FunctionClass)) {
         AbstractMemory* ptr;
-        Data_Get_Struct(proc, AbstractMemory, ptr);
+        TypedData_Get_Struct(proc, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
         return ptr->address;
     }
 
-    //callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
     callback = rbffi_Function_ForProc(cbInfo, proc);
+    RB_GC_GUARD(callback);
 
-    return ((AbstractMemory *) DATA_PTR(callback))->address;
+    TypedData_Get_Struct(callback, AbstractMemory, &rbffi_abstract_memory_data_type, mem);
+    return mem->address;
 }
 
 

data/ext/ffi_c/Call.h

@@ -3,33 +3,37 @@
  * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
  * Copyright (c) 2009, Mike Dalessio <mike.dalessio@gmail.com>
  * Copyright (c) 2009, Aman Gupta.
+ *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * 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.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * * 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.
+ * 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 <COPYRIGHT HOLDER> 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_INVOKE_H
-#define	RBFFI_INVOKE_H
+#ifndef RBFFI_CALL_H
+#define	RBFFI_CALL_H
+
+#include "Thread.h"
 
 #ifdef	__cplusplus
 extern "C" {
@@ -44,7 +48,7 @@ extern "C" {
 #if (defined(__i386__) || defined(__x86_64__)) && !(defined(_WIN32) || defined(__WIN32__))
 #  define BYPASS_FFI 1
 #endif
-    
+
 typedef union {
 #ifdef USE_RAW
     signed int s8, s16, s32;
@@ -64,27 +68,41 @@ typedef union {
     void* ptr;
     float f32;
     double f64;
+    long double ld;
 } FFIStorage;
 
-
 extern void rbffi_Call_Init(VALUE moduleFFI);
 
-extern void rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
+extern VALUE rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
         FFIStorage* paramStorage, void** ffiValues,
-        VALUE* callbackParameters, int callbackCount, VALUE enums);
+        VALUE* callbackParameters, int callbackCount,
+        VALUE enums);
 
-extern VALUE rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+struct FunctionType_;
+extern VALUE rbffi_CallFunction(int argc, VALUE* argv, void* function, struct FunctionType_* fnInfo);
 
-typedef VALUE (*Invoker)(int argc, VALUE* argv, void* function, FunctionType* fnInfo);
+typedef VALUE (*Invoker)(int argc, VALUE* argv, void* function, struct FunctionType_* fnInfo);
 
-Invoker rbffi_GetInvoker(FunctionType* fnInfo);
+Invoker rbffi_GetInvoker(struct FunctionType_* fnInfo);
 
 extern VALUE rbffi_GetEnumValue(VALUE enums, VALUE value);
 extern int rbffi_GetSignedIntValue(VALUE value, int type, int minValue, int maxValue, const char* typeName, VALUE enums);
 
+typedef struct rbffi_blocking_call {
+    rbffi_frame_t* frame;
+    void* function;
+    ffi_cif cif;
+    void **ffiValues;
+    void* retval;
+    void* params;
+} rbffi_blocking_call_t;
+
+VALUE rbffi_do_blocking_call(VALUE data);
+VALUE rbffi_save_frame_exception(VALUE data, VALUE exc);
+
 #ifdef	__cplusplus
 }
 #endif
 
-#endif	/* RBFFI_INVOKE_H */
+#endif	/* RBFFI_CALL_H */