ffi 1.13.0 → 1.15.5

data/ext/ffi_c/DynamicLibrary.c

@@ -29,9 +29,7 @@
 
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-#  include <stdint.h>
-#endif
+#include <stdint.h>
 #if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
 # include <winsock2.h>
 # define _WINSOCKAPI_
@@ -41,9 +39,6 @@
 # include <dlfcn.h>
 #endif
 #include <ruby.h>
-#if defined(_MSC_VER) && !defined(INT8_MIN)
-#  include "win32/stdint.h"
-#endif
 
 #include <ffi.h>
 

data/ext/ffi_c/Function.c

@@ -37,15 +37,8 @@
 #endif
 
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# if !defined(INT8_MIN)
-#  include "win32/stdint.h"
-# endif
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ruby/thread.h>
 
@@ -256,11 +249,11 @@ VALUE
 rbffi_Function_ForProc(VALUE rbFunctionInfo, VALUE proc)
 {
     VALUE callback, cbref, cbTable;
-    Function* fp;
 
     cbref = RTEST(rb_ivar_defined(proc, id_cb_ref)) ? rb_ivar_get(proc, id_cb_ref) : Qnil;
     /* If the first callback reference has the same function function signature, use it */
     if (cbref != Qnil && CLASS_OF(cbref) == rbffi_FunctionClass) {
+        Function* fp;
         Data_Get_Struct(cbref, Function, fp);
         if (fp->rbFunctionInfo == rbFunctionInfo) {
             return cbref;
@@ -279,14 +272,27 @@ rbffi_Function_ForProc(VALUE rbFunctionInfo, VALUE proc)
         rb_ivar_set(proc, id_cb_ref, callback);
     } else {
         /* The proc instance has been used as more than one type of callback, store extras in a hash */
-        cbTable = rb_hash_new();
-        rb_ivar_set(proc, id_cbtable, cbTable);
+        if(cbTable == Qnil) {
+          cbTable = rb_hash_new();
+          rb_ivar_set(proc, id_cbtable, cbTable);
+        }
         rb_hash_aset(cbTable, rbFunctionInfo, callback);
     }
 
     return callback;
 }
 
+#if !defined(_WIN32) && defined(DEFER_ASYNC_CALLBACK)
+static void
+after_fork_callback(void)
+{
+    /* Ensure that a new dispatcher thread is started in a forked process */
+    async_cb_thread = Qnil;
+    pthread_mutex_init(&async_cb_mutex, NULL);
+    pthread_cond_init(&async_cb_cond, NULL);
+}
+#endif
+
 static VALUE
 function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 {
@@ -314,7 +320,16 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 
 #if defined(DEFER_ASYNC_CALLBACK)
         if (async_cb_thread == Qnil) {
+
+#if !defined(_WIN32)
+            if( pthread_atfork(NULL, NULL, after_fork_callback) ){
+                rb_warn("FFI: unable to register fork callback");
+            }
+#endif
+
             async_cb_thread = rb_thread_create(async_cb_event, NULL);
+            /* Name thread, for better debugging */
+            rb_funcall(async_cb_thread, rb_intern("name="), 1, rb_str_new2("FFI Callback Dispatcher"));
         }
 #endif
 
@@ -530,7 +545,9 @@ async_cb_event(void* unused)
         rb_thread_call_without_gvl(async_cb_wait, &w, async_cb_stop, &w);
         if (w.cb != NULL) {
             /* Start up a new ruby thread to run the ruby callback */
-            rb_thread_create(async_cb_call, w.cb);
+            VALUE new_thread = rb_thread_create(async_cb_call, w.cb);
+            /* Name thread, for better debugging */
+            rb_funcall(new_thread, rb_intern("name="), 1, rb_str_new2("FFI Callback Runner"));
         }
     }
 
@@ -716,7 +733,6 @@ invoke_callback(VALUE data)
                 break;
 
             case NATIVE_FUNCTION:
-            case NATIVE_CALLBACK:
             case NATIVE_STRUCT:
                 param = rbffi_NativeValue_ToRuby(paramType, rbParamType, parameters[i]);
                 break;
@@ -792,7 +808,6 @@ invoke_callback(VALUE data)
             break;
 
         case NATIVE_FUNCTION:
-        case NATIVE_CALLBACK:
             if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
 
                 *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
@@ -849,7 +864,7 @@ callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errm
     FunctionType* fnInfo = (FunctionType *) ctx;
     ffi_status ffiStatus;
 
-    ffiStatus = ffi_prep_closure_loc(code, &fnInfo->ffi_cif, callback_invoke, closure, code);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &fnInfo->ffi_cif, callback_invoke, closure, code);
     if (ffiStatus != FFI_OK) {
         snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);
         return false;

