ffi 0.3.0 → 0.3.1

data/Rakefile

@@ -31,9 +31,8 @@ PROJ.name = 'ffi'
 PROJ.authors = 'Wayne Meissner'
 PROJ.email = 'wmeissner@gmail.com'
 PROJ.url = 'http://kenai.com/projects/ruby-ffi'
-PROJ.version = '0.3.0'
+PROJ.version = '0.3.1'
 PROJ.rubyforge.name = 'ffi'
-
 PROJ.readme_file = 'README.rdoc'
 
 # Annoucement
@@ -52,6 +51,13 @@ PROJ.gem.extensions = %w(ext/ffi_c/extconf.rb gen/Rakefile)
 PROJ.rdoc.exclude << '^ext\/'
 PROJ.rdoc.opts << '-x' << 'ext'
 
+# Ruby
+PROJ.ruby_opts = []
+PROJ.ruby_opts << '-I' << "\"#{BUILD_DIR}\"" unless RUBY_PLATFORM == "java"
+
+#RSpec
+PROJ.spec.opts << '--color' << '-fs'
+
 TEST_DEPS = [ LIBTEST ]
 if RUBY_PLATFORM == "java"
   desc "Run all specs"
@@ -121,3 +127,6 @@ namespace :bench do
     end
   end
 end
+
+task 'spec:run' => TEST_DEPS
+task 'spec:specdoc' => TEST_DEPS

data/ext/ffi_c/AbstractMemory.c

@@ -9,41 +9,60 @@
 #include "Pointer.h"
 #include "Callback.h"
 
-static VALUE memory_put_float32(VALUE self, VALUE offset, VALUE value);
-static VALUE memory_get_float32(VALUE self, VALUE offset);
-static VALUE memory_put_float64(VALUE self, VALUE offset, VALUE value);
-static VALUE memory_get_float64(VALUE self, VALUE offset);
-static VALUE memory_put_pointer(VALUE self, VALUE offset, VALUE value);
-static VALUE memory_get_pointer(VALUE self, VALUE offset);
 
 static inline char* memory_address(VALUE self);
 VALUE rb_FFI_AbstractMemory_class = Qnil;
 static VALUE classMemory = Qnil;
 static ID to_ptr = 0;
 
+static VALUE
+memory_allocate(VALUE klass)
+{
+    AbstractMemory* memory;
+    VALUE obj;
+    obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
+    memory->ops = &rb_FFI_AbstractMemory_ops;
+
+    return obj;
+}
+
 #define NUM_OP(name, type, toNative, fromNative) \
-static VALUE memory_put_##name(VALUE self, VALUE offset, VALUE value); \
-static VALUE \
-memory_put_##name(VALUE self, VALUE offset, VALUE value) \
+static void memory_op_put_##name(AbstractMemory* memory, long off, VALUE value); \
+static void \
+memory_op_put_##name(AbstractMemory* memory, long off, VALUE value) \
 { \
-    long off = NUM2LONG(offset); \
-    AbstractMemory* memory = MEMORY(self); \
     type tmp = (type) toNative(value); \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(memory->address + off, &tmp, sizeof(tmp)); \
+} \
+static VALUE memory_put_##name(VALUE self, VALUE offset, VALUE value); \
+static VALUE \
+memory_put_##name(VALUE self, VALUE offset, VALUE value) \
+{ \
+    AbstractMemory* memory; \
+    Data_Get_Struct(self, AbstractMemory, memory); \
+    memory_op_put_##name(memory, NUM2LONG(offset), value); \
     return self; \
 } \
-static VALUE memory_get_##name(VALUE self, VALUE offset); \
+static VALUE memory_op_get_##name(AbstractMemory* memory, long off); \
 static VALUE \
-memory_get_##name(VALUE self, VALUE offset) \
+memory_op_get_##name(AbstractMemory* memory, long off) \
 { \
-    long off = NUM2LONG(offset); \
-    AbstractMemory* memory = MEMORY(self); \
     type tmp; \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(&tmp, memory->address + off, sizeof(tmp)); \
     return fromNative(tmp); \
 } \
+static VALUE memory_get_##name(VALUE self, VALUE offset); \
+static VALUE \
+memory_get_##name(VALUE self, VALUE offset) \
+{ \
+    AbstractMemory* memory; \
+    Data_Get_Struct(self, AbstractMemory, memory); \
+    return memory_op_get_##name(memory, NUM2LONG(offset)); \
+} \
+static MemoryOp memory_op_##name = { memory_op_get_##name, memory_op_put_##name }; \
+\
 static VALUE memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary); \
 static VALUE \
 memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
@@ -88,11 +107,9 @@ NUM_OP(uint64, uint64_t, NUM2ULL, ULL2NUM);
 NUM_OP(float32, float, NUM2DBL, rb_float_new);
 NUM_OP(float64, double, NUM2DBL, rb_float_new);
 
