ffi 0.3.1 → 0.4.0

data/ext/ffi_c/Struct.c

@@ -33,11 +33,11 @@ static void struct_mark(Struct *);
 static void struct_layout_mark(StructLayout *);
 static inline MemoryOp* ptr_get_op(AbstractMemory* ptr, int type);
 
-VALUE rb_FFI_Struct_class = Qnil;
-static VALUE classStruct = Qnil, classStructLayout = Qnil;
-static VALUE classStructField = Qnil, classStructLayoutBuilder = Qnil;
-static ID pointerID = 0, layoutID = 0, SIZE_ID, ALIGN_ID;
-static ID getID = 0, putID = 0, to_ptr = 0;
+VALUE rbffi_StructClass = Qnil;
+static VALUE StructLayoutClass = Qnil;
+static VALUE StructFieldClass = Qnil, StructLayoutBuilderClass = Qnil;
+static ID pointer_var_id = 0, layout_var_id = 0, SIZE_ID, ALIGN_ID, TYPE_ID;
+static ID get_id = 0, put_id = 0, to_ptr = 0, to_s = 0, layout_id = 0;
 
 static VALUE
 struct_field_allocate(VALUE klass)
@@ -58,15 +58,15 @@ struct_field_initialize(int argc, VALUE* argv, VALUE self)
     nargs = rb_scan_args(argc, argv, "11", &offset, &info);
     
     field->offset = NUM2UINT(offset);
-    if (rb_const_defined(CLASS_OF(self), rb_intern("TYPE"))) {
-        field->type = NUM2UINT(rb_const_get(CLASS_OF(self), rb_intern("TYPE")));
+    if (rb_const_defined(CLASS_OF(self), TYPE_ID)) {
+        field->type = NUM2UINT(rb_const_get(CLASS_OF(self), TYPE_ID));
     } else {
         field->type = ~0;
     }
 
 #ifdef notyet
-    field->size = NUM2UINT(rb_const_get(klass, rb_intern("SIZE")));
-    field->align = NUM2UINT(rb_const_get(klass, rb_intern("ALIGN")));
+    field->size = NUM2UINT(rb_const_get(klass, SIZE_ID));
+    field->align = NUM2UINT(rb_const_get(klass, ALIGN_ID));
 #endif
     rb_iv_set(self, "@off", offset);
     rb_iv_set(self, "@info", info);
@@ -151,14 +151,14 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
 
     /* Call up into ruby code to adjust the layout */
     if (nargs > 1) {
-        s->rbLayout = rb_funcall2(CLASS_OF(self), rb_intern("layout"), RARRAY_LEN(rest), RARRAY_PTR(rest));
-    } else if (rb_cvar_defined(klass, layoutID)) {
-        s->rbLayout = rb_cvar_get(klass, layoutID);
+        s->rbLayout = rb_funcall2(CLASS_OF(self), layout_id, RARRAY_LEN(rest), RARRAY_PTR(rest));
+    } else if (rb_cvar_defined(klass, layout_var_id)) {
+        s->rbLayout = rb_cvar_get(klass, layout_var_id);
     } else {
         rb_raise(rb_eRuntimeError, "No Struct layout configured");
     }
 
-    if (!rb_obj_is_kind_of(s->rbLayout, classStructLayout)) {
+    if (!rb_obj_is_kind_of(s->rbLayout, StructLayoutClass)) {
         rb_raise(rb_eRuntimeError, "Invalid Struct layout");
     }
 
@@ -168,7 +168,7 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
         s->pointer = MEMORY(rbPointer);
         s->rbPointer = rbPointer;
     } else {
-        s->rbPointer = rb_FFI_MemoryPointer_new(s->layout->size, 1, true);
+        s->rbPointer = rbffi_MemoryPointer_NewInstance(s->layout->size, 1, true);
         s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
     }
 
@@ -198,7 +198,7 @@ struct_field(Struct* s, VALUE fieldName)
 
     rbField = rb_hash_aref(layout->rbFields, fieldName);
     if (rbField == Qnil) {
-        VALUE str = rb_funcall2(fieldName, rb_intern("to_s"), 0, NULL);
+        VALUE str = rb_funcall2(fieldName, to_s, 0, NULL);
         rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
     }
 
@@ -259,7 +259,7 @@ struct_get_field(VALUE self, VALUE fieldName)
     }
     
     /* call up to the ruby code to fetch the value */
