ffi 0.4.0 → 0.5.0

data/ext/ffi_c/Variadic.c

@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * 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.
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#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"
+
+typedef struct VariadicInvoker_ {
+    VALUE rbAddress;
+    VALUE rbReturnType;
+    VALUE rbEnums;
+
+    Type* returnType;
+    ffi_abi abi;
+    void* function;
+    int paramCount;
+} 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;
+
+    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;
+    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;
+
+#if defined(_WIN32) || defined(__WIN32__)
+    VALUE 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 inline VALUE
+ffi_invoke(ffi_cif* cif, void* function, Type* returnType, void** ffiValues,
+    VALUE rbReturnType, VALUE rbEnums)
+{
+    FFIStorage retval;
+
+#ifdef USE_RAW
+    ffi_raw_call(cif, function, &retval, (ffi_raw *) ffiValues[0]);
+#else
+    ffi_call(cif, function, &retval, ffiValues);
+#endif
+    rbffi_save_errno();
+
+    return rbffi_NativeValue_ToRuby(returnType, rbReturnType, &retval, rbEnums);
+}
+
+static VALUE
+variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
+{
+    VariadicInvoker* invoker;
+    FFIStorage* params;
+    ffi_cif cif;
+    void** ffiValues;
+    ffi_type** ffiParamTypes;
+    ffi_type* ffiReturnType;
+    NativeType* paramTypes;
+    VALUE* argv;
+    int paramCount = 0, i;
+    ffi_status ffiStatus;
+
+    Check_Type(parameterTypes, T_ARRAY);
+    Check_Type(parameterValues, T_ARRAY);
+
+    Data_Get_Struct(self, VariadicInvoker, invoker);
+    paramCount = RARRAY_LEN(parameterTypes);
+    paramTypes = ALLOCA_N(NativeType, paramCount);
+    ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
+    params = ALLOCA_N(FFIStorage, paramCount);
+    ffiValues = ALLOCA_N(void*, paramCount);
+    argv = ALLOCA_N(VALUE, paramCount);
+
+    for (i = 0; i < paramCount; ++i) {
+        VALUE entry = rb_ary_entry(parameterTypes, i);
+        int paramType = rbffi_Type_GetIntValue(entry);
+        Type* type;
+        Data_Get_Struct(entry, Type, type);
+
+        switch (paramType) {
+            case NATIVE_INT8:
+            case NATIVE_INT16:
+            case NATIVE_INT32:
+            case NATIVE_ENUM:
+                paramType = NATIVE_INT32;
+                ffiParamTypes[i] = &ffi_type_sint;
+                break;
+            case NATIVE_UINT8:
+            case NATIVE_UINT16:
+            case NATIVE_UINT32:
+                paramType = NATIVE_UINT32;
+                ffiParamTypes[i] = &ffi_type_uint;
+                break;
+            case NATIVE_FLOAT32:
+                paramType = NATIVE_FLOAT64;
+                ffiParamTypes[i] = &ffi_type_double;
+                break;
+            default:
+                ffiParamTypes[i] = type->ffiType;
+                break;
+        }
+        paramTypes[i] = paramType;
+        if (ffiParamTypes[i] == NULL) {
+            rb_raise(rb_eArgError, "Invalid parameter type #%x", paramType);
+        }
+        argv[i] = rb_ary_entry(parameterValues, i);
+    }
+
+    ffiReturnType = invoker->returnType->ffiType;
+    if (ffiReturnType == NULL) {
+        rb_raise(rb_eArgError, "Invalid return type");
+    }
+    ffiStatus = ffi_prep_cif(&cif, invoker->abi, paramCount, ffiReturnType, ffiParamTypes);
+    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);
+
+    return ffi_invoke(&cif, invoker->function, invoker->returnType,
+        ffiValues, invoker->rbReturnType, invoker->rbEnums);
+}
+
+
+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);
+}
+

data/ext/ffi_c/compat.h

@@ -1,22 +1,72 @@
-#ifndef FFI_COMPAT_H
-#define FFI_COMPAT_H
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * 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.
+ */
+
+#ifndef RBFFI_COMPAT_H
+#define RBFFI_COMPAT_H
 
 #include <ruby.h>
 
 #ifndef RARRAY_LEN
 #  define RARRAY_LEN(ary) RARRAY(ary)->len
 #endif
+
 #ifndef RARRAY_PTR
 #  define RARRAY_PTR(ary) RARRAY(ary)->ptr
 #endif
+
 #ifndef RSTRING_LEN
 #  define RSTRING_LEN(s) RSTRING(s)->len
 #endif
+
 #ifndef RSTRING_PTR
 #  define RSTRING_PTR(s) RSTRING(s)->ptr
 #endif
+
 #ifndef NUM2ULL
 #  define NUM2ULL(x) rb_num2ull((VALUE)x)
 #endif
 
-#endif /* FFI_COMPAT_H */
+#ifndef roundup
+#  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
+#endif
+
+#ifdef __GNUC__
+#  define likely(x) __builtin_expect((x), 1)
+#  define unlikely(x) __builtin_expect((x), 0)
+#else
+#  define likely(x) (x)
+#  define unlikely(x) (x)
+#endif
+
+#ifndef MAX
+#  define MAX(a, b) ((a) < (b) ? (b) : (a))
+#endif
+#ifndef MIN
+#  define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+#endif /* RBFFI_COMPAT_H */

data/ext/ffi_c/extconf.rb

