alinta-ffi 1.9.19

data/ext/ffi_c/Type.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * Copyright (C) 2009 Luc Heinrich <luc@honk-honk.com>
+ *
+ * This file is part of ruby-ffi.
+ *
+ * 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 Evan Phoenix nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef RBFFI_TYPE_H
+#define	RBFFI_TYPE_H
+
+#include <ruby.h>
+#include <ffi.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct Type_ Type;
+
+#include "Types.h"
+    
+struct Type_ {
+    NativeType nativeType;
+    ffi_type* ffiType;
+};
+
+extern VALUE rbffi_TypeClass;
+extern VALUE rbffi_Type_Lookup(VALUE type);
+extern VALUE rbffi_Type_Find(VALUE type);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_TYPE_H */
+

data/ext/ffi_c/Types.c

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich
+ * 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.
+ *
+ * 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.
+ */
+
+#include <ruby.h>
+#include "Pointer.h"
+#include "rbffi.h"
+#include "Function.h"
+#include "StructByValue.h"
+#include "Types.h"
+#include "Struct.h"
+#include "MappedType.h"
+#include "MemoryPointer.h"
+#include "LongDouble.h"
+
+static ID id_from_native = 0;
+
+
+VALUE
+rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
+{
+    switch (type->nativeType) {
+        case NATIVE_VOID:
+            return Qnil;
+        case NATIVE_INT8:
+          return INT2NUM((signed char) *(ffi_sarg *) ptr);
+        case NATIVE_INT16:
+          return INT2NUM((signed short) *(ffi_sarg *) ptr);
+        case NATIVE_INT32:
+          return INT2NUM((signed int) *(ffi_sarg *) ptr);
+        case NATIVE_LONG:
+            return LONG2NUM((signed long) *(ffi_sarg *) ptr);
+        case NATIVE_INT64:
+            return LL2NUM(*(signed long long *) ptr);
+
+        case NATIVE_UINT8:
+          return UINT2NUM((unsigned char) *(ffi_arg *) ptr);
+        case NATIVE_UINT16:
+          return UINT2NUM((unsigned short) *(ffi_arg *) ptr);
+        case NATIVE_UINT32:
+          return UINT2NUM((unsigned int) *(ffi_arg *) ptr);
+        case NATIVE_ULONG:
+            return ULONG2NUM((unsigned long) *(ffi_arg *) ptr);
+        case NATIVE_UINT64:
+            return ULL2NUM(*(unsigned long long *) ptr);
+
+        case NATIVE_FLOAT32:
+            return rb_float_new(*(float *) ptr);
+        case NATIVE_FLOAT64:
+            return rb_float_new(*(double *) ptr);
+
+        case NATIVE_LONGDOUBLE:
+	  return rbffi_longdouble_new(*(long double *) ptr);
+
+        case NATIVE_STRING:
+            return (*(void **) ptr != NULL) ? rb_tainted_str_new2(*(char **) ptr) : Qnil;
+        case NATIVE_POINTER:
+            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 
+                    ? rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr))
+                    : Qnil;
+        }
+
+        case NATIVE_STRUCT: {
+            StructByValue* sbv = (StructByValue *)type;
+            AbstractMemory* mem;
+            VALUE rbMemory = rbffi_MemoryPointer_NewInstance(1, sbv->base.ffiType->size, false);
+
+            Data_Get_Struct(rbMemory, AbstractMemory, mem);
+            memcpy(mem->address, ptr, sbv->base.ffiType->size);
+            RB_GC_GUARD(rbMemory);
+            RB_GC_GUARD(rbType);
+
+            return rb_class_new_instance(1, &rbMemory, sbv->rbStructClass);
+        }
+
+        case NATIVE_MAPPED: {
+            /*
+             * For mapped types, first convert to the real native type, then upcall to
+             * ruby to convert to the expected return type
+             */
+            MappedType* m = (MappedType *) type;
+            VALUE values[2], rbReturnValue;
+
+            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;
+    }
+}
+
+void
+rbffi_Types_Init(VALUE moduleFFI)
+{
+    id_from_native = rb_intern("from_native");
+}
+

data/ext/ffi_c/Types.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
+ *
+ * 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.
+ *
+ * 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_TYPES_H
+#define	RBFFI_TYPES_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    NATIVE_VOID,
+    NATIVE_INT8,
+    NATIVE_UINT8,
+    NATIVE_INT16,
+    NATIVE_UINT16,
+    NATIVE_INT32,
+    NATIVE_UINT32,
+    NATIVE_INT64,
+    NATIVE_UINT64,
+    NATIVE_LONG,
+    NATIVE_ULONG,
+    NATIVE_FLOAT32,
+    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,
+
+    /** An array type definition */
+    NATIVE_ARRAY,
+
+    /** Custom native type */
+    NATIVE_MAPPED,
+} NativeType;
+
+#include <ffi.h>
+#include "Type.h"
+
+VALUE rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr);
+void rbffi_Types_Init(VALUE moduleFFI);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_TYPES_H */
+

