ffi 0.3.0 → 0.4.0

data/ext/ffi_c/Buffer.c

@@ -18,14 +18,31 @@ static void buffer_release(Buffer* ptr);
 static void buffer_mark(Buffer* ptr);
 static VALUE buffer_free(VALUE self);
 
-static VALUE classBuffer = Qnil;
-#define BUFFER(obj)  ((Buffer *) rb_FFI_AbstractMemory_cast((obj), classBuffer))
+static VALUE BufferClass = Qnil;
+#define BUFFER(obj)  ((Buffer *) rbffi_AbstractMemory_Cast((obj), BufferClass))
 
 static VALUE
 buffer_allocate(VALUE klass)
 {
     Buffer* buffer;
-    return Data_Make_Struct(klass, Buffer, buffer_mark, buffer_release, buffer);
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
+    buffer->parent = Qnil;
+    buffer->memory.ops = &rbffi_AbstractMemoryOps;
+
+    return obj;
+}
+
+static void
+buffer_release(Buffer* ptr)
+{
+    if (ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+    
+    xfree(ptr);
 }
 
 static VALUE
@@ -33,28 +50,30 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
 {
     VALUE size = Qnil, count = Qnil, clear = Qnil;
     Buffer* p;
-    unsigned long msize;
-    void* memory;
     int nargs;
 
+    Data_Get_Struct(self, Buffer, p);
+
     nargs = rb_scan_args(argc, argv, "12", &size, &count, &clear);
-    msize = rb_FFI_type_size(size) * (nargs > 1 ? NUM2LONG(count) : 1);
-    memory = malloc(msize + 7);
-    if (memory == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", msize);
+    p->type_size = rbffi_type_size(size);
+    p->memory.size = p->type_size * (nargs > 1 ? NUM2LONG(count) : 1);
+
+    p->storage = malloc(p->memory.size + 7);
+    if (p->storage == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", p->memory.size);
     }
-    Data_Get_Struct(self, Buffer, p);
-    p->storage = memory;
-    p->memory.size = msize;
+
     /* ensure the memory is aligned on at least a 8 byte boundary */
-    p->memory.address = (void *) (((uintptr_t) memory + 0x7) & (uintptr_t) ~0x7UL);
-    p->parent = Qnil;
-    if (nargs > 2 && RTEST(clear) && p->memory.size > 0) {
+    p->memory.address = (void *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);
+    
+    if (nargs > 2 && (RTEST(clear) || clear == Qnil) && p->memory.size > 0) {
         memset(p->memory.address, 0, p->memory.size);
     }
+
     if (rb_block_given_p()) {
-        return rb_rescue(rb_yield, self, buffer_free, self);
+        return rb_ensure(rb_yield, self, buffer_free, self);
     }
+
     return self;
 }
 
@@ -73,18 +92,41 @@ buffer_plus(VALUE self, VALUE offset)
     long off = NUM2LONG(offset);
 
     checkBounds(&ptr->memory, off, 1);
-    retval = Data_Make_Struct(classBuffer, Buffer, buffer_mark, buffer_release, p);
-    p->memory.address = ptr->memory.address + off;;
+
+    retval = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, p);
+    p->memory.address = ptr->memory.address + off;
     p->memory.size = ptr->memory.size - off;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->parent = self;
+
     return retval;
 }
 
+static VALUE
+buffer_aref(VALUE self, VALUE offset)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+    return buffer_plus(self, INT2FIX(ptr->type_size * NUM2INT(offset)));
+}
+
+static VALUE
+buffer_type_size(VALUE self)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+    return INT2NUM(ptr->type_size);
+}
+
 static VALUE
 buffer_inspect(VALUE self)
 {
     char tmp[100];
+
     snprintf(tmp, sizeof(tmp), "#<Buffer size=%ld>", BUFFER(self)->memory.size);
+    
     return rb_str_new2(tmp);
 }
 
@@ -92,45 +134,38 @@ buffer_inspect(VALUE self)
 static VALUE
 buffer_free(VALUE self)
 {
-    Buffer* ptr = BUFFER(self);
-    if (ptr->parent == Qnil && ptr->storage != NULL) {
-        free(ptr->storage);
-        ptr->storage = NULL;
-    }
-    return self;
-}
+    Buffer* ptr;
 