-    return rb_funcall2(rbField, getID, 1, &s->rbPointer);
+    return rb_funcall2(rbField, get_id, 1, &s->rbPointer);
 }
 
 static VALUE
@@ -284,7 +284,7 @@ struct_put_field(VALUE self, VALUE fieldName, VALUE value)
     /* call up to the ruby code to set the value */
     argv[0] = s->rbPointer;
     argv[1] = value;
-    rb_funcall2(rbField, putID, 2, argv);
+    rb_funcall2(rbField, put_id, 2, argv);
     
     return self;
 }
@@ -294,14 +294,14 @@ struct_set_pointer(VALUE self, VALUE pointer)
 {
     Struct* s;
 
-    if (!rb_obj_is_kind_of(pointer, rb_FFI_AbstractMemory_class)) {
+    if (!rb_obj_is_kind_of(pointer, rbffi_AbstractMemoryClass)) {
         rb_raise(rb_eArgError, "Invalid pointer");
     }
 
     Data_Get_Struct(self, Struct, s);
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
-    rb_ivar_set(self, pointerID, pointer);
+    rb_ivar_set(self, pointer_var_id, pointer);
 
     return self;
 }
@@ -322,12 +322,12 @@ struct_set_layout(VALUE self, VALUE layout)
     Struct* s;
     Data_Get_Struct(self, Struct, s);
 
-    if (!rb_obj_is_kind_of(layout, classStructLayout)) {
+    if (!rb_obj_is_kind_of(layout, StructLayoutClass)) {
         rb_raise(rb_eArgError, "Invalid Struct layout");
     }
 
     Data_Get_Struct(layout, StructLayout, s->layout);
-    rb_ivar_set(self, layoutID, layout);
+    rb_ivar_set(self, layout_var_id, layout);
 
     return self;
 }
@@ -373,7 +373,7 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
     for (i = 0; i < RARRAY_LEN(field_names); ++i) {
         VALUE name = RARRAY_PTR(field_names)[i];
         VALUE field = rb_hash_aref(fields, name);
-        if (TYPE(field) != T_DATA || !rb_obj_is_kind_of(field, classStructField)) {
+        if (TYPE(field) != T_DATA || !rb_obj_is_kind_of(field, StructFieldClass)) {
             rb_raise(rb_eArgError, "Invalid field");
         }
         rb_hash_aset(layout->rbFields, name, field);
@@ -399,57 +399,66 @@ struct_layout_mark(StructLayout *layout)
 }
 
 void
-rb_FFI_Struct_Init()
+rbffi_Struct_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    VALUE klass;
-    rb_FFI_Struct_class = classStruct = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
-    classStructLayout = rb_define_class_under(moduleFFI, "StructLayout", rb_cObject);
-    classStructLayoutBuilder = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
-    classStructField = rb_define_class_under(classStructLayoutBuilder, "Field", rb_cObject);
-
-    rb_define_alloc_func(classStruct, struct_allocate);
-    rb_define_method(classStruct, "initialize", struct_initialize, -1);
+    VALUE klass, StructClass;
+    rbffi_StructClass = StructClass = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
+    rb_global_variable(&rbffi_StructClass);
+
+    StructLayoutClass = rb_define_class_under(moduleFFI, "StructLayout", rb_cObject);
+    rb_global_variable(&StructLayoutClass);
+
+    StructLayoutBuilderClass = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
+    rb_global_variable(&StructLayoutBuilderClass);
+
+    StructFieldClass = rb_define_class_under(StructLayoutBuilderClass, "Field", rb_cObject);
+    rb_global_variable(&StructFieldClass);
+
+    rb_define_alloc_func(StructClass, struct_allocate);
+    rb_define_method(StructClass, "initialize", struct_initialize, -1);
     
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_in", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_out", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_inout", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_in", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_out", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_inout", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_in", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_out", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_inout", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_in", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_out", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_inout", "new");
 
-    rb_define_method(classStruct, "pointer", struct_get_pointer, 0);
-    rb_define_private_method(classStruct, "pointer=", struct_set_pointer, 1);
+    rb_define_method(StructClass, "pointer", struct_get_pointer, 0);
+    rb_define_private_method(StructClass, "pointer=", struct_set_pointer, 1);
 
-    rb_define_method(classStruct, "layout", struct_get_layout, 0);
-    rb_define_private_method(classStruct, "layout=", struct_set_layout, 1);
+    rb_define_method(StructClass, "layout", struct_get_layout, 0);
+    rb_define_private_method(StructClass, "layout=", struct_set_layout, 1);
 
-    rb_define_method(classStruct, "[]", struct_get_field, 1);
-    rb_define_method(classStruct, "[]=", struct_put_field, 2);
+    rb_define_method(StructClass, "[]", struct_get_field, 1);
+    rb_define_method(StructClass, "[]=", struct_put_field, 2);
     
-    rb_define_alloc_func(classStructField, struct_field_allocate);
-    rb_define_method(classStructField, "initialize", struct_field_initialize, -1);
-    rb_define_method(classStructField, "offset", struct_field_offset, 0);
-    rb_define_method(classStructField, "put", struct_field_put, 2);
-    rb_define_method(classStructField, "get", struct_field_get, 1);
-
-    rb_define_alloc_func(classStructLayout, struct_layout_allocate);
-    rb_define_method(classStructLayout, "initialize", struct_layout_initialize, 4);
-    rb_define_method(classStructLayout, "[]", struct_layout_aref, 1);
-
-    pointerID = rb_intern("@pointer");
-    layoutID = rb_intern("@layout");
-    getID = rb_intern("get");
-    putID = rb_intern("put");
+    rb_define_alloc_func(StructFieldClass, struct_field_allocate);
+    rb_define_method(StructFieldClass, "initialize", struct_field_initialize, -1);
+    rb_define_method(StructFieldClass, "offset", struct_field_offset, 0);
+    rb_define_method(StructFieldClass, "put", struct_field_put, 2);
+    rb_define_method(StructFieldClass, "get", struct_field_get, 1);
+
+    rb_define_alloc_func(StructLayoutClass, struct_layout_allocate);
+    rb_define_method(StructLayoutClass, "initialize", struct_layout_initialize, 4);
+    rb_define_method(StructLayoutClass, "[]", struct_layout_aref, 1);
+
+    pointer_var_id = rb_intern("@pointer");
+    layout_var_id = rb_intern("@layout");
+    layout_id = rb_intern("layout");
+    get_id = rb_intern("get");
+    put_id = rb_intern("put");
     to_ptr = rb_intern("to_ptr");
+    to_s = rb_intern("to_s");
     SIZE_ID = rb_intern("SIZE");
     ALIGN_ID = rb_intern("ALIGN");
+    TYPE_ID = rb_intern("TYPE");
 #undef FIELD
 #define FIELD(name, typeName, nativeType, T) do { \
     typedef struct { char c; T v; } s; \
-        klass = rb_define_class_under(classStructLayoutBuilder, #name, classStructField); \
-        rb_define_const(klass, "ALIGN", INT2NUM((sizeof(s) - sizeof(T)) * 8)); \
-        rb_define_const(klass, "SIZE", INT2NUM(sizeof(T)* 8)); \
+        klass = rb_define_class_under(StructLayoutBuilderClass, #name, StructFieldClass); \
+        rb_define_const(klass, "ALIGN", INT2NUM((sizeof(s) - sizeof(T)))); \
+        rb_define_const(klass, "SIZE", INT2NUM(sizeof(T))); \
         rb_define_const(klass, "TYPE", INT2NUM(nativeType)); \
     } while(0)
     

data/ext/ffi_c/Struct.h

@@ -7,7 +7,7 @@
 extern "C" {
 #endif
 
-    void rb_FFI_Struct_Init();
+    extern void rbffi_Struct_Init(VALUE ffiModule);
 
     struct StructLayout;
     typedef struct Struct {
@@ -17,7 +17,7 @@ extern "C" {
         VALUE rbPointer;
     } Struct;
 
-    extern VALUE rb_FFI_Struct_class;
+    extern VALUE rbffi_StructClass;
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/Type.c

@@ -0,0 +1,230 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#include <ruby.h>
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+#include "Types.h"
+#include "Type.h"
+
+
+typedef struct BuiltinType_ {
+    Type type;
+    char* name;
+} BuiltinType;
+
+static void builtin_type_free(BuiltinType *);
+
+VALUE rbffi_TypeClass = Qnil;
+
+static VALUE classBuiltinType = Qnil;
+
+static VALUE
+type_allocate(VALUE klass)
+{
+    Type* type;
+    VALUE obj = Data_Make_Struct(klass, Type, NULL, -1, type);
+
+    type->nativeType = -1;
+    type->size = 0;
+    type->alignment = 1;
+
+    return obj;
+}
+
+static VALUE
+type_initialize(VALUE self, VALUE value)
+{
+    Type* type;
+    Type* other;
+
+    Data_Get_Struct(self, Type, type);
+
+    if (FIXNUM_P(value)) {
+        type->nativeType = FIX2INT(value);
+    } else if (rb_obj_is_kind_of(value, rbffi_TypeClass)) {
+        Data_Get_Struct(value, Type, other);
+        type->nativeType = other->nativeType;
+        type->size = other->size;
+        type->alignment = other->alignment;
+    } else {
+        rb_raise(rb_eArgError, "wrong type");
+    }
+    
+    return self;
+}
+
+static VALUE
+type_size(VALUE self)
+{
+    Type *type;
+
+    Data_Get_Struct(self, Type, type);
+
+    return INT2FIX(type->size);
+}
+
+static VALUE
+type_alignment(VALUE self)
+{
+    Type *type;
+
+    Data_Get_Struct(self, Type, type);
+
+    return INT2FIX(type->alignment);
+}
+
+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, type->size, type->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;
+    type->size = ffi_type_sint.size;
+    type->alignment = ffi_type_sint.alignment;
+
+    return obj;
+}
+
+int
+rbffi_Type_GetIntValue(VALUE type)
+{
+    if (rb_obj_is_kind_of(type, rbffi_TypeClass)) {
+        Type* t;
+        Data_Get_Struct(type, Type, t);
+        return t->nativeType;
+    } else {
+        rb_raise(rb_eArgError, "Invalid type argument");
+    }
+}
+
+static VALUE
+builtin_type_new(VALUE klass, int nativeType, ffi_type* ffiType, const char* name)
+{
+    BuiltinType* type;
+    VALUE obj = Data_Make_Struct(klass, BuiltinType, NULL, builtin_type_free, type);
+    
+    type->name = strdup(name);
+    type->type.nativeType = nativeType;
+    type->type.ffiType = ffiType;
+    type->type.size = ffiType->size;
+    type->type.alignment = ffiType->alignment;
+
+    return obj;
+}
+
+static void
+builtin_type_free(BuiltinType *type)
+{
+    free(type->name);
+    xfree(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:%ssize=%d alignment=%d>",
+            type->name, type->type.size, type->type.alignment);
+
+    return rb_str_new2(buf);
+}
+
+void
+rbffi_Type_Init(VALUE moduleFFI)
+{
+    VALUE moduleNativeType;
+    VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
+    VALUE classEnum =  rb_define_class_under(moduleFFI, "Enum", classType);
+    classBuiltinType = rb_define_class_under(rbffi_TypeClass, "Builtin", rbffi_TypeClass);
+    moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
+
+    rb_global_variable(&rbffi_TypeClass);
+    rb_global_variable(&classBuiltinType);
+    rb_global_variable(&moduleNativeType);
+
+    rb_define_alloc_func(classType, type_allocate);
+    rb_define_method(classType, "initialize", type_initialize, 1);
+    rb_define_method(classType, "size", type_size, 0);
+    rb_define_method(classType, "alignment", type_alignment, 0);
+    rb_define_method(classBuiltinType, "inspect", type_inspect, 0);
+
+    // 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);
+
+    // Define all the builtin types
+    #define T(x, ffiType) do { \
+        VALUE t = Qnil; \
+        rb_define_const(classType, #x, t = builtin_type_new(classBuiltinType, NATIVE_##x, ffiType, #x)); \
+        rb_define_const(moduleNativeType, #x, t); \
+        rb_define_const(moduleFFI, "TYPE_" #x, t); \
+    } while(0)
+
+    T(VOID, &ffi_type_void);
+    T(INT8, &ffi_type_sint8);
+    T(UINT8, &ffi_type_uint8);
+    T(INT16, &ffi_type_sint16);
+    T(UINT16, &ffi_type_uint16);
+    T(INT32, &ffi_type_sint32);
+    T(UINT32, &ffi_type_uint32);
+    T(INT64, &ffi_type_sint64);
+    T(UINT64, &ffi_type_uint64);
+    T(FLOAT32, &ffi_type_float);
+    T(FLOAT64, &ffi_type_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_sint);
+
+
+    T(CHAR_ARRAY, &ffi_type_void);
+    T(VARARGS, &ffi_type_void);
+    
+
+    if (sizeof(long) == 4) {
+        VALUE t = Qnil;
+        rb_define_const(classType, "LONG", t = builtin_type_new(classBuiltinType, NATIVE_INT32, &ffi_type_slong, "LONG"));
+        rb_define_const(moduleNativeType, "LONG", t);
+        rb_define_const(moduleFFI, "TYPE_LONG", t);
+        rb_define_const(classType, "ULONG", t = builtin_type_new(classBuiltinType, NATIVE_UINT32, &ffi_type_slong, "ULONG"));
+        rb_define_const(moduleNativeType, "ULONG", t);
+        rb_define_const(moduleFFI, "TYPE_ULONG", t);
+    } else {
+        VALUE t = Qnil;
+        rb_define_const(classType, "LONG", t = builtin_type_new(classBuiltinType, NATIVE_INT64, &ffi_type_slong, "LONG"));
+        rb_define_const(moduleNativeType, "LONG", t);
+        rb_define_const(moduleFFI, "TYPE_LONG", t);
+        rb_define_const(classType, "ULONG", t = builtin_type_new(classBuiltinType, NATIVE_UINT64, &ffi_type_slong, "ULONG"));
+        rb_define_const(moduleNativeType, "ULONG", t);
+        rb_define_const(moduleFFI, "TYPE_ULONG", t);
+    }
+}

data/ext/ffi_c/Type.h

@@ -0,0 +1,28 @@
+#ifndef _TYPE_H
+#define	_TYPE_H
+
+#include <ruby.h>
+#include <ffi.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    
+typedef struct Type_ {
+    NativeType nativeType;
+    ffi_type* ffiType;
+    int size;
+    int alignment;
+} Type;
+
+extern VALUE rbffi_TypeClass;
+extern int rbffi_Type_GetIntValue(VALUE type);
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _TYPE_H */
+

data/ext/ffi_c/Types.c

@@ -1,9 +1,13 @@
 #include <ruby.h>
 #include "Pointer.h"
+#include "rbffi.h"
+#include "Callback.h"
 #include "Types.h"
 
+static ID id_find = 0;
+
 ffi_type*
-rb_FFI_NativeTypeToFFI(NativeType type)
+rbffi_NativeType_ToFFI(NativeType type)
 {
     switch (type) {
         case NATIVE_VOID:
@@ -16,7 +20,9 @@ rb_FFI_NativeTypeToFFI(NativeType type)
             return &ffi_type_sint16;
         case NATIVE_UINT16:
             return &ffi_type_uint16;
+        case NATIVE_BOOL:
         case NATIVE_INT32:
+        case NATIVE_ENUM:
             return &ffi_type_sint32;
         case NATIVE_UINT32:
             return &ffi_type_uint32;
@@ -34,6 +40,7 @@ rb_FFI_NativeTypeToFFI(NativeType type)
         case NATIVE_BUFFER_IN:
         case NATIVE_BUFFER_OUT:
         case NATIVE_BUFFER_INOUT:
+        case NATIVE_CALLBACK:
             return &ffi_type_pointer;
         default:
             return NULL;
@@ -41,9 +48,9 @@ rb_FFI_NativeTypeToFFI(NativeType type)
 }
 
 VALUE
-rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
+rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
 {
-    switch (type) {
+    switch (type->nativeType) {
         case NATIVE_VOID:
             return Qnil;
         case NATIVE_INT8:
@@ -67,10 +74,45 @@ rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
         case NATIVE_FLOAT64:
             return rb_float_new(*(double *) ptr);
         case NATIVE_STRING:
-            return rb_tainted_str_new2(*(char **) ptr);
+            return (*(char **)ptr) ? rb_tainted_str_new2(*(char **) ptr) : Qnil;
         case NATIVE_POINTER:
-            return rb_FFI_Pointer_new(*(void **) ptr);
+            return rbffi_Pointer_NewInstance(*(void **) ptr);
+        case NATIVE_BOOL:
+            return ((int) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
+        case NATIVE_ENUM:
+        {
+            VALUE enum_obj = rb_funcall(enums, id_find, 1, rbType);
+            if (enum_obj == Qnil) {
+                VALUE s = rb_inspect(rbType);
+                rb_raise(rb_eRuntimeError, "Unknown enumeration: %s", StringValueCStr(s));
+            }
+            return rb_funcall(enum_obj, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
+        }
+        case NATIVE_CALLBACK: {
+            CallbackInfo* cbInfo;
+            VALUE argv[6];
+            VALUE funcptr = rbffi_Pointer_NewInstance(*(void **) ptr);
+
+            Data_Get_Struct(rbType, CallbackInfo, cbInfo);
+            argv[0] = funcptr;
+            argv[1] = cbInfo->rbParameterTypes;
+            argv[2] = ID2SYM(rb_intern("cb")); // just shove a dummy value
+            argv[3] = cbInfo->rbReturnType;
+            argv[4] = rb_str_new2("default");
+            argv[5] = Qnil;
+
+            return rb_class_new_instance(6, argv, rbffi_InvokerClass);
+        }
+
         default:
-            rb_raise(rb_eRuntimeError, "Unknown type: %d", type);
+            rb_raise(rb_eRuntimeError, "Unknown type: %d", type->nativeType);
+            return Qnil;
     }
 }
+
+void
+rbffi_Types_Init(VALUE moduleFFI)
+{
+    id_find = rb_intern("find");
+}
+

data/ext/ffi_c/Types.h

@@ -25,6 +25,7 @@ typedef enum {
     NATIVE_BUFFER_OUT,
     NATIVE_BUFFER_INOUT,
     NATIVE_CHAR_ARRAY,
+    NATIVE_BOOL,
     
     /**
      * An immutable string.  Nul terminated, but only copies in to the native function
@@ -34,11 +35,16 @@ typedef enum {
     NATIVE_RBXSTRING,
     /** The function takes a variable number of arguments */
     NATIVE_VARARGS,
+    /** A typedef-ed enum */
+    NATIVE_ENUM,
 } NativeType;
 
 #include <ffi.h>
-extern ffi_type* rb_FFI_NativeTypeToFFI(NativeType type);
-VALUE rb_FFI_NativeValueToRuby(NativeType type, const void* ptr);
+#include "Type.h"
+
+extern ffi_type* rbffi_NativeType_ToFFI(NativeType type);
+VALUE rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums);
+void rbffi_Types_Init(VALUE moduleFFI);
 
 #ifdef	__cplusplus
 }

data/ext/ffi_c/endian.h

@@ -0,0 +1,40 @@
+#ifndef JFFI_ENDIAN_H
+#define JFFI_ENDIAN_H
+
+#include <sys/param.h>
+#include <sys/types.h>
+
+#ifdef __linux__
+#  include_next <endian.h>
+#endif
+
+#ifdef __sun
+# include <sys/byteorder.h>
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# if defined(_BIG_ENDIAN)
+#  define BYTE_ORDER BIG_ENDIAN
+# elif defined(_LITTLE_ENDIAN)
+#  define BYTE_ORDER LITTLE_ENDIAN
+# else
+#  error "Cannot determine endian-ness"
+# endif
+#endif
+
+#if defined(_AIX) && !defined(BYTE_ORDER)
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# if defined(__BIG_ENDIAN__)
+#  define BYTE_ORDER BIG_ENDIAN
+# elif defined(__LITTLE_ENDIAN__)
+#  define BYTE_ORDER LITTLE_ENDIAN
+# else
+#  error "Cannot determine endian-ness"
+# endif
+#endif
+
+#if !defined(BYTE_ORDER) || !defined(LITTLE_ENDIAN) || !defined(BIG_ENDIAN)
+#  error "Cannot determine the endian-ness of this platform"
+#endif
+
+#endif /* JFFI_ENDIAN_H */