data/ext/ffi_c/Variadic.c

@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) 2008-2010 Wayne Meissner
+ * Copyright (C) 2009 Andrea Fazzi <andrea.fazzi@alcacoop.it>
+ * 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.
+ *
+ * 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>
+#ifndef _MSC_VER
+# include <stdint.h>
+# include <stdbool.h>
+#else
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
+#endif
+#include <ruby.h>
+
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "Types.h"
+#include "Type.h"
+#include "LastError.h"
+#include "MethodHandle.h"
+#include "Call.h"
+#include "Thread.h"
+
+typedef struct VariadicInvoker_ {
+    VALUE rbAddress;
+    VALUE rbReturnType;
+    VALUE rbEnums;
+
+    Type* returnType;
+    ffi_abi abi;
+    void* function;
+    int paramCount;
+    bool blocking;
+} VariadicInvoker;
+
+
+static VALUE variadic_allocate(VALUE klass);
+static VALUE variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes,
+        VALUE rbReturnType, VALUE options);
+static void variadic_mark(VariadicInvoker *);
+
+static VALUE classVariadicInvoker = Qnil;
+
+
+static VALUE
+variadic_allocate(VALUE klass)
+{
+    VariadicInvoker *invoker;
+    VALUE obj = Data_Make_Struct(klass, VariadicInvoker, variadic_mark, -1, invoker);
+
+    invoker->rbAddress = Qnil;
+    invoker->rbEnums = Qnil;
+    invoker->rbReturnType = Qnil;
+    invoker->blocking = false;
+
+    return obj;
+}
+
+static void
+variadic_mark(VariadicInvoker *invoker)
+{
+    rb_gc_mark(invoker->rbEnums);
+    rb_gc_mark(invoker->rbAddress);
+    rb_gc_mark(invoker->rbReturnType);
+}
+
+static VALUE
+variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE rbReturnType, VALUE options)
+{
+    VariadicInvoker* invoker = NULL;
+    VALUE retval = Qnil;
+    VALUE convention = Qnil;
+    VALUE fixed = Qnil;
+#if defined(X86_WIN32)
+    VALUE rbConventionStr;
+#endif
+    int i;
+
+    Check_Type(options, T_HASH);
+    convention = rb_hash_aref(options, ID2SYM(rb_intern("convention")));
+
+    Data_Get_Struct(self, VariadicInvoker, invoker);
+    invoker->rbEnums = rb_hash_aref(options, ID2SYM(rb_intern("enums")));
+    invoker->rbAddress = rbFunction;
+    invoker->function = rbffi_AbstractMemory_Cast(rbFunction, rbffi_PointerClass)->address;
+    invoker->blocking = RTEST(rb_hash_aref(options, ID2SYM(rb_intern("blocking"))));
+
+#if defined(X86_WIN32)
+    rbConventionStr = rb_funcall2(convention, rb_intern("to_s"), 0, NULL);
+    invoker->abi = (RTEST(convention) && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0)
+            ? FFI_STDCALL : FFI_DEFAULT_ABI;
+#else
+    invoker->abi = FFI_DEFAULT_ABI;
+#endif
+
+    invoker->rbReturnType = rbffi_Type_Lookup(rbReturnType);
+    if (!RTEST(invoker->rbReturnType)) {
+        VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
+        rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
+    }
+
+    Data_Get_Struct(rbReturnType, Type, invoker->returnType);
+
+    invoker->paramCount = -1;
+
+    fixed = rb_ary_new2(RARRAY_LEN(rbParameterTypes) - 1);
+    for (i = 0; i < RARRAY_LEN(rbParameterTypes); ++i) {
+        VALUE entry = rb_ary_entry(rbParameterTypes, i);
+        VALUE rbType = rbffi_Type_Lookup(entry);
+        Type* type;
+
+        if (!RTEST(rbType)) {
+            VALUE typeName = rb_funcall2(entry, rb_intern("inspect"), 0, NULL);
+            rb_raise(rb_eTypeError, "Invalid parameter type (%s)", RSTRING_PTR(typeName));
+        }
+        Data_Get_Struct(rbType, Type, type);
+        if (type->nativeType != NATIVE_VARARGS) {
+            rb_ary_push(fixed, entry);
+        }
+    }
+    /*
+     * @fixed and @type_map are used by the parameter mangling ruby code
+     */
+    rb_iv_set(self, "@fixed", fixed);
+    rb_iv_set(self, "@type_map", rb_hash_aref(options, ID2SYM(rb_intern("type_map"))));
+
+    return retval;
+}
+
+static VALUE
+variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
+{
+    VariadicInvoker* invoker;
+    FFIStorage* params;
+    void* retval;
+    ffi_cif cif;
+    void** ffiValues;
+    ffi_type** ffiParamTypes;
+    ffi_type* ffiReturnType;
+    Type** paramTypes;
+    VALUE* argv;
+    int paramCount = 0, fixedCount = 0, i;
+    ffi_status ffiStatus;
+    rbffi_frame_t frame = { 0 };
+
+    Check_Type(parameterTypes, T_ARRAY);
+    Check_Type(parameterValues, T_ARRAY);
+
+    Data_Get_Struct(self, VariadicInvoker, invoker);
+    paramCount = (int) RARRAY_LEN(parameterTypes);
+    paramTypes = ALLOCA_N(Type *, paramCount);
+    ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
+    params = ALLOCA_N(FFIStorage, paramCount);
+    ffiValues = ALLOCA_N(void*, paramCount);
+    argv = ALLOCA_N(VALUE, paramCount);
+    retval = alloca(MAX(invoker->returnType->ffiType->size, FFI_SIZEOF_ARG));
+
+    for (i = 0; i < paramCount; ++i) {
+        VALUE rbType = rb_ary_entry(parameterTypes, i);
+        
+        if (!rb_obj_is_kind_of(rbType, rbffi_TypeClass)) {
+            rb_raise(rb_eTypeError, "wrong type.  Expected (FFI::Type)");
+        }
+        Data_Get_Struct(rbType, Type, paramTypes[i]);
+
+        switch (paramTypes[i]->nativeType) {
+            case NATIVE_INT8:
+            case NATIVE_INT16:
+            case NATIVE_INT32:
+                rbType = rb_const_get(rbffi_TypeClass, rb_intern("INT32"));
+                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                break;
+            case NATIVE_UINT8:
+            case NATIVE_UINT16:
+            case NATIVE_UINT32:
+                rbType = rb_const_get(rbffi_TypeClass, rb_intern("UINT32"));
+                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                break;
+            
+            case NATIVE_FLOAT32:
+                rbType = rb_const_get(rbffi_TypeClass, rb_intern("DOUBLE"));
+                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                break;
+
+            default:
+                break;
+        }
+        
+        
+        ffiParamTypes[i] = paramTypes[i]->ffiType;
+        if (ffiParamTypes[i] == NULL) {
+            rb_raise(rb_eArgError, "Invalid parameter type #%x", paramTypes[i]->nativeType);
+        }
+        argv[i] = rb_ary_entry(parameterValues, i);
+    }
+
+    ffiReturnType = invoker->returnType->ffiType;
+    if (ffiReturnType == NULL) {
+        rb_raise(rb_eArgError, "Invalid return type");
+    }
+
+    /*Get the number of fixed args from @fixed array*/
+    fixedCount = RARRAY_LEN(rb_iv_get(self, "@fixed"));
+
+#ifdef HAVE_FFI_PREP_CIF_VAR
+    ffiStatus = ffi_prep_cif_var(&cif, invoker->abi, fixedCount, paramCount, ffiReturnType, ffiParamTypes);
+#else
+    ffiStatus = ffi_prep_cif(&cif, invoker->abi, paramCount, ffiReturnType, ffiParamTypes);
+#endif
+    switch (ffiStatus) {
+        case FFI_BAD_ABI:
+            rb_raise(rb_eArgError, "Invalid ABI specified");
+        case FFI_BAD_TYPEDEF:
+            rb_raise(rb_eArgError, "Invalid argument type specified");
+        case FFI_OK:
+            break;
+        default:
+            rb_raise(rb_eArgError, "Unknown FFI error");
+    }
+
+    rbffi_SetupCallParams(paramCount, argv, -1, paramTypes, params,
+        ffiValues, NULL, 0, invoker->rbEnums);
+    
+    rbffi_frame_push(&frame);
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+    /* In Call.c, blocking: true is supported on older ruby variants
+     * without rb_thread_call_without_gvl by allocating on the heap instead
+     * of the stack. Since this functionality is being added later,
+     * we’re skipping support for old rubies here. */
+    if(unlikely(invoker->blocking)) {
+        rbffi_blocking_call_t* bc;
+        bc = ALLOCA_N(rbffi_blocking_call_t, 1);
+        bc->retval = retval;
+        bc->function = invoker->function;
+        bc->ffiValues = ffiValues;
+        bc->params = params;
+        bc->frame = &frame;
+        bc->cif = cif;
+
+        rb_rescue2(rbffi_do_blocking_call, (VALUE) bc, rbffi_save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
+    } else {
+        ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
+    }
+#else
+    ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
+#endif
+    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);
+}
+
+
+void
+rbffi_Variadic_Init(VALUE moduleFFI)
+{
+    classVariadicInvoker = rb_define_class_under(moduleFFI, "VariadicInvoker", rb_cObject);
+    rb_global_variable(&classVariadicInvoker);
+
+    rb_define_alloc_func(classVariadicInvoker, variadic_allocate);
+
+    rb_define_method(classVariadicInvoker, "initialize", variadic_initialize, 4);
+    rb_define_method(classVariadicInvoker, "invoke", variadic_invoke, 2);
+}
+