-static void
-buffer_release(Buffer* ptr)
-{
-    if (ptr->parent == Qnil && ptr->storage != NULL) {
+    Data_Get_Struct(self, Buffer, ptr);
+    if (ptr->storage != NULL) {
         free(ptr->storage);
         ptr->storage = NULL;
     }
-    xfree(ptr);
+
+    return self;
 }
 
 static void
 buffer_mark(Buffer* ptr)
 {
-    if (ptr->parent != Qnil) {
-        rb_gc_mark(ptr->parent);
-    }
+    rb_gc_mark(ptr->parent);
 }
 
 void
-rb_FFI_Buffer_Init()
+rbffi_Buffer_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    classBuffer = rb_define_class_under(moduleFFI, "Buffer", rb_FFI_AbstractMemory_class);
-    rb_define_alloc_func(classBuffer, buffer_allocate);
+    BufferClass = rb_define_class_under(moduleFFI, "Buffer", rbffi_AbstractMemoryClass);
+
+    rb_global_variable(&BufferClass);
+    rb_define_alloc_func(BufferClass, buffer_allocate);
 
-    rb_define_singleton_method(classBuffer, "alloc_inout", buffer_alloc_inout, -1);
-    rb_define_singleton_method(classBuffer, "alloc_out", buffer_alloc_inout, -1);
-    rb_define_singleton_method(classBuffer, "alloc_in", buffer_alloc_inout, -1);
+    rb_define_singleton_method(BufferClass, "alloc_inout", buffer_alloc_inout, -1);
+    rb_define_singleton_method(BufferClass, "alloc_out", buffer_alloc_inout, -1);
+    rb_define_singleton_method(BufferClass, "alloc_in", buffer_alloc_inout, -1);
     
-    rb_define_method(classBuffer, "initialize", buffer_initialize, -1);
-    rb_define_method(classBuffer, "inspect", buffer_inspect, 0);
-    rb_define_method(classBuffer, "+", buffer_plus, 1);
+    rb_define_method(BufferClass, "initialize", buffer_initialize, -1);
+    rb_define_method(BufferClass, "inspect", buffer_inspect, 0);
+    rb_define_method(BufferClass, "type_size", buffer_type_size, 0);
+    rb_define_method(BufferClass, "[]", buffer_aref, 1);
+    rb_define_method(BufferClass, "+", buffer_plus, 1);
 }
-

data/ext/ffi_c/Callback.c

@@ -10,13 +10,13 @@
 #include "MemoryPointer.h"
 #include "Callback.h"
 #include "Types.h"
+#include "Type.h"
 #include "rbffi.h"
 #include "compat.h"
 #include "extconf.h"
 
-
-static void CallbackInfo_mark(CallbackInfo *);
-static void CallbackInfo_free(CallbackInfo *);
+static void cbinfo_mark(CallbackInfo* cbInfo);
+static void cbinfo_free(CallbackInfo *);
 
 #if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
 static void* ffi_closure_alloc(size_t size, void** code);
@@ -26,36 +26,67 @@ ffi_status ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
         void* user_data, void* code);
 #endif /* HAVE_FFI_CLOSURE_ALLOC */
 
-static VALUE classCallbackInfo = Qnil;
-static VALUE classNativeCallback = Qnil;
-static ID callID = Qnil, cbTableID = Qnil;
+static VALUE CallbackInfoClass = Qnil;
+static VALUE NativeCallbackClass = Qnil;
+static ID id_call = Qnil, id_cbtable = Qnil;
+
+VALUE rbffi_CallbackInfoClass = Qnil;
+
+static VALUE
+cbinfo_allocate(VALUE klass)
+{
+    CallbackInfo* cbInfo;
+    VALUE obj = Data_Make_Struct(klass, CallbackInfo, cbinfo_mark, cbinfo_free, cbInfo);
+
+    cbInfo->type.ffiType = &ffi_type_pointer;
+    cbInfo->type.size = ffi_type_pointer.size;
+    cbInfo->type.alignment = ffi_type_pointer.alignment;
+    cbInfo->type.nativeType = NATIVE_CALLBACK;
+    cbInfo->rbReturnType = Qnil;
 
-VALUE rb_FFI_CallbackInfo_class = Qnil;
+    return obj;
+}
 
 static VALUE
