ffi 0.6.0 → 1.0.0

data/ext/ffi_c/StructByReference.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 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_STRUCTBYREFERENCE_H
+#define	RBFFI_STRUCTBYREFERENCE_H
+
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct StructByReference_ {
+    VALUE rbStructClass;
+} StructByReference;
+
+void rbffi_StructByReference_Init(VALUE moduleFFI);
+
+extern VALUE rbffi_StructByReferenceClass;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_STRUCTBYREFERENCE_H */
+

data/ext/ffi_c/StructLayout.c

@@ -52,6 +52,8 @@ static void struct_layout_free(StructLayout *);
 static void struct_field_mark(StructField* );
 
 VALUE rbffi_StructLayoutFieldClass = Qnil;
+VALUE rbffi_StructLayoutNumberFieldClass = Qnil, rbffi_StructLayoutPointerFieldClass = Qnil;
+VALUE rbffi_StructLayoutStringFieldClass = Qnil;
 VALUE rbffi_StructLayoutFunctionFieldClass = Qnil, rbffi_StructLayoutArrayFieldClass = Qnil;
 
 VALUE rbffi_StructLayoutClass = Qnil;
@@ -320,6 +322,7 @@ struct_layout_allocate(VALUE klass)
     layout->rbFieldMap = Qnil;
     layout->rbFieldNames = Qnil;
     layout->rbFields = Qnil;
+    layout->fieldSymbolTable = st_init_numtable();
     layout->base.ffiType = xcalloc(1, sizeof(*layout->base.ffiType));
     layout->base.ffiType->size = 0;
     layout->base.ffiType->alignment = 0;
@@ -329,29 +332,29 @@ struct_layout_allocate(VALUE klass)
 }
 
 static VALUE
-struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size, VALUE align)
+struct_layout_initialize(VALUE self, VALUE fields, VALUE size, VALUE align)
 {
     StructLayout* layout;
     ffi_type* ltype;
     int i;
 
     Data_Get_Struct(self, StructLayout, layout);
+    layout->fieldCount = RARRAY_LEN(fields);
     layout->rbFieldMap = rb_hash_new();
-    layout->rbFieldNames = rb_ary_dup(field_names);
+    layout->rbFieldNames = rb_ary_new2(layout->fieldCount);
     layout->size = NUM2INT(size);
     layout->align = NUM2INT(align);
-    layout->fieldCount = RARRAY_LEN(field_names);
     layout->fields = xcalloc(layout->fieldCount, sizeof(StructField *));
     layout->ffiTypes = xcalloc(layout->fieldCount + 1, sizeof(ffi_type *));
     layout->rbFields = rb_ary_new2(layout->fieldCount);
     layout->base.ffiType->elements = layout->ffiTypes;
-    layout->base.ffiType->size = 0;
-    layout->base.ffiType->alignment = 1;
+    layout->base.ffiType->size = layout->size;
+    layout->base.ffiType->alignment = layout->align;
 
     ltype = layout->base.ffiType;
     for (i = 0; i < (int) layout->fieldCount; ++i) {
-        VALUE rbName = rb_ary_entry(field_names, i);
-        VALUE rbField = rb_hash_aref(fields, rbName);
+        VALUE rbField = rb_ary_entry(fields, i);
+        VALUE rbName;
         StructField* field;
         ffi_type* ftype;
 
@@ -359,6 +362,7 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
         if (!rb_obj_is_kind_of(rbField, rbffi_StructLayoutFieldClass)) {
             rb_raise(rb_eTypeError, "wrong type for field %d.", i);
         }
+        rbName = rb_funcall2(rbField, rb_intern("name"), 0, NULL);
 
         Data_Get_Struct(rbField, StructField, field = layout->fields[i]);
 
@@ -371,20 +375,17 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
             rb_raise(rb_eTypeError, "type of field %d has zero size", i);
         }
 
-        rb_hash_aset(layout->rbFieldMap, rbName, rbField);
         layout->ffiTypes[i] = ftype;
+        st_insert(layout->fieldSymbolTable, rbName, rbField);
+        rb_hash_aset(layout->rbFieldMap, rbName, rbField);
         rb_ary_push(layout->rbFields, rbField);
-        ltype->size = MAX(ltype->size, field->offset + ftype->size);
-        ltype->alignment = MAX(ltype->alignment, ftype->alignment);
+        rb_ary_push(layout->rbFieldNames, rbName);
     }
 
     if (ltype->size == 0) {
         rb_raise(rb_eRuntimeError, "Struct size is zero");
     }
 