-static VALUE
-memory_put_pointer(VALUE self, VALUE offset, VALUE value)
+static void
+memory_op_put_pointer(AbstractMemory* memory, long off, VALUE value)
 { 
-    AbstractMemory* memory = MEMORY(self);
-    long off = NUM2LONG(offset);
     const int type = TYPE(value);
     checkBounds(memory, off, sizeof(void *));
 
@@ -115,20 +132,39 @@ memory_put_pointer(VALUE self, VALUE offset, VALUE value)
     } else {
         rb_raise(rb_eArgError, "value is not a pointer");
     }
-    return self;
 }
 
 static VALUE
-memory_get_pointer(VALUE self, VALUE offset)
+memory_op_get_pointer(AbstractMemory* memory, long off)
 {
-    AbstractMemory* memory = MEMORY(self);
-    long off = NUM2LONG(offset);
     void* tmp;
+
     checkBounds(memory, off, sizeof(tmp));
     memcpy(&tmp, memory->address + off, sizeof(tmp));
     return rb_FFI_Pointer_new(tmp);
 }
 
+static VALUE
+memory_put_pointer(VALUE self, VALUE offset, VALUE value)
+{
+    AbstractMemory* memory;
+
+    Data_Get_Struct(self, AbstractMemory, memory);
+    memory_op_put_pointer(memory, NUM2LONG(offset), value);
+
+    return self;
+}
+
+static VALUE
+memory_get_pointer(VALUE self, VALUE offset)
+{
+    AbstractMemory* memory;
+    
+    Data_Get_Struct(self, AbstractMemory, memory);
+
+    return memory_op_get_pointer(memory, NUM2LONG(offset));
+}
+
 static VALUE
 memory_put_callback(VALUE self, VALUE offset, VALUE proc, VALUE cbInfo)
 {
@@ -184,8 +220,10 @@ memory_put_string(VALUE self, VALUE offset, VALUE str)
     AbstractMemory* ptr = MEMORY(self);
     long off, len;
 
+    Check_Type(str, T_STRING);
     off = NUM2LONG(offset);
     len = RSTRING_LEN(str);
+
     checkBounds(ptr, off, len);
     if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
         rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
@@ -215,6 +253,8 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     long off, len, idx;
     int nargs = rb_scan_args(argc, argv, "22", &offset, &str, &rbIndex, &rbLength);
 
+    Check_Type(str, T_STRING);
+
     off = NUM2LONG(offset);
     idx = nargs > 2 ? NUM2LONG(rbIndex) : 0;
     if (idx < 0) {
@@ -249,11 +289,51 @@ rb_FFI_AbstractMemory_cast(VALUE obj, VALUE klass)
     rb_raise(rb_eArgError, "Invalid Memory object");
 }
 
+static VALUE
+memory_op_get_strptr(AbstractMemory* ptr, long offset)
+{
+    void* tmp = NULL;
+
+    if (ptr != NULL && ptr->address != NULL) {
+        checkBounds(ptr, offset, sizeof(tmp));
+        memcpy(&tmp, ptr->address + offset, sizeof(tmp));
+    }
+
+    return tmp != NULL ? rb_tainted_str_new2(tmp) : Qnil;
+}
+
+static void
+memory_op_put_strptr(AbstractMemory* ptr, long offset, VALUE value)
+{
+    rb_raise(rb_eArgError, "Cannot set :string fields");
+}
+
+static MemoryOp memory_op_strptr = { memory_op_get_strptr, memory_op_put_strptr };
+
+static MemoryOp memory_op_pointer = { memory_op_get_pointer, memory_op_put_pointer };
+
+MemoryOps rb_FFI_AbstractMemory_ops = {
+    .int8 = &memory_op_int8,
+    .uint8 = &memory_op_uint8,
+    .int16 = &memory_op_int16,
+    .uint16 = &memory_op_uint16,
+    .int32 = &memory_op_int32,
+    .uint32 = &memory_op_uint32,
+    .int64 = &memory_op_int64,
+    .uint64 = &memory_op_uint64,
+    .float32 = &memory_op_float32,
+    .float64 = &memory_op_float64,
+    .pointer = &memory_op_pointer,
+    .strptr = &memory_op_strptr,
+};
+
 void
 rb_FFI_AbstractMemory_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
     rb_FFI_AbstractMemory_class = classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
+
+    rb_define_alloc_func(classMemory, memory_allocate);
 #undef INT
 #define INT(type) \
     rb_define_method(classMemory, "put_" #type, memory_put_##type, 2); \

data/ext/ffi_c/AbstractMemory.h

@@ -9,10 +9,34 @@
 extern "C" {
 #endif
 
+typedef struct AbstractMemory_ AbstractMemory;
+
+typedef struct {
+    VALUE (*get)(AbstractMemory* ptr, long offset);
+    void (*put)(AbstractMemory* ptr, long offset, VALUE value);
+} MemoryOp;
+
 typedef struct {
+    MemoryOp* int8;
+    MemoryOp* uint8;
+    MemoryOp* int16;
+    MemoryOp* uint16;
+    MemoryOp* int32;
+    MemoryOp* uint32;
+    MemoryOp* int64;
+    MemoryOp* uint64;
+    MemoryOp* float32;
+    MemoryOp* float64;
+    MemoryOp* pointer;
+    MemoryOp* strptr;
+} MemoryOps;
+
+struct AbstractMemory_ {
     char* address; // Use char* instead of void* to ensure adding to it works correctly
     long size;
-} AbstractMemory;
+    MemoryOps* ops;
+};
+
 
 static inline void
 checkBounds(AbstractMemory* mem, long off, long len)
@@ -30,6 +54,8 @@ checkBounds(AbstractMemory* mem, long off, long len)
 extern AbstractMemory* rb_FFI_AbstractMemory_cast(VALUE obj, VALUE klass);
 
 extern VALUE rb_FFI_AbstractMemory_class;
+extern MemoryOps rb_FFI_AbstractMemory_ops;
+
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/AutoPointer.c

@@ -13,17 +13,20 @@ typedef struct AutoPointer {
     VALUE parent;
 } AutoPointer;
 
-VALUE rb_FFI_AutoPointer_class;
-static VALUE classAutoPointer = Qnil;
 static void autoptr_mark(AutoPointer* ptr);
-static void autoptr_free(AutoPointer* ptr);
+static VALUE autoptr_allocate(VALUE klass);
+static VALUE autoptr_set_parent(VALUE self, VALUE parent);
+
+VALUE rb_FFI_AutoPointer_class = Qnil;
 
 static VALUE
 autoptr_allocate(VALUE klass)
 {
     AutoPointer* p;
-    VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, autoptr_free, p);
+    VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, -1, p);
     p->parent = Qnil;
+    p->memory.ops = &rb_FFI_AbstractMemory_ops;
+
     return obj;
 }
 