-CallbackInfo_new(VALUE klass, VALUE rbReturnType, VALUE rbParamTypes)
+cbinfo_initialize(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
 {
     CallbackInfo *cbInfo;
-    VALUE retval;
-    int paramCount = RARRAY_LEN(rbParamTypes);
+    int paramCount;
     ffi_status status;
     int i;
 
-    retval = Data_Make_Struct(klass, CallbackInfo, CallbackInfo_mark, CallbackInfo_free, cbInfo);
+    Check_Type(rbParamTypes, T_ARRAY);
+
+    
+    paramCount = RARRAY_LEN(rbParamTypes);
+
+    Data_Get_Struct(self, CallbackInfo, cbInfo);
     cbInfo->parameterCount = paramCount;
-    cbInfo->parameterTypes = xcalloc(paramCount, sizeof(NativeType));
+    cbInfo->parameterTypes = xcalloc(paramCount, sizeof(*cbInfo->parameterTypes));
     cbInfo->ffiParameterTypes = xcalloc(paramCount, sizeof(ffi_type *));
+    Data_Get_Struct(rbReturnType, Type, cbInfo->returnType);
+    cbInfo->rbReturnType = rbReturnType;
+    cbInfo->rbParameterTypes = rbParamTypes;
+
     for (i = 0; i < paramCount; ++i) {
-        cbInfo->parameterTypes[i] = FIX2INT(rb_ary_entry(rbParamTypes, i));
-        cbInfo->ffiParameterTypes[i] = rb_FFI_NativeTypeToFFI(cbInfo->parameterTypes[i]);
+        VALUE entry = rb_ary_entry(rbParamTypes, i);
+        if (!rb_obj_is_kind_of(entry, rbffi_TypeClass)) {
+            rb_raise(rb_eTypeError, "Invalid parameter type");
+        }
+        Data_Get_Struct(entry, Type, cbInfo->parameterTypes[i]);
+        cbInfo->ffiParameterTypes[i] = cbInfo->parameterTypes[i]->ffiType;
         if (cbInfo->ffiParameterTypes[i] == NULL) {
-            rb_raise(rb_eArgError, "Unknown argument type: %#x", cbInfo->parameterTypes[i]);
+            rb_raise(rb_eArgError, "Unknown argument type: %#x", cbInfo->parameterTypes[i]->nativeType);
         }
     }
-    cbInfo->returnType = FIX2INT(rbReturnType);
-    cbInfo->ffiReturnType = rb_FFI_NativeTypeToFFI(cbInfo->returnType);
+
+    if (!rb_obj_is_kind_of(rbReturnType, rbffi_TypeClass)) {
+        rb_raise(rb_eTypeError, "Invalid return type");
+    }
+
+    cbInfo->ffiReturnType = cbInfo->returnType->ffiType;
     if (cbInfo->ffiReturnType == NULL) {
-        rb_raise(rb_eArgError, "Unknown return type: %#x", cbInfo->returnType);
+        rb_raise(rb_eArgError, "Unknown return type: %#x", cbInfo->returnType->nativeType);
     }
 #if defined(_WIN32) && defined(notyet)
     cbInfo->abi = (flags & STDCALL) ? FFI_STDCALL : FFI_DEFAULT_ABI;
@@ -74,38 +105,35 @@ CallbackInfo_new(VALUE klass, VALUE rbReturnType, VALUE rbParamTypes)
         default:
             rb_raise(rb_eArgError, "Unknown FFI error");
     }
-    return retval;
+    return self;
 }
 
 static void
-CallbackInfo_mark(CallbackInfo* cbinfo)
+cbinfo_mark(CallbackInfo* cbInfo)
 {
+    rb_gc_mark(cbInfo->rbReturnType);
+    rb_gc_mark(cbInfo->rbParameterTypes);
 }
 
 static void