@@ -2,24 +2,23 @@
 require 'mkmf'
 require 'rbconfig'
 dir_config("ffi_c")
-#IS_MAC = Config::CONFIG['host_os'] =~ /^darwin/
-#if IS_MAC
-#  $CPPFLAGS << " -DMACOSX"
-#  find_header("ffi.h", "/usr/include/ffi")
-#end
+
+IS_MAC = Config::CONFIG['host_os'] =~ /^darwin/
 have_closure_alloc = have_library("ffi", "ffi_closure_alloc", [ "ffi.h" ])
 $defs.push("-DHAVE_FFI_CLOSURE_ALLOC") if have_closure_alloc
-libffi_ok = have_closure_alloc
+libffi_ok = have_closure_alloc && !IS_MAC
 $defs << "-DHAVE_LIBFFI" if libffi_ok
 $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
 
+have_func('rb_thread_blocking_region')
+
 create_makefile("ffi_c")
 create_header("extconf.h")
 File.open("Makefile", "a") do |mf|
   mf.puts "CPPFLAGS += -Werror -Wunused -Wformat -Wimplicit -Wreturn-type"
   unless libffi_ok 
     mf.puts "LIBFFI_HOST=--host=#{Config::CONFIG['host_alias']}" if Config::CONFIG.has_key?("host_alias")
-    mf.puts "FFI_MMAP_EXEC=-DFFI_MMAP_EXEC_WRIT=#{Config::CONFIG['host_os'] =~ /win/ ? 0 : 1}"
+    mf.puts "FFI_MMAP_EXEC=-DFFI_MMAP_EXEC_WRIT=#{Config::CONFIG['host_os'] =~ /(win32|mingw)/ ? 0 : 1}"
     if Config::CONFIG['host_os'].downcase =~ /darwin/
       mf.puts "include ${srcdir}/libffi.darwin.mk"
     elsif Config::CONFIG['host_os'].downcase =~ /bsd/

data/ext/ffi_c/ffi.c

@@ -1,3 +1,30 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * 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.
+ */
+
 #include <sys/types.h>
 #include <stdio.h>
 #include <ruby.h>
@@ -10,67 +37,46 @@
 #include "MemoryPointer.h"
 #include "AutoPointer.h"
 #include "Struct.h"
-#include "Callback.h"
+#include "StructByValue.h"
 #include "DynamicLibrary.h"
 #include "Platform.h"
 #include "Types.h"
 #include "LastError.h"
+#include "Function.h"
+#include "ClosurePool.h"
+#include "MethodHandle.h"
+#include "Call.h"
+#include "ArrayType.h"
 
+void Init_ffi_c(void);
 
-void Init_ffi_c();
+VALUE rbffi_FFIModule = Qnil;
 
 static VALUE moduleFFI = Qnil;
-static VALUE typeMap = Qnil, sizeMap = Qnil;
-static ID type_size_id = 0, size_id;
-
-int
-rbffi_type_size(VALUE type)
-{
-    int t = TYPE(type);
-    if (t == T_FIXNUM || t == T_BIGNUM) {
-        return NUM2INT(type);
-    } else if (t == T_SYMBOL) {
-        /*
-         * Try looking up directly in the type and size maps
-         */
-        VALUE nType;
-        if ((nType = rb_hash_aref(typeMap, type)) != Qnil) {
-            VALUE nSize = rb_hash_aref(sizeMap, nType);
-            if (TYPE(nSize) == T_FIXNUM) {
-                return FIX2INT(nSize);
-            }
-        }
-        // Not found - call up to the ruby version to resolve
-        return NUM2INT(rb_funcall2(moduleFFI, type_size_id, 1, &type));
-    } else {
-        return NUM2INT(rb_funcall2(type, size_id, 0, NULL));
-    }
-}
 
 void
-Init_ffi_c() {
-    moduleFFI = rb_define_module("FFI");
+Init_ffi_c(void) {
+    rbffi_FFIModule = moduleFFI = rb_define_module("FFI");
     rb_global_variable(&moduleFFI);
-    rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
-    rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
-    rb_global_variable(&typeMap);
-    rb_global_variable(&sizeMap);
-    type_size_id = rb_intern("type_size");
-    size_id = rb_intern("size");
 
+    // FFI::Type needs to be initialized before most other classes
     rbffi_Type_Init(moduleFFI);
+    rbffi_ArrayType_Init(moduleFFI);
     rbffi_LastError_Init(moduleFFI);
+    rbffi_Call_Init(moduleFFI);
+    rbffi_ClosurePool_Init(moduleFFI);
+    rbffi_MethodHandle_Init(moduleFFI);
     rbffi_Platform_Init(moduleFFI);
     rbffi_AbstractMemory_Init(moduleFFI);
     rbffi_Pointer_Init(moduleFFI);
     rbffi_AutoPointer_Init(moduleFFI);
-    rbffi_NullPointer_Init(moduleFFI);
+    rbffi_Function_Init(moduleFFI);
     rbffi_MemoryPointer_Init(moduleFFI);
     rbffi_Buffer_Init(moduleFFI);
-    rbffi_Callback_Init(moduleFFI);
+    rbffi_StructByValue_Init(moduleFFI);
     rbffi_Struct_Init(moduleFFI);
     rbffi_DynamicLibrary_Init(moduleFFI);
-    rbffi_Invoker_Init(moduleFFI);
+    rbffi_Variadic_Init(moduleFFI);
     rbffi_Types_Init(moduleFFI);
 }