-    // Include tail padding
-    ltype->size = FFI_ALIGN(ltype->size, ltype->alignment);
-
     return self;
 }
 
@@ -442,6 +443,7 @@ struct_layout_free(StructLayout *layout)
     xfree(layout->ffiTypes);
     xfree(layout->base.ffiType);
     xfree(layout->fields);
+    st_free_table(layout->fieldSymbolTable);
     xfree(layout);
 }
 
@@ -455,6 +457,15 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rbffi_StructLayoutFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Field", rb_cObject);
     rb_global_variable(&rbffi_StructLayoutFieldClass);
 
+    rbffi_StructLayoutNumberFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Number", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutNumberFieldClass);
+
+    rbffi_StructLayoutStringFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "String", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutStringFieldClass);
+
+    rbffi_StructLayoutPointerFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Pointer", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutPointerFieldClass);
+
     rbffi_StructLayoutFunctionFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Function", rbffi_StructLayoutFieldClass);
     rb_global_variable(&rbffi_StructLayoutFunctionFieldClass);
 
@@ -478,7 +489,7 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rb_define_method(rbffi_StructLayoutArrayFieldClass, "put", array_field_put, 2);
 
     rb_define_alloc_func(rbffi_StructLayoutClass, struct_layout_allocate);
-    rb_define_method(rbffi_StructLayoutClass, "initialize", struct_layout_initialize, 4);
+    rb_define_method(rbffi_StructLayoutClass, "initialize", struct_layout_initialize, 3);
     rb_define_method(rbffi_StructLayoutClass, "[]", struct_layout_aref, 1);
     rb_define_method(rbffi_StructLayoutClass, "fields", struct_layout_fields, 0);
     rb_define_method(rbffi_StructLayoutClass, "members", struct_layout_members, 0);

data/ext/ffi_c/Type.c

@@ -1,28 +1,19 @@
 /*
  * Copyright (c) 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:
+ * This file is part of ruby-ffi.
  *
- * * 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 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 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 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/>.
  */
 
 #include <sys/param.h>
