ffi 1.7.0-x86-mingw32 → 1.8.1-x86-mingw32

data/ext/ffi_c/AbstractMemory.c

@@ -20,19 +20,17 @@
 
 #include <sys/types.h>
 #ifndef _MSC_VER
-#include <sys/param.h>
-#include <stdint.h>
-#include <stdbool.h>
+# include <sys/param.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
+
 #include <limits.h>
 #include <ruby.h>
-#if defined(_MSC_VER) && !defined(INT8_MIN)
-#  include "win32/stdint.h"
-#endif
+
 #include "rbffi.h"
 #include "compat.h"
 #include "AbstractMemory.h"

data/ext/ffi_c/Buffer.c

@@ -19,14 +19,11 @@
  */
 
 #ifndef _MSC_VER
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
-#ifndef _MSC_VER
-#include <stdint.h>
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <limits.h>
 #include <ruby.h>

data/ext/ffi_c/Call.c

@@ -26,16 +26,15 @@
 #include <sys/types.h>
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <errno.h>
 #include <ruby.h>
-#if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION) && !defined(_WIN32)
+#if defined(HAVE_NATIVETHREAD) && (defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)) && !defined(_WIN32)
 #  include <signal.h>
 #  include <pthread.h>
 #endif
@@ -267,6 +266,7 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
 
 
 typedef struct BlockingCall_ {
+    rbffi_frame_t* frame;
     void* function;
     FunctionType* info;
     void **ffiValues;
@@ -281,14 +281,13 @@ static VALUE
 call_blocking_function(void* data)
 {
     BlockingCall* b = (BlockingCall *) data;
-
+    b->frame->has_gvl = false;
     ffi_call(&b->info->ffi_cif, FFI_FN(b->function), b->retval, b->ffiValues);
+    b->frame->has_gvl = true;
 
     return Qnil;
 }
 
-#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
-
 static VALUE
 do_blocking_call(void *data)
 {
@@ -298,30 +297,22 @@ do_blocking_call(void *data)
 }
 
 static VALUE
-cleanup_blocking_call(void *data)
+save_frame_exception(void *data, VALUE exc)
 {
-    BlockingCall* bc = (BlockingCall *) data;
-
-    memcpy(bc->stkretval, bc->retval, MAX(bc->info->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
-    xfree(bc->params);
-    xfree(bc->ffiValues);
-    xfree(bc->retval);
-    xfree(bc);
-
+    rbffi_frame_t* frame = (rbffi_frame_t *) data;
+    frame->exc = exc;
     return Qnil;
 }
 
-#endif /* HAVE_RB_THREAD_BLOCKING_REGION */
-
 VALUE
 rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
 {
     void* retval;
     void** ffiValues;
     FFIStorage* params;
-    VALUE rbReturnValue, exc;    
-    rbffi_thread_t oldThread;
-
+    VALUE rbReturnValue;
+    rbffi_frame_t frame = { 0 };
+    
     retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
     
     if (unlikely(fnInfo->blocking)) {
@@ -347,21 +338,24 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
         bc->function = function;
         bc->ffiValues = ffiValues;
         bc->params = params;
+        bc->frame = &frame;
 
         rbffi_SetupCallParams(argc, argv,
             fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
             fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
 
-#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) 
-        rb_thread_call_without_gvl(call_blocking_function, bc, (void *) -1, NULL);
+        rbffi_frame_push(&frame); 
+        rb_rescue2(do_blocking_call, (VALUE) bc, save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
+        rbffi_frame_pop(&frame);
 
-#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
-        rb_thread_blocking_region(call_blocking_function, bc, (void *) -1, NULL);
-
-#else
-        rb_ensure(do_blocking_call, (VALUE) bc, cleanup_blocking_call, (VALUE) bc);
+#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
+        memcpy(bc->stkretval, bc->retval, MAX(bc->info->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
+        xfree(bc->params);
+        xfree(bc->ffiValues);
+        xfree(bc->retval);
+        xfree(bc);
 #endif
-        
+    
     } else {
 
         ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
@@ -371,22 +365,19 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
             fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
             fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
 
-        oldThread = rbffi_active_thread;
-        rbffi_active_thread = rbffi_thread_self();
-        
+        rbffi_frame_push(&frame);
         ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
-
-        exc = rbffi_active_thread.exc;
-        rbffi_active_thread = oldThread;
-        if (exc != Qnil) {
-            rb_exc_raise(exc);
-        }
+        rbffi_frame_pop(&frame);
     }
 
     if (unlikely(!fnInfo->ignoreErrno)) {
         rbffi_save_errno();
     }    
-    
+
+    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);
     

data/ext/ffi_c/Call.h

@@ -21,8 +21,8 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef RBFFI_INVOKE_H
-#define	RBFFI_INVOKE_H
+#ifndef RBFFI_CALL_H
+#define	RBFFI_CALL_H
 
 #ifdef	__cplusplus
 extern "C" {
@@ -59,19 +59,19 @@ typedef union {
     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,
         FFIStorage* paramStorage, void** ffiValues,
         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);
@@ -80,5 +80,5 @@ extern int rbffi_GetSignedIntValue(VALUE value, int type, int minValue, int maxV
 }
 #endif
 
-#endif	/* RBFFI_INVOKE_H */
+#endif	/* RBFFI_CALL_H */
 

data/ext/ffi_c/ClosurePool.c

@@ -26,12 +26,11 @@
 #endif
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #ifndef _WIN32
 #  include <unistd.h>

data/ext/ffi_c/Function.c

@@ -18,8 +18,6 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "MethodHandle.h"
-
 #ifndef _MSC_VER
 #include <sys/param.h>
 #endif
@@ -28,19 +26,18 @@
 # include <sys/mman.h>
 # include <unistd.h>
 #endif
+
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
-#include <ruby.h>
-#if defined(_MSC_VER) && !defined(INT8_MIN)
+# include "win32/stdbool.h"
+# if !defined(INT8_MIN)
 #  include "win32/stdint.h"
+# endif
 #endif
+#include <ruby.h>
 
 #include <ffi.h>
 #if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
@@ -59,10 +56,11 @@ typedef int bool;
 #include "LastError.h"
 #include "Call.h"
 #include "ClosurePool.h"
-#include "Function.h"
 #include "MappedType.h"
 #include "Thread.h"
 #include "LongDouble.h"
+#include "MethodHandle.h"
+#include "Function.h"
 
 typedef struct Function_ {
     Pointer base;
@@ -80,6 +78,7 @@ static VALUE function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc);
 static void callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data);
 static bool callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
 static VALUE callback_with_gvl(void* data);
+static VALUE invoke_callback(void* data);
 static VALUE save_callback_exception(void* data, VALUE exc);
 
 #define DEFER_ASYNC_CALLBACK 1
@@ -107,6 +106,7 @@ struct gvl_callback {
     void*    retval;
     void**   parameters;
     bool done;
+    rbffi_frame_t *frame;
 #if defined(DEFER_ASYNC_CALLBACK)
     struct gvl_callback* next;
 # ifndef _WIN32
@@ -124,13 +124,13 @@ static struct gvl_callback* async_cb_list = NULL;
 # ifndef _WIN32
     static pthread_mutex_t async_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
     static pthread_cond_t async_cb_cond = PTHREAD_COND_INITIALIZER;
-#  if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#  if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
     static int async_cb_pipe[2];
 #  endif
 # else
     static HANDLE async_cb_cond;
     static CRITICAL_SECTION async_cb_lock;
-#  if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#  if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
     static int async_cb_pipe[2];
 #  endif
 # endif
@@ -311,9 +311,9 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 
 #if defined(DEFER_ASYNC_CALLBACK)
         if (async_cb_thread == Qnil) {
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION) && defined(_WIN32)
+#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)) && defined(_WIN32)
             _pipe(async_cb_pipe, 1024, O_BINARY);
-#elif !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#elif !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
             pipe(async_cb_pipe);
             fcntl(async_cb_pipe[0], F_SETFL, fcntl(async_cb_pipe[0], F_GETFL) | O_NONBLOCK);
             fcntl(async_cb_pipe[1], F_SETFL, fcntl(async_cb_pipe[1], F_GETFL) | O_NONBLOCK);
@@ -453,16 +453,22 @@ function_release(VALUE self)
 static void
 callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
 {
-    struct gvl_callback cb;
+    struct gvl_callback cb = { 0 };
+    
     cb.closure = (Closure *) user_data;
     cb.retval = retval;
     cb.parameters = parameters;
     cb.done = false;
-
-    if (rbffi_thread_has_gvl_p()) {
-        rbffi_active_thread.exc = Qnil;
-        rb_rescue2(callback_with_gvl, (VALUE) &cb, save_callback_exception, (VALUE) &cb, rb_eException, (VALUE) 0);
+    cb.frame = rbffi_frame_current();
     
+    if (cb.frame != NULL) cb.frame->exc = Qnil;
+    if (cb.frame != NULL && cb.frame->has_gvl) {
+        callback_with_gvl(&cb);
+
+#if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
+    } else if (cb.frame != NULL) {
+        rb_thread_call_with_gvl(callback_with_gvl, &cb);
+#endif
 #if defined(DEFER_ASYNC_CALLBACK) && !defined(_WIN32)
     } else {
         bool empty = false;
@@ -475,9 +481,9 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         empty = async_cb_list == NULL;
         cb.next = async_cb_list;
         async_cb_list = &cb;
-        pthread_mutex_unlock(&async_cb_mutex);
 
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
+        pthread_mutex_unlock(&async_cb_mutex);
         /* Only signal if the list was empty */
         if (empty) {
             char c;
@@ -485,6 +491,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         }
 #else
         pthread_cond_signal(&async_cb_cond);
+        pthread_mutex_unlock(&async_cb_mutex);
 #endif
 
         /* Wait for the thread executing the ruby callback to signal it is done */
@@ -509,7 +516,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         async_cb_list = &cb;
         LeaveCriticalSection(&async_cb_lock);
 
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
         /* Only signal if the list was empty */
         if (empty) {
             char c;
@@ -697,9 +704,9 @@ static VALUE
 async_cb_call(void *data)
 {
     struct gvl_callback* cb = (struct gvl_callback *) data;
-
-    callback_with_gvl(cb);
-
+    
+    callback_with_gvl(data);
+        
     /* Signal the original native thread that the ruby code has completed */
 #ifdef _WIN32
     SetEvent(cb->async_event);
@@ -715,9 +722,14 @@ async_cb_call(void *data)
 
 #endif
 
-
 static VALUE
 callback_with_gvl(void* data)
+{
+    rb_rescue2(invoke_callback, (VALUE) data, save_callback_exception, (VALUE) data, rb_eException, (VALUE) 0);
+}
+
+static VALUE
+invoke_callback(void* data)
 {
     struct gvl_callback* cb = (struct gvl_callback *) data;
 
@@ -913,7 +925,7 @@ save_callback_exception(void* data, VALUE exc)
     struct gvl_callback* cb = (struct gvl_callback *) data;
     
     memset(cb->retval, 0, ((Function *) cb->closure->info)->info->returnType->ffiType->size);
-    rbffi_active_thread.exc = exc;
+    if (cb->frame != NULL) cb->frame->exc = exc;
     
     return Qnil;
 }

data/ext/ffi_c/Function.h

@@ -26,12 +26,11 @@ extern "C" {
 #endif
 
 #ifndef _MSC_VER
-#include <stdbool.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
 #endif
+
 #include <ffi.h>
 
 typedef struct FunctionType_ FunctionType;

data/ext/ffi_c/FunctionInfo.c

@@ -18,18 +18,18 @@
  */
 
 #ifndef _MSC_VER
-#include <sys/param.h>
+# include <sys/param.h>
 #endif
 #include <sys/types.h>
 #include <stdio.h>
+
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
 #endif
+
 #include <errno.h>
 #include <ruby.h>
 

data/ext/ffi_c/LastError.c

@@ -19,17 +19,15 @@
  */
 
 #ifndef _MSC_VER
-#include <sys/param.h>
+# include <sys/param.h>
 #endif
 #include <sys/types.h>
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
 #endif
 #include <errno.h>
 #include <ruby.h>

data/ext/ffi_c/MemoryPointer.c

@@ -20,14 +20,11 @@
  */
 
 #ifndef _MSC_VER
-#include <stdbool.h>
+# include <stdbool.h>
+# include <stdint.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
-#ifndef _MSC_VER
-#include <stdint.h>
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <limits.h>
 #include <ruby.h>

data/ext/ffi_c/MemoryPointer.h

@@ -23,11 +23,9 @@
 #define	RBFFI_MEMORYPOINTER_H
 
 #ifndef _MSC_VER
-#include <stdbool.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
 #endif
 #include <ruby.h>
 

data/ext/ffi_c/MethodHandle.c

@@ -22,19 +22,18 @@
 #endif
 #include <sys/types.h>
 #ifndef _WIN32
-#  include <sys/mman.h>
+# include <sys/mman.h>
 #endif
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdint.h"
+# include "win32/stdbool.h"
 #endif
 #ifndef _WIN32
-#  include <unistd.h>
+# include <unistd.h>
 #endif
 #include <errno.h>
 #include <ruby.h>

data/ext/ffi_c/Platform.c

@@ -19,23 +19,23 @@
  */
 
 #ifndef _MSC_VER
-#include <sys/param.h>
+# include <sys/param.h>
 #endif
-#include <sys/types.h>
+# include <sys/types.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdint.h"
+# include "win32/stdbool.h"
 #endif
 #include <ruby.h>
 #include <ctype.h>
 #include "rbffi_endian.h"
 #include "Platform.h"
+
 #if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
-  #include <gnu/lib-names.h>
+# include <gnu/lib-names.h>
 #endif
 
 static VALUE PlatformModule = Qnil;

data/ext/ffi_c/Pointer.c

@@ -19,14 +19,11 @@
  */
 
 #ifndef _MSC_VER
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
-#ifndef _MSC_VER
-#include <stdint.h>
+# include "win32/stdint.h"
+# include "win32/stdbool.h"
 #endif
 #include <limits.h>
 #include <ruby.h>

data/ext/ffi_c/Pointer.h

@@ -22,11 +22,9 @@
 #define	RBFFI_POINTER_H
 
 #ifndef _MSC_VER
-#include <stdbool.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
 #endif
 
 #ifdef	__cplusplus

data/ext/ffi_c/Struct.c

@@ -20,16 +20,13 @@
  */
 
 #include <sys/types.h>
-
-#include "Function.h"
 #ifndef _MSC_VER
-#include <sys/param.h>
-#include <stdint.h>
-#include <stdbool.h>
+# include <sys/param.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <ruby.h>
 #include "rbffi.h"
@@ -39,10 +36,11 @@ typedef int bool;
 #include "MemoryPointer.h"
 #include "Function.h"
 #include "Types.h"
-#include "Struct.h"
+#include "Function.h"
 #include "StructByValue.h"
 #include "ArrayType.h"
 #include "MappedType.h"
+#include "Struct.h"
 
 typedef struct InlineArray_ {
     VALUE rbMemory;

data/ext/ffi_c/StructByReference.c

@@ -26,17 +26,16 @@
  */
 
 #ifndef _MSC_VER
-#include <sys/param.h>
+# include <sys/param.h>
 #endif
 #include <sys/types.h>
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <errno.h>
 #include <ruby.h>

data/ext/ffi_c/StructByValue.c

@@ -24,12 +24,11 @@
 #include <sys/types.h>
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <errno.h>
 #include <ruby.h>

data/ext/ffi_c/StructLayout.c

@@ -21,15 +21,13 @@
 
 #include <sys/types.h>
 
-#include "Function.h"
 #ifndef _MSC_VER
-#include <sys/param.h>
-#include <stdint.h>
-#include <stdbool.h>
+# include <sys/param.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <ruby.h>
 #include "rbffi.h"
@@ -39,10 +37,11 @@ typedef int bool;
 #include "MemoryPointer.h"
 #include "Function.h"
 #include "Types.h"
-#include "Struct.h"
 #include "StructByValue.h"
 #include "ArrayType.h"
+#include "Function.h"
 #include "MappedType.h"
+#include "Struct.h"
 
 #define FFI_ALIGN(v, a)  (((((size_t) (v))-1) | ((a)-1))+1)
 

data/ext/ffi_c/Thread.c

@@ -21,9 +21,8 @@
 #ifndef _MSC_VER
 #include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 
 #ifndef _WIN32
@@ -39,46 +38,56 @@ typedef int bool;
 #include <fcntl.h>
 #include "Thread.h"
 
+#ifdef _WIN32
+static volatile DWORD frame_thread_key = TLS_OUT_OF_INDEXES;
+#else
+static pthread_key_t thread_data_key;
+struct thread_data {
+    rbffi_frame_t* frame;
+};
+static inline struct thread_data* thread_data_get(void);
 
-rbffi_thread_t rbffi_active_thread;
+#endif
 
-rbffi_thread_t
-rbffi_thread_self()
+rbffi_frame_t*
+rbffi_frame_current(void)
 {
-    rbffi_thread_t self;
 #ifdef _WIN32
-    self.id = GetCurrentThreadId();
+    return (rbffi_frame_t *) TlsGetValue(frame_thread_key);
 #else
-    self.id = pthread_self();
+    struct thread_data* td = (struct thread_data *) pthread_getspecific(thread_data_key);
+    return td != NULL ? td->frame : NULL;
 #endif
-    self.valid = true;
-    self.exc = Qnil;
-
-    return self;
 }
 
-bool
-rbffi_thread_equal(const rbffi_thread_t* lhs, const rbffi_thread_t* rhs)
+void 
+rbffi_frame_push(rbffi_frame_t* frame)
 {
-    return lhs->valid && rhs->valid && 
+    memset(frame, 0, sizeof(*frame));
+    frame->has_gvl = true;
+    frame->exc = Qnil;
+    
 #ifdef _WIN32
-            lhs->id == rhs->id;
+    frame->prev = TlsGetValue(frame_thread_key);
+    TlsSetValue(frame_thread_key, frame);
 #else
-            pthread_equal(lhs->id, rhs->id);
+    frame->td = thread_data_get();
+    frame->prev = frame->td->frame;
+    frame->td->frame = frame;
 #endif
 }
 
-bool
-rbffi_thread_has_gvl_p(void)
+void 
+rbffi_frame_pop(rbffi_frame_t* frame)
 {
 #ifdef _WIN32
-    return rbffi_active_thread.valid && rbffi_active_thread.id == GetCurrentThreadId();
+    TlsSetValue(frame_thread_key, frame->prev);
 #else
-    return rbffi_active_thread.valid && pthread_equal(rbffi_active_thread.id, pthread_self());
+    frame->td->frame = frame->prev;
 #endif
 }
 
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
 
 #if !defined(_WIN32)
 
@@ -296,3 +305,39 @@ rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(voi
 
 #endif /* HAVE_RB_THREAD_BLOCKING_REGION */
 
+#ifndef _WIN32
+static struct thread_data* thread_data_init(void);
+
+static inline struct thread_data*
+thread_data_get(void)
+{
+    struct thread_data* td = (struct thread_data *) pthread_getspecific(thread_data_key);
+    return td != NULL ? td : thread_data_init();
+}
+
+static struct thread_data*
+thread_data_init(void)
+{
+    struct thread_data* td = calloc(1, sizeof(struct thread_data));
+
+    pthread_setspecific(thread_data_key, td);
+
+    return td;
+}
+
+static void
+thread_data_free(void *ptr)
+{
+    free(ptr);
+}
+#endif
+
+void
+rbffi_Thread_Init(VALUE moduleFFI)
+{
+#ifdef _WIN32
+    frame_thread_key = TlsAlloc();
+#else
+    pthread_key_create(&thread_data_key, thread_data_free);    
+#endif
+}

data/ext/ffi_c/Thread.h

@@ -22,11 +22,10 @@
 #define	RBFFI_THREAD_H
 
 #ifndef _MSC_VER
-#include <stdbool.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <ruby.h>
 #include "extconf.h"
@@ -36,11 +35,6 @@ extern "C" {
 #endif
 
 
-#ifdef HAVE_RUBY_THREAD_HAS_GVL_P
-    extern int ruby_thread_has_gvl_p(void);
-# define rbffi_thread_has_gvl_p ruby_thread_has_gvl_p
-#else
-
 #ifdef _WIN32
 # include <windows.h>
 #else
@@ -54,17 +48,29 @@ typedef struct {
     pthread_t id;
 #endif
     bool valid;
+    bool has_gvl;
     VALUE exc;
 } rbffi_thread_t;
 
-extern rbffi_thread_t rbffi_active_thread;
-rbffi_thread_t rbffi_thread_self();
-bool rbffi_thread_equal(const rbffi_thread_t* lhs, const rbffi_thread_t* rhs);
-bool rbffi_thread_has_gvl_p(void);
-
+typedef struct rbffi_frame {
+#ifndef _WIN32
+    struct thread_data* td;
 #endif
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    struct rbffi_frame* prev;
+    bool has_gvl;
+    VALUE exc;
+} rbffi_frame_t;
+
+rbffi_frame_t* rbffi_frame_current(void);
+void rbffi_frame_push(rbffi_frame_t* frame);
+void rbffi_frame_pop(rbffi_frame_t* frame);
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+# define rbffi_thread_blocking_region rb_thread_call_without_gvl
+
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
 # define rbffi_thread_blocking_region rb_thread_blocking_region
+
 #else
 
 VALUE rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(void *), void *data2);

data/ext/ffi_c/Variadic.c

@@ -24,12 +24,11 @@
 
 #include <stdio.h>
 #ifndef _MSC_VER
-#include <stdint.h>
-#include <stdbool.h>
+# include <stdint.h>
+# include <stdbool.h>
 #else
-typedef int bool;
-#define true 1
-#define false 0
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
 #endif
 #include <ruby.h>
 
@@ -163,8 +162,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     VALUE* argv;
     int paramCount = 0, i;
     ffi_status ffiStatus;
-    VALUE exc;
-    rbffi_thread_t oldThread;
+    rbffi_frame_t frame = { 0 };
 
     Check_Type(parameterTypes, T_ARRAY);
     Check_Type(parameterValues, T_ARRAY);
@@ -239,18 +237,16 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
 
     rbffi_SetupCallParams(paramCount, argv, -1, paramTypes, params,
         ffiValues, NULL, 0, invoker->rbEnums);
-    oldThread = rbffi_active_thread;
-    rbffi_active_thread = rbffi_thread_self();
-
+    
+    rbffi_frame_push(&frame);
     ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
-
-    exc = rbffi_active_thread.exc;
-    rbffi_active_thread = oldThread;
-    if (exc != Qnil) {
-        rb_exc_raise(exc);
-    }
+    rbffi_frame_pop(&frame);
     
     rbffi_save_errno();
+    
+    if (RTEST(frame.exc) && frame.exc != Qnil) {
+        rb_exc_raise(frame.exc);
+    }
 
     return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, retval);
 }

data/ext/ffi_c/ffi.c

@@ -49,7 +49,8 @@ VALUE rbffi_FFIModule = Qnil;
 static VALUE moduleFFI = Qnil;
 
 void
-Init_ffi_c(void) {
+Init_ffi_c(void) 
+{
     /* 
      * Document-module: FFI
      *
@@ -58,7 +59,8 @@ Init_ffi_c(void) {
     rbffi_FFIModule = moduleFFI = rb_define_module("FFI");
     rb_global_variable(&rbffi_FFIModule);
 
-
+    rbffi_Thread_Init(rbffi_FFIModule);
+    
     /* FFI::Type needs to be initialized before most other classes */
     rbffi_Type_Init(moduleFFI);
 

data/ext/ffi_c/rbffi.h

@@ -38,6 +38,7 @@ extern void rbffi_Variadic_Init(VALUE ffiModule);
 extern void rbffi_DataConverter_Init(VALUE ffiModule);
 extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
 extern int rbffi_type_size(VALUE type);
+extern void rbffi_Thread_Init(VALUE moduleFFI);
 
 #ifdef	__cplusplus
 }

data/ext/ffi_c/win32/stdbool.h

@@ -0,0 +1,8 @@
+#ifndef FFI_STDBOOL_H
+#define FFI_STDBOOL_H
+
+typedef int bool;
+#define true 1
+#define false 0
+
+#endif /* FFI_STDBOOL_H */

data/ext/ffi_c/win32/stdint.h

@@ -1,4 +1,5 @@
 /* stdint.h standard header */
+#if !defined(_MSC_VER) && !defined(INT8_MIN)
 #pragma once
 #ifndef _STDINT
 #define _STDINT
@@ -197,3 +198,4 @@ using _CSTD uint_fast32_t; using _CSTD uint_fast64_t;
  * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
  * Consult your license regarding permissions and restrictions.
 V5.20:0009 */
+#endif /* !defined(_MSC_VER) && !defined(INT8_MIN) */

data/ffi.gemspec

@@ -1,6 +1,8 @@
+require File.expand_path("../lib/#{File.basename(__FILE__, '.gemspec')}/version", __FILE__)
+
 Gem::Specification.new do |s|
   s.name = 'ffi'
-  s.version = '1.7.0'
+  s.version = FFI::VERSION
   s.author = 'Wayne Meissner'
   s.email = 'wmeissner@gmail.com'
   s.homepage = 'http://wiki.github.com/ffi/ffi'

data/lib/ffi/version.rb

@@ -0,0 +1,4 @@
+module FFI
+  VERSION = '1.8.1'
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ffi
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 53
   prerelease: 
   segments: 
   - 1
-  - 7
-  - 0
-  version: 1.7.0
+  - 8
+  - 1
+  version: 1.8.1
 platform: x86-mingw32
 authors: 
 - Wayne Meissner
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-04-12 00:00:00 Z
+date: 2013-04-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -417,6 +417,7 @@ files:
 - ext/ffi_c/Types.c
 - ext/ffi_c/Types.h
 - ext/ffi_c/Variadic.c
+- ext/ffi_c/win32/stdbool.h
 - ext/ffi_c/win32/stdint.h
 - gen/log
 - gen/Rakefile
@@ -471,6 +472,7 @@ files:
 - lib/ffi/types.rb
 - lib/ffi/union.rb
 - lib/ffi/variadic.rb
+- lib/ffi/version.rb
 - lib/ffi.rb
 - spec/ffi/async_callback_spec.rb
 - spec/ffi/bool_spec.rb