data/ext/ffi_c/Function.h

@@ -34,11 +34,7 @@
 extern "C" {
 #endif
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 
 #include <ffi.h>
 

data/ext/ffi_c/FunctionInfo.c

@@ -33,12 +33,8 @@
 #include <sys/types.h>
 #include <stdio.h>
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 
 #include <errno.h>
 #include <ruby.h>

data/ext/ffi_c/LastError.c

@@ -33,12 +33,8 @@
 #endif
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <ruby.h>
 

data/ext/ffi_c/MemoryPointer.c

@@ -28,13 +28,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdbool.h>
-# include <stdint.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdbool.h>
+#include <stdint.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"

data/ext/ffi_c/MemoryPointer.h

@@ -31,11 +31,7 @@
 #ifndef RBFFI_MEMORYPOINTER_H
 #define	RBFFI_MEMORYPOINTER_H
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 #include <ruby.h>
 
 #ifdef	__cplusplus

data/ext/ffi_c/MethodHandle.c

@@ -34,13 +34,8 @@
 # include <sys/mman.h>
 #endif
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #ifndef _WIN32
 # include <unistd.h>
 #endif
@@ -117,6 +112,7 @@ rbffi_MethodHandle_Free(MethodHandle* handle)
 {
     if (handle != NULL) {
         rbffi_Closure_Free(handle->closure);
+        xfree(handle);
     }
 }
 
@@ -140,7 +136,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 #if defined(USE_RAW)
     ffiStatus = ffi_prep_raw_closure(code, &mh_cif, attached_method_invoke, closure);
 #else
-    ffiStatus = ffi_prep_closure_loc(code, &mh_cif, attached_method_invoke, closure, code);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &mh_cif, attached_method_invoke, closure, code);
 #endif
     if (ffiStatus != FFI_OK) {
         snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);

data/ext/ffi_c/Platform.c

@@ -31,19 +31,14 @@
 # include <sys/param.h>
 #endif
 # include <sys/types.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ctype.h>
 #include "rbffi_endian.h"
 #include "Platform.h"
 
-#if defined(__GNU__) || defined(__GLIBC__)
+#if defined(__GNU__) || (defined(__GLIBC__) && !defined(__UCLIBC__))
 # include <gnu/lib-names.h>
 #endif
 