@@ -42,7 +33,7 @@ typedef struct BuiltinType_ {
 
 static void builtin_type_free(BuiltinType *);
 
-VALUE rbffi_TypeClass = Qnil, rbffi_EnumTypeClass = Qnil;
+VALUE rbffi_TypeClass = Qnil;
 
 static VALUE classBuiltinType = Qnil;
 static VALUE typeMap = Qnil, sizeMap = Qnil;
@@ -104,41 +95,12 @@ type_alignment(VALUE self)
 static VALUE
 type_inspect(VALUE self)
 {
-    char buf[256];
     Type *type;
 
     Data_Get_Struct(self, Type, type);
-    snprintf(buf, sizeof(buf), "#<FFI::Type:%p size=%d alignment=%d>", 
-            type, (int) type->ffiType->size, (int) type->ffiType->alignment);
-
-    return rb_str_new2(buf);
-}
-
-static VALUE
-enum_allocate(VALUE klass)
-{
-    Type* type;
-    VALUE obj;
-
-    obj = Data_Make_Struct(klass, Type, NULL, -1, type);
-    type->nativeType = NATIVE_ENUM;
-    type->ffiType = &ffi_type_sint;
-
-    return obj;
-}
-
-int
-rbffi_Type_GetIntValue(VALUE type)
-{
-    Type* t;
-
-    if (!rb_obj_is_kind_of(type, rbffi_TypeClass)) {
-        rb_raise(rb_eTypeError, "wrong type.  Expected (FFI::Type)");
-    }
-
-    Data_Get_Struct(type, Type, t);
 
-    return t->nativeType;
+    return rb_sprintf("#<%s:%p size=%d alignment=%d>",
+            rb_obj_classname(self), type, (int) type->ffiType->size, (int) type->ffiType->alignment);
 }
 
 static VALUE
@@ -166,14 +128,11 @@ builtin_type_free(BuiltinType *type)
 static VALUE
 builtin_type_inspect(VALUE self)
 {
-    char buf[256];
     BuiltinType *type;
 
     Data_Get_Struct(self, BuiltinType, type);
-    snprintf(buf, sizeof(buf), "#<FFI::Type::Builtin:%s size=%d alignment=%d>",
-            type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
-
-    return rb_str_new2(buf);
+    return rb_sprintf("#<%s:%s size=%d alignment=%d>",
+            rb_obj_classname(self), type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
 }
 
 int
@@ -231,8 +190,7 @@ rbffi_Type_Find(VALUE name)
     VALUE rbType = rbffi_Type_Lookup(name);
 
     if (!RTEST(rbType)) {
-        VALUE typeName = rb_funcall2(name, rb_intern("inspect"), 0, NULL);
-        rb_raise(rb_eTypeError, "Invalid type (%s)", RSTRING_PTR(typeName));
+        rb_raise(rb_eTypeError, "invalid type, %s", RSTRING_PTR(rb_inspect(name)));
     }
 
     return rbType;
@@ -243,7 +201,6 @@ rbffi_Type_Init(VALUE moduleFFI)
 {
     VALUE moduleNativeType;
     VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
-    VALUE classEnum = rbffi_EnumTypeClass = rb_define_class_under(moduleFFI, "Enum", classType);
 
     rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
     rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
@@ -270,9 +227,7 @@ rbffi_Type_Init(VALUE moduleFFI)
     // Make Type::Builtin non-allocatable
     rb_undef_method(CLASS_OF(classBuiltinType), "new");
     rb_define_method(classBuiltinType, "inspect", builtin_type_inspect, 0);
-
-    rb_define_alloc_func(classEnum, enum_allocate);
-
+    
     rb_global_variable(&rbffi_TypeClass);
     rb_global_variable(&classBuiltinType);
 
@@ -284,29 +239,45 @@ rbffi_Type_Init(VALUE moduleFFI)
         rb_define_const(moduleFFI, "TYPE_" #x, t); \
     } while(0)
 
+    #define A(old_type, new_type) do { \
+        VALUE t = rb_const_get(classType, rb_intern(#old_type)); \
+        rb_const_set(classType, rb_intern(#new_type), t); \
+    } while(0)
+
     T(VOID, &ffi_type_void);
     T(INT8, &ffi_type_sint8);
+    A(INT8, SCHAR);
+    A(INT8, CHAR);
     T(UINT8, &ffi_type_uint8);
+    A(UINT8, UCHAR);
+
     T(INT16, &ffi_type_sint16);
+    A(INT16, SHORT);
+    A(INT16, SSHORT);
     T(UINT16, &ffi_type_uint16);
+    A(UINT16, USHORT);
     T(INT32, &ffi_type_sint32);
+    A(INT32, INT);
+    A(INT32, SINT);
     T(UINT32, &ffi_type_uint32);
+    A(UINT32, UINT);
     T(INT64, &ffi_type_sint64);
+    A(INT64, LONG_LONG);
+    A(INT64, SLONG_LONG);
     T(UINT64, &ffi_type_uint64);
+    A(UINT64, ULONG_LONG);
     T(LONG, &ffi_type_slong);
+    A(LONG, SLONG);
     T(ULONG, &ffi_type_ulong);
     T(FLOAT32, &ffi_type_float);
+    A(FLOAT32, FLOAT);
     T(FLOAT64, &ffi_type_double);
+    A(FLOAT64, DOUBLE);
     T(POINTER, &ffi_type_pointer);
     T(STRING, &ffi_type_pointer);
-    T(RBXSTRING, &ffi_type_pointer);
     T(BUFFER_IN, &ffi_type_pointer);
     T(BUFFER_OUT, &ffi_type_pointer);
     T(BUFFER_INOUT, &ffi_type_pointer);
-    T(ENUM, &ffi_type_sint);
     T(BOOL, &ffi_type_uchar);
-
-
-    T(CHAR_ARRAY, &ffi_type_void);
     T(VARARGS, &ffi_type_void);
 }

data/ext/ffi_c/Type.h

@@ -1,28 +1,19 @@
 /*
  * Copyright (c) 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:
+ * This file is part of ruby-ffi.
  *
- * * 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 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 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 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/>.
  */
 
 #ifndef RBFFI_TYPE_H
@@ -44,8 +35,7 @@ struct Type_ {
     ffi_type* ffiType;
 };
 
-extern VALUE rbffi_TypeClass, rbffi_EnumTypeClass;
-extern int rbffi_Type_GetIntValue(VALUE type);
+extern VALUE rbffi_TypeClass;
 extern VALUE rbffi_Type_Lookup(VALUE type);
 extern VALUE rbffi_Type_Find(VALUE type);
 

data/ext/ffi_c/Types.c

@@ -34,9 +34,10 @@
 #include "StructByValue.h"
 #include "Types.h"
 #include "Struct.h"
+#include "MappedType.h"
 #include "MemoryPointer.h"
 
-static ID id_find = 0;
+static ID id_from_native = 0;
 
 
 VALUE
@@ -76,14 +77,15 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
         case NATIVE_POINTER:
             return rbffi_Pointer_NewInstance(*(void **) ptr);
         case NATIVE_BOOL:
-            return ((int) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
-        case NATIVE_ENUM:
-            return rb_funcall(rbType, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
+            return ((unsigned char) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
         
         case NATIVE_FUNCTION:
         case NATIVE_CALLBACK: {
-            return rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr));
+            return *(void **) ptr != NULL 
+                    ? rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr))
+                    : Qnil;
         }
+
         case NATIVE_STRUCT: {
             StructByValue* sbv = (StructByValue *)type;
             AbstractMemory* mem;
@@ -95,6 +97,19 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
             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;
+            VALUE values[2];
+
+            Data_Get_Struct(rbType, MappedType, m);
+            values[0] = rbffi_NativeValue_ToRuby(m->type, m->rbType, ptr, enums);
+            values[1] = Qnil;
+
+            return rb_funcall2(m->rbConverter, id_from_native, 2, values);
+        }
+    
         default:
             rb_raise(rb_eRuntimeError, "Unknown type: %d", type->nativeType);
             return Qnil;
@@ -104,6 +119,6 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
 void
 rbffi_Types_Init(VALUE moduleFFI)
 {
-    id_find = rb_intern("find");
+    id_from_native = rb_intern("from_native");
 }
 

data/ext/ffi_c/Types.h

@@ -57,20 +57,20 @@ typedef enum {
     NATIVE_CHAR_ARRAY,
     NATIVE_BOOL,
     
-    /**
-     * An immutable string.  Nul terminated, but only copies in to the native function
-     */
+    /** An immutable string.  Nul terminated, but only copies in to the native function */
     NATIVE_STRING,
-    /** A Rubinus :string arg - copies data both ways, and nul terminates */
-    NATIVE_RBXSTRING,
+    
     /** The function takes a variable number of arguments */
     NATIVE_VARARGS,
-    /** A typedef-ed enum */
-    NATIVE_ENUM,
+    
     /** Struct-by-value param or result */
     NATIVE_STRUCT,
+
     /** An array type definition */
     NATIVE_ARRAY,
+
+    /** Custom native type */
+    NATIVE_MAPPED,
 } NativeType;
 
 #include <ffi.h>

data/ext/ffi_c/Variadic.c

@@ -155,7 +155,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     void** ffiValues;
     ffi_type** ffiParamTypes;
     ffi_type* ffiReturnType;
-    NativeType* paramTypes;
+    Type** paramTypes;
     VALUE* argv;
     int paramCount = 0, i;
     ffi_status ffiStatus;
@@ -165,7 +165,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
 
     Data_Get_Struct(self, VariadicInvoker, invoker);
     paramCount = RARRAY_LEN(parameterTypes);
-    paramTypes = ALLOCA_N(NativeType, paramCount);
+    paramTypes = ALLOCA_N(Type *, paramCount);
     ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
     params = ALLOCA_N(FFIStorage, paramCount);
     ffiValues = ALLOCA_N(void*, paramCount);
@@ -173,36 +173,40 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     retval = alloca(MAX(invoker->returnType->ffiType->size, FFI_SIZEOF_ARG));
 
     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);
+        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 (paramType) {
+        switch (paramTypes[i]->nativeType) {
             case NATIVE_INT8:
             case NATIVE_INT16:
             case NATIVE_INT32:
-            case NATIVE_ENUM:
-                paramType = NATIVE_INT32;
-                ffiParamTypes[i] = &ffi_type_sint;
+                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:
-                paramType = NATIVE_UINT32;
-                ffiParamTypes[i] = &ffi_type_uint;
+                rbType = rb_const_get(rbffi_TypeClass, rb_intern("UINT32"));
+                Data_Get_Struct(rbType, Type, paramTypes[i]);
                 break;
+            
             case NATIVE_FLOAT32:
-                paramType = NATIVE_FLOAT64;
-                ffiParamTypes[i] = &ffi_type_double;
+                rbType = rb_const_get(rbffi_TypeClass, rb_intern("DOUBLE"));
+                Data_Get_Struct(rbType, Type, paramTypes[i]);
                 break;
+
             default:
-                ffiParamTypes[i] = type->ffiType;
                 break;
         }
-        paramTypes[i] = paramType;
+        
+        
+        ffiParamTypes[i] = paramTypes[i]->ffiType;
         if (ffiParamTypes[i] == NULL) {
-            rb_raise(rb_eArgError, "Invalid parameter type #%x", paramType);
+            rb_raise(rb_eArgError, "Invalid parameter type #%x", paramTypes[i]);
         }
         argv[i] = rb_ary_entry(parameterValues, i);
     }

data/ext/ffi_c/extconf.rb

@@ -15,9 +15,13 @@ unless Config::CONFIG['host_os'] =~ /mswin32|mingw32/
 end
 
 have_func('rb_thread_blocking_region')
+have_func('ruby_thread_has_gvl_p')
+have_func('ruby_native_thread_p')
+have_func('rb_thread_call_with_gvl')
 
 $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
 $defs << "-DUSE_INTERNAL_LIBFFI" unless libffi_ok
+$defs << "-DRUBY_1_9" if RUBY_VERSION >= "1.9.0"
 
 create_header
 

data/ext/ffi_c/ffi.c

@@ -35,9 +35,9 @@
 #include "AbstractMemory.h"
 #include "Pointer.h"
 #include "MemoryPointer.h"
-#include "AutoPointer.h"
 #include "Struct.h"
 #include "StructByValue.h"
+#include "StructByReference.h"
 #include "DynamicLibrary.h"
 #include "Platform.h"
 #include "Types.h"
@@ -47,6 +47,7 @@
 #include "MethodHandle.h"
 #include "Call.h"
 #include "ArrayType.h"
+#include "MappedType.h"
 
 void Init_ffi_c(void);
 
@@ -59,8 +60,12 @@ Init_ffi_c(void) {
     rbffi_FFIModule = moduleFFI = rb_define_module("FFI");
     rb_global_variable(&moduleFFI);
 
+
     // FFI::Type needs to be initialized before most other classes
     rbffi_Type_Init(moduleFFI);
+
+    rbffi_DataConverter_Init(moduleFFI);
+
     rbffi_ArrayType_Init(moduleFFI);
     rbffi_LastError_Init(moduleFFI);
     rbffi_Call_Init(moduleFFI);
@@ -69,14 +74,15 @@ Init_ffi_c(void) {
     rbffi_Platform_Init(moduleFFI);
     rbffi_AbstractMemory_Init(moduleFFI);
     rbffi_Pointer_Init(moduleFFI);
-    rbffi_AutoPointer_Init(moduleFFI);
     rbffi_Function_Init(moduleFFI);
     rbffi_MemoryPointer_Init(moduleFFI);
     rbffi_Buffer_Init(moduleFFI);
     rbffi_StructByValue_Init(moduleFFI);
+    rbffi_StructByReference_Init(moduleFFI);
     rbffi_Struct_Init(moduleFFI);
     rbffi_DynamicLibrary_Init(moduleFFI);
     rbffi_Variadic_Init(moduleFFI);
     rbffi_Types_Init(moduleFFI);
+    rbffi_MappedType_Init(moduleFFI);
 }
 

data/ext/ffi_c/libffi/configure

@@ -9021,7 +9021,7 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
       old_archive_from_new_cmds='true'
       # FIXME: Should let the user specify the lib program.
       old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
-      fix_srcfile_path='`cygpath -w "$srcfile"`'
+#      fix_srcfile_path='`cygpath -w "$srcfile"`'
       enable_shared_with_static_runtimes=yes
       ;;
 

data/ext/ffi_c/libffi.gnu.mk

@@ -14,7 +14,7 @@ LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi
 ifeq ($(srcdir),.)
   LIBFFI_SRC_DIR := $(shell pwd)/libffi
 else
-  LIBFFI_SRC_DIR := $(srcdir)/libffi
+  LIBFFI_SRC_DIR := $(abspath $(srcdir)/libffi)
 endif
 
 LIBFFI = $(LIBFFI_BUILD_DIR)/.libs/libffi_convenience.a

data/ext/ffi_c/libffi.mk

@@ -7,7 +7,7 @@ $(LIBFFI):
 	@if [ ! -f $(LIBFFI_BUILD_DIR)/Makefile ]; then \
 	    echo "Configuring libffi"; \
 	    cd $(LIBFFI_BUILD_DIR) && \
-		/usr/bin/env CC="$(CC)" LD="$(LD)" CFLAGS="$(LIBFFI_CFLAGS)" \
+		/usr/bin/env CFLAGS="$(LIBFFI_CFLAGS)" \
 		/bin/sh $(LIBFFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
 	fi
 	cd $(LIBFFI_BUILD_DIR) && $(MAKE)