-CallbackInfo_free(CallbackInfo* cbInfo)
+cbinfo_free(CallbackInfo* cbInfo)
 {
-    if (cbInfo != NULL) {
-        if (cbInfo->parameterTypes != NULL) {
-            xfree(cbInfo->parameterTypes);
-            cbInfo->parameterTypes = NULL;
-        }
-        if (cbInfo->ffiParameterTypes != NULL) {
-            xfree(cbInfo->ffiParameterTypes);
-            cbInfo->ffiParameterTypes = NULL;
-        }
-        xfree(cbInfo);
+    if (cbInfo->parameterTypes != NULL) {
+        xfree(cbInfo->parameterTypes);
     }
+    if (cbInfo->ffiParameterTypes != NULL) {
+        xfree(cbInfo->ffiParameterTypes);
+    }
+    xfree(cbInfo);
 }
 
 static void
 native_callback_free(NativeCallback* cb)
 {
-    if (cb != NULL) {
-        if (cb->ffi_closure != NULL) {
-            ffi_closure_free(cb->ffi_closure);
-        }
+    if (cb->ffi_closure != NULL) {
+        ffi_closure_free(cb->ffi_closure);
     }
+    xfree(cb);
 }
 
 static void
@@ -127,7 +155,7 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
     rbParams = ALLOCA_N(VALUE, cbInfo->parameterCount);
     for (i = 0; i < cbInfo->parameterCount; ++i) {
         VALUE param;
-        switch (cbInfo->parameterTypes[i]) {
+        switch (cbInfo->parameterTypes[i]->nativeType) {
             case NATIVE_INT8:
                 param = INT2NUM(*(int8_t *) parameters[i]);
                 break;
@@ -162,7 +190,14 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
                 param = rb_tainted_str_new2(*(char **) parameters[i]);
                 break;
             case NATIVE_POINTER:
-                param = rb_FFI_Pointer_new(*(void **) parameters[i]);
+                param = rbffi_Pointer_NewInstance(*(void **) parameters[i]);
+                break;
+            case NATIVE_BOOL:
+                param = (*(void **) parameters[i]) ? Qtrue : Qfalse;
+                break;
+            case NATIVE_CALLBACK:
+                param = rbffi_NativeValue_ToRuby(cbInfo->parameterTypes[i],
+                     rb_ary_entry(cbInfo->rbParameterTypes, i), parameters[i], Qnil);
                 break;
             default:
                 param = Qnil;
@@ -170,10 +205,10 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
         }
         rbParams[i] = param;
     }
-    rbReturnValue = rb_funcall2(cb->rbProc, callID, cbInfo->parameterCount, rbParams);
+    rbReturnValue = rb_funcall2(cb->rbProc, id_call, cbInfo->parameterCount, rbParams);
     if (rbReturnValue == Qnil || TYPE(rbReturnValue) == T_NIL) {
         memset(retval, 0, cbInfo->ffiReturnType->size);
-    } else switch (cbInfo->returnType) {
+    } else switch (cbInfo->returnType->nativeType) {
         case NATIVE_INT8:
         case NATIVE_INT16:
         case NATIVE_INT32:
@@ -197,58 +232,89 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
             *((double *) retval) = NUM2DBL(rbReturnValue);
             break;
         case NATIVE_POINTER:
-            if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rb_FFI_Pointer_class)) {
+            if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
                 *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
             } else {
                 // Default to returning NULL if not a value pointer object.  handles nil case as well
                 *((void **) retval) = NULL;
             }
             break;
+        case NATIVE_BOOL:
+            *((ffi_sarg *) retval) = TYPE(rbReturnValue) == T_TRUE ? 1 : 0;
+            break;
+        case NATIVE_CALLBACK:
+            if (rb_obj_is_kind_of(rbReturnValue, rb_cProc) || rb_respond_to(rbReturnValue, id_call)) {
+                VALUE callback;
+
+                callback = rbffi_NativeCallback_ForProc(rbReturnValue, cbInfo->rbReturnType);
+                
+                *((void **) retval) = ((NativeCallback *) DATA_PTR(callback))->code;
+            } else {
+                *((void **) retval) = NULL;
+            }
+            break;
+
         default:
+            *((ffi_arg *) retval) = 0;
             break;
     }
 }
 
+static VALUE
+native_callback_allocate(VALUE klass)
+{
+    NativeCallback* closure;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, NativeCallback, native_callback_mark, native_callback_free, closure);
+    closure->rbCallbackInfo = Qnil;
+    closure->rbProc = Qnil;
+    
+    return obj;
+}
+
 VALUE
-rb_FFI_NativeCallback_new(VALUE rbCallbackInfo, VALUE rbProc)
+rbffi_NativeCallback_NewInstance(VALUE rbCallbackInfo, VALUE rbProc)
 {
     NativeCallback* closure = NULL;
-    CallbackInfo* cbInfo = (CallbackInfo *) DATA_PTR(rbCallbackInfo);
+    CallbackInfo* cbInfo;
+    VALUE obj;
     ffi_status status;
-    
-    closure = ALLOC(NativeCallback);
+
+    Data_Get_Struct(rbCallbackInfo, CallbackInfo, cbInfo);
+    obj = Data_Make_Struct(NativeCallbackClass, NativeCallback, native_callback_mark, native_callback_free, closure);
+    closure->cbInfo = cbInfo;
+    closure->rbProc = rbProc;
+    closure->rbCallbackInfo = rbCallbackInfo;
+
     closure->ffi_closure = ffi_closure_alloc(sizeof(*closure->ffi_closure), &closure->code);
     if (closure->ffi_closure == NULL) {
-        xfree(closure);
         rb_raise(rb_eNoMemError, "Failed to allocate FFI native closure");
     }
-    closure->cbInfo = cbInfo;
-    closure->rbProc = rbProc;
-    closure->rbCallbackInfo = rbCallbackInfo;
+
     status = ffi_prep_closure_loc(closure->ffi_closure, &cbInfo->ffi_cif,
             native_callback_invoke, closure, closure->code);
     if (status != FFI_OK) {
-        ffi_closure_free(closure->ffi_closure);
-        xfree(closure);
         rb_raise(rb_eArgError, "ffi_prep_closure_loc failed");
     }
-    return Data_Wrap_Struct(classNativeCallback, native_callback_mark, native_callback_free, closure);
+
+    return obj;
 }
 
 VALUE
-rb_FFI_NativeCallback_for_proc(VALUE proc, VALUE cbInfo)
+rbffi_NativeCallback_ForProc(VALUE proc, VALUE cbInfo)
 {
     VALUE callback;
-    VALUE cbTable = RTEST(rb_ivar_defined(proc, cbTableID)) ? rb_ivar_get(proc, cbTableID) : Qnil;
+    VALUE cbTable = RTEST(rb_ivar_defined(proc, id_cbtable)) ? rb_ivar_get(proc, id_cbtable) : Qnil;
     if (cbTable == Qnil) {
         cbTable = rb_hash_new();
-        rb_ivar_set(proc, cbTableID, cbTable);
+        rb_ivar_set(proc, id_cbtable, cbTable);
     }
     callback = rb_hash_aref(cbTable, cbInfo);
     if (callback != Qnil) {
         return callback;
     }
-    callback = rb_FFI_NativeCallback_new(cbInfo, proc);
+    callback = rbffi_NativeCallback_NewInstance(cbInfo, proc);
     rb_hash_aset(cbTable, cbInfo, callback);
     return callback;
 }
@@ -292,12 +358,17 @@ ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
 #endif /* HAVE_FFI_CLOSURE_ALLOC */
 
 void
-rb_FFI_Callback_Init()
+rbffi_Callback_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_CallbackInfo_class = classCallbackInfo = rb_define_class_under(moduleFFI, "CallbackInfo", rb_cObject);
-    rb_define_singleton_method(classCallbackInfo, "new", CallbackInfo_new, 2);
-    classNativeCallback = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
-    callID = rb_intern("call");
-    cbTableID = rb_intern("@__ffi_callback_table__");
+    rbffi_CallbackInfoClass = CallbackInfoClass = rb_define_class_under(moduleFFI, "CallbackInfo", rbffi_TypeClass);
+    rb_global_variable(&rbffi_CallbackInfoClass);
+
+    rb_define_alloc_func(CallbackInfoClass, cbinfo_allocate);
+    rb_define_method(CallbackInfoClass, "initialize", cbinfo_initialize, 2);
+
+    NativeCallbackClass = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
+    rb_global_variable(&NativeCallbackClass);
+    rb_define_alloc_func(NativeCallbackClass, native_callback_allocate);
+    id_call = rb_intern("call");
+    id_cbtable = rb_intern("@__ffi_callback_table__");
 }

data/ext/ffi_c/Callback.h

@@ -2,6 +2,7 @@
 #define	_CALLBACK_H
 
 #include "Types.h"
+#include "Type.h"
 
 #ifdef	__cplusplus
 extern "C" {
@@ -9,8 +10,12 @@ extern "C" {
 #include <ffi.h>
     
 typedef struct {
-    NativeType returnType;
-    NativeType* parameterTypes;
+    Type type; // The native type of a CallbackInfo object
+    VALUE rbReturnType;
+    VALUE rbParameterTypes;
+
+    Type* returnType;
+    Type** parameterTypes;
     ffi_type* ffiReturnType;
     ffi_type** ffiParameterTypes;
     ffi_cif ffi_cif;
@@ -29,9 +34,10 @@ typedef struct {
     VALUE rbProc;
 } NativeCallback;
 
-extern VALUE rb_FFI_CallbackInfo_class;
-extern VALUE rb_FFI_NativeCallback_new(VALUE, VALUE);
-extern VALUE rb_FFI_NativeCallback_for_proc(VALUE proc, VALUE cbInfo);
+extern VALUE rbffi_CallbackInfoClass;
+extern void rbffi_Callback_Init(VALUE ffiModule);
+extern VALUE rbffi_NativeCallback_NewInstance(VALUE, VALUE);
+extern VALUE rbffi_NativeCallback_ForProc(VALUE proc, VALUE cbInfo);
 
 #ifdef	__cplusplus
 }