@@ -43,21 +46,16 @@ autoptr_set_parent(VALUE self, VALUE parent)
 static void
 autoptr_mark(AutoPointer* ptr)
 {
-    if (ptr->parent != Qnil) {
-        rb_gc_mark(ptr->parent);
-    }
-}
-static void
-autoptr_free(AutoPointer* ptr)
-{
-    xfree(ptr);
+    rb_gc_mark(ptr->parent);
 }
 
 void
 rb_FFI_AutoPointer_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_AutoPointer_class = classAutoPointer = rb_define_class_under(moduleFFI, "AutoPointer", rb_FFI_Pointer_class);
-    rb_define_alloc_func(classAutoPointer, autoptr_allocate);
-    rb_define_protected_method(classAutoPointer, "parent=", autoptr_set_parent, 1);
+    rb_FFI_AutoPointer_class = rb_define_class_under(moduleFFI, "AutoPointer", rb_FFI_Pointer_class);
+    rb_global_variable(&rb_FFI_AutoPointer_class);
+    
+    rb_define_alloc_func(rb_FFI_AutoPointer_class, autoptr_allocate);
+    rb_define_protected_method(rb_FFI_AutoPointer_class, "parent=", autoptr_set_parent, 1);
 }

data/ext/ffi_c/Buffer.c

@@ -25,7 +25,24 @@ 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 = &rb_FFI_AbstractMemory_ops;
+
+    return obj;
+}
+
+static void
+buffer_release(Buffer* ptr)
+{
+    if (ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+    
+    xfree(ptr);
 }
 
 static VALUE
@@ -34,27 +51,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;
-
+    
     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);
-    }
+
     Data_Get_Struct(self, Buffer, p);
-    p->storage = memory;
     p->memory.size = msize;
+
+    p->storage = malloc(msize + 7);
+    if (p->storage == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", 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;
+    p->memory.address = (void *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);
+    
     if (nargs > 2 && RTEST(clear) && 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,10 +93,13 @@ 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(classBuffer, Buffer, buffer_mark, -1, p);
+    p->memory.address = ptr->memory.address + off;
     p->memory.size = ptr->memory.size - off;
+    p->memory.ops = &rb_FFI_AbstractMemory_ops;
     p->parent = self;
+
     return retval;
 }
 
@@ -84,7 +107,9 @@ 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,30 +117,21 @@ 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
@@ -123,6 +139,8 @@ rb_FFI_Buffer_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
     classBuffer = rb_define_class_under(moduleFFI, "Buffer", rb_FFI_AbstractMemory_class);
+
+    rb_global_variable(&classBuffer);
     rb_define_alloc_func(classBuffer, buffer_allocate);
 
     rb_define_singleton_method(classBuffer, "alloc_inout", buffer_alloc_inout, -1);
@@ -133,4 +151,3 @@ rb_FFI_Buffer_Init()
     rb_define_method(classBuffer, "inspect", buffer_inspect, 0);
     rb_define_method(classBuffer, "+", buffer_plus, 1);
 }
-