@@ -76,7 +71,7 @@ rbffi_Platform_Init(VALUE moduleFFI)
     rb_define_const(PlatformModule, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
     rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
     rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
-#if defined(__GNU__) || defined(__GLIBC__)
+#if defined(__GNU__) || (defined(__GLIBC__) && !defined(__UCLIBC__))
     rb_define_const(PlatformModule, "GNU_LIBC", rb_str_new2(LIBC_SO));
 #endif
     export_primitive_types(PlatformModule);

data/ext/ffi_c/Pointer.c

@@ -27,13 +27,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -157,14 +152,14 @@ ptr_initialize_copy(VALUE self, VALUE other)
 {
     AbstractMemory* src;
     Pointer* dst;
-    
+
     Data_Get_Struct(self, Pointer, dst);
     src = POINTER(other);
     if (src->size == LONG_MAX) {
         rb_raise(rb_eRuntimeError, "cannot duplicate unbounded memory area");
         return Qnil;
     }
-    
+
     if ((dst->memory.flags & (MEM_RD | MEM_WR)) != (MEM_RD | MEM_WR)) {
         rb_raise(rb_eRuntimeError, "cannot duplicate unreadable/unwritable memory area");
         return Qnil;
@@ -180,13 +175,13 @@ ptr_initialize_copy(VALUE self, VALUE other)
         rb_raise(rb_eNoMemError, "failed to allocate memory size=%lu bytes", src->size);
         return Qnil;
     }
-    
+
     dst->allocated = true;
     dst->autorelease = true;
     dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7ULL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
-    
+
     /* finally, copy the actual memory contents */
     memcpy(dst->memory.address, src->address, src->size);
 
@@ -199,7 +194,7 @@ slice(VALUE self, long offset, long size)
     AbstractMemory* ptr;
     Pointer* p;
     VALUE retval;
-    
+
     Data_Get_Struct(self, AbstractMemory, ptr);
     checkBounds(ptr, offset, size == LONG_MAX ? 1 : size);
 
@@ -214,7 +209,7 @@ slice(VALUE self, long offset, long size)
     return retval;
 }
 
-/* 
+/*
  * Document-method: +
  * call-seq: ptr + offset
  * @param [Numeric] offset
@@ -237,7 +232,7 @@ ptr_plus(VALUE self, VALUE offset)
  * @param [Numeric] offset
  * @param [Numeric] length
  * @return [Pointer]
- * Return a new {Pointer} from an existing one. This pointer points on same contents 
+ * Return a new {Pointer} from an existing one. This pointer points on same contents
  * from +offset+ for a length +length+.
  */
 static VALUE
@@ -256,7 +251,7 @@ ptr_inspect(VALUE self)
 {
     char buf[100];
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     if (ptr->memory.size != LONG_MAX) {
@@ -295,7 +290,7 @@ static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     if (NIL_P(other)) {
@@ -314,7 +309,7 @@ static VALUE
 ptr_address(VALUE self)
 {
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     return ULL2NUM((uintptr_t) ptr->memory.address);
@@ -331,9 +326,9 @@ ptr_address(VALUE self)
  * @overload order
  *  @return [:big, :little] endianness of +self+
  * @overload order(order)
- *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+ 
+ *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+
  *   are synonymous.
- *  @return [self]
+ *  @return a new pointer with the new order
  */
 static VALUE
 ptr_order(int argc, VALUE* argv, VALUE self)
@@ -358,6 +353,8 @@ ptr_order(int argc, VALUE* argv, VALUE self)
 
             } else if (id == rb_intern("big") || id == rb_intern("network")) {
                 order = BIG_ENDIAN;
+            } else {
+                rb_raise(rb_eArgError, "unknown byte order");
             }
         }
         if (order != BYTE_ORDER) {
@@ -395,7 +392,7 @@ ptr_free(VALUE self)
 
     } else {
         VALUE caller = rb_funcall(rb_funcall(Qnil, rb_intern("caller"), 0), rb_intern("first"), 0);
-        
+
         rb_warn("calling free on non allocated pointer %s from %s", RSTRING_PTR(ptr_inspect(self)), RSTRING_PTR(rb_str_to_str(caller)));
     }
 
@@ -408,7 +405,7 @@ ptr_type_size(VALUE self)
     Pointer* ptr;
 
     Data_Get_Struct(self, Pointer, ptr);
-    
+
     return INT2NUM(ptr->memory.typeSize);
 }
 
@@ -440,7 +437,7 @@ ptr_autorelease_p(VALUE self)
     Pointer* ptr;
 
     Data_Get_Struct(self, Pointer, ptr);
-    
+
     return ptr->autorelease ? Qtrue : Qfalse;
 }
 
@@ -472,9 +469,11 @@ rbffi_Pointer_Init(VALUE moduleFFI)
      * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his
      * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic.
      *
-     * ==Autorelease
-     * A pointer object may autorelease his contents when freed (by default). This behaviour may be
-     * changed with {#autorelease=} method.
+     * == Autorelease
+     * By default a pointer object frees its content when it's garbage collected.
+     * Therefore it's usually not necessary to call {#free} explicit.
+     * This behaviour may be changed with {#autorelease=} method.
+     * If it's set to +false+, the memory isn't freed by the garbage collector, but stays valid until +free()+ is called on C level or when the process terminates.
      */
     rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", ffi_AbstractMemory);
     /*

data/ext/ffi_c/Pointer.h

@@ -30,11 +30,7 @@
 #ifndef RBFFI_POINTER_H
 #define	RBFFI_POINTER_H
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 
 #ifdef	__cplusplus
 extern "C" {

data/ext/ffi_c/Struct.c

@@ -31,12 +31,9 @@
 #include <sys/types.h>
 #ifndef _MSC_VER
 # include <sys/param.h>
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
 #endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -290,7 +287,7 @@ struct_field(Struct* s, VALUE fieldName)
         VALUE rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
         if (unlikely(NIL_P(rbField))) {
             VALUE str = rb_funcall2(fieldName, id_to_s, 0, NULL);
-            rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
+            rb_raise(rb_eArgError, "No such field '%s'", StringValueCStr(str));
         }
         /* Write the retrieved coder to the cache */
         p_ce->fieldName = fieldName;

data/ext/ffi_c/StructByValue.c

@@ -32,13 +32,8 @@
 #endif
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <ruby.h>
 

data/ext/ffi_c/StructLayout.c

@@ -32,12 +32,9 @@
 
 #ifndef _MSC_VER
 # include <sys/param.h>
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
 #endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -126,7 +123,6 @@ struct_field_initialize(int argc, VALUE* argv, VALUE self)
 
     switch (field->type->nativeType == NATIVE_MAPPED ? ((MappedType *) field->type)->type->nativeType : field->type->nativeType) {
         case NATIVE_FUNCTION:
-        case NATIVE_CALLBACK:
         case NATIVE_POINTER:
             field->referenceRequired = true;
             break;

data/ext/ffi_c/Thread.c

@@ -28,12 +28,7 @@
  */
 
 #include <stddef.h>
-#ifndef _MSC_VER
 #include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
 
 #if defined(__CYGWIN__) || !defined(_WIN32)
 # include <pthread.h>

data/ext/ffi_c/Thread.h

@@ -30,12 +30,7 @@
 #ifndef RBFFI_THREAD_H
 #define	RBFFI_THREAD_H
 
-#ifndef _MSC_VER
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdbool.h>
 #include <ruby.h>
 #include "extconf.h"
 

data/ext/ffi_c/Type.c

@@ -28,7 +28,7 @@
  */
 
 #ifndef _MSC_VER
-#include <sys/param.h>
+# include <sys/param.h>
 #endif
 
 #include <sys/types.h>

data/ext/ffi_c/Types.c

@@ -85,10 +85,9 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
             return rbffi_Pointer_NewInstance(*(void **) ptr);
         case NATIVE_BOOL:
             return ((unsigned char) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
-        
-        case NATIVE_FUNCTION:
-        case NATIVE_CALLBACK: {
-            return *(void **) ptr != NULL 
+
+        case NATIVE_FUNCTION: {
+            return *(void **) ptr != NULL
                     ? rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr))
                     : Qnil;
         }
@@ -116,15 +115,15 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
 
             values[0] = rbffi_NativeValue_ToRuby(m->type, m->rbType, ptr);
             values[1] = Qnil;
-            
+
 
             rbReturnValue = rb_funcall2(m->rbConverter, id_from_native, 2, values);
             RB_GC_GUARD(values[0]);
             RB_GC_GUARD(rbType);
-            
+
             return rbReturnValue;
         }
-    
+
         default:
             rb_raise(rb_eRuntimeError, "Unknown type: %d", type->nativeType);
             return Qnil;

data/ext/ffi_c/Types.h

@@ -51,20 +51,19 @@ typedef enum {
     NATIVE_FLOAT64,
     NATIVE_LONGDOUBLE,
     NATIVE_POINTER,
-    NATIVE_CALLBACK,
     NATIVE_FUNCTION,
     NATIVE_BUFFER_IN,
     NATIVE_BUFFER_OUT,
     NATIVE_BUFFER_INOUT,
     NATIVE_CHAR_ARRAY,
     NATIVE_BOOL,
-    
+
     /** An immutable string.  Nul terminated, but only copies in to the native function */
     NATIVE_STRING,
-    
+
     /** The function takes a variable number of arguments */
     NATIVE_VARARGS,
-    
+
     /** Struct-by-value param or result */
     NATIVE_STRUCT,
 

data/ext/ffi_c/Variadic.c

@@ -33,13 +33,8 @@
 #include <sys/types.h>
 
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 
 #include <ffi.h>
@@ -173,7 +168,8 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     ffi_type* ffiReturnType;
     Type** paramTypes;
     VALUE* argv;
-    int paramCount = 0, fixedCount = 0, i;
+    VALUE* callbackParameters;
+    int paramCount = 0, fixedCount = 0, callbackCount = 0, i;
     ffi_status ffiStatus;
     rbffi_frame_t frame = { 0 };
 
@@ -187,6 +183,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     params = ALLOCA_N(FFIStorage, paramCount);
     ffiValues = ALLOCA_N(void*, paramCount);
     argv = ALLOCA_N(VALUE, paramCount);
+    callbackParameters = ALLOCA_N(VALUE, paramCount);
     retval = alloca(MAX(invoker->returnType->ffiType->size, FFI_SIZEOF_ARG));
 
     for (i = 0; i < paramCount; ++i) {
@@ -216,6 +213,14 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
                 Data_Get_Struct(rbType, Type, paramTypes[i]);
                 break;
 
+            case NATIVE_FUNCTION:
+                if (!rb_obj_is_kind_of(rbType, rbffi_FunctionTypeClass)) {
+                    VALUE typeName = rb_funcall2(rbType, rb_intern("inspect"), 0, NULL);
+                    rb_raise(rb_eTypeError, "Incorrect parameter type (%s)", RSTRING_PTR(typeName));
+                }
+                callbackParameters[callbackCount++] = rbType;
+                break;
+
             default:
                 break;
         }
@@ -253,7 +258,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     }
 
     rbffi_SetupCallParams(paramCount, argv, -1, paramTypes, params,
-        ffiValues, NULL, 0, invoker->rbEnums);
+        ffiValues, callbackParameters, callbackCount, invoker->rbEnums);
 
     rbffi_frame_push(&frame);