ffi 0.3.0 → 0.4.0

data/README.rdoc

@@ -4,16 +4,66 @@ ruby-ffi
 
 == DESCRIPTION:
 
-A Ruby foreign function interface
+Ruby-FFI is a ruby extension for programmatically loading dynamic
+libraries, binding functions within them, and calling those functions
+from Ruby code. Moreover, a Ruby-FFI extension works without changes
+on Ruby and JRuby. Discover why should you write your next extension
+using Ruby-FFI {here}[http://kenai.com/projects/ruby-ffi/pages/WhyUseFFI].
 
 == FEATURES/PROBLEMS:
 
+* It has a very intuitive DSL
+* It supports all C native types
+* It supports C structs (also nested), enums and global variables
+* It supports callbacks
+* It has smart methods to handle memory management of pointers and structs
+
 == SYNOPSIS:
 
+  require 'ffi'
+
+  module MyLib
+    extend FFI::Library
+    attach_function :puts, [ :string ], :int
+  end
+
+  MyLib.puts 'Hello boys using libc!'
+
+For less minimalistic and more sane examples you may look at:
+
+* the samples/ folder
+* the examples on the Kenai {wiki}[http://kenai.com/projects/ruby-ffi/pages/Home]
+* the projects using FFI listed on this {page}[http://kenai.com/projects/ruby-ffi/pages/ProjectsUsingFFI]
+
 == REQUIREMENTS:
 
+* You need a sane building environment in order to compile the extension.
+
 == DOWNLOAD/INSTALL:
 
+From rubyforge:
+
+  [sudo] gem install ffi
+
+or from the mercurial repository on Kenai:
+
+  hg clone https://kenai.com/hg/ruby-ffi~mercurial ruby-ffi
+  cd ruby-ffi
+  rake gem:install
+
+== CREDITS:
+
+Special thanks to:
+
+Yehuda Katz
+Luc Heinrich
+Andrea Fazzi
+Mike Dalessio
+Hongli Lai
+Evan Phoenix
+Aman Gupta
+Beoran
+
 == LICENSE:
 
 See LICENSE file.

data/Rakefile

@@ -1,9 +1,11 @@
 require 'rubygems'
+require 'rbconfig'
 
-USE_RAKE_COMPILER = (RUBY_VERSION =~ /1\.9.*/ || RUBY_PLATFORM =~ /java/) ? false : true
+USE_RAKE_COMPILER = (RUBY_PLATFORM =~ /java/) ? false : true
 if USE_RAKE_COMPILER
-  gem 'rake-compiler', '>=0.3.0'
+  gem 'rake-compiler', '>=0.6.0'
   require 'rake/extensiontask'
+  ENV['RUBY_CC_VERSION'] = '1.8.6:1.9.1'
 end
 
 require 'date'
@@ -24,34 +26,44 @@ end
 LIBEXT = Config::CONFIG['host_os'].downcase =~ /darwin/ ? "dylib" : "so"
 GMAKE = Config::CONFIG['host_os'].downcase =~ /bsd/ ? "gmake" : "make"
 LIBTEST = "build/libtest.#{LIBEXT}"
-BUILD_DIR = "build/#{RUBY_VERSION}"
+BUILD_DIR = "build"
+BUILD_EXT_DIR = File.join(BUILD_DIR, "#{Config::CONFIG['arch']}", 'ffi_c', RUBY_VERSION)
 
 # Project general information
 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.4.0'
 PROJ.rubyforge.name = 'ffi'
-
 PROJ.readme_file = 'README.rdoc'
 
 # Annoucement
-PROJ.ann.paragraphs
-PROJ.ann.email[:from] = 'wmeissner@gmail.com'
+PROJ.ann.paragraphs << 'FEATURES' << 'SYNOPSIS' << 'REQUIREMENTS' << 'DOWNLOAD/INSTALL' << 'CREDITS' << 'LICENSE'
+
+PROJ.ann.email[:from] = 'andrea.fazzi@alcacoop.it'
 PROJ.ann.email[:to] << 'dev@ruby-ffi.kenai.com' << 'users@ruby-ffi.kenai.com'
 PROJ.ann.email[:server] = 'smtp.gmail.com'
 
 # Gem specifications
 PROJ.gem.need_tar = false
-PROJ.gem.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{ext,lib,nbproject,samples,spec}/**/*")
+PROJ.gem.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{ext,gen,lib,spec}/**/*")
 PROJ.gem.platform = Gem::Platform::RUBY
-PROJ.gem.extensions = %w(ext/ffi_c/extconf.rb gen/Rakefile)
+
+# Override Mr. Bones autogenerated extensions and force ours in
+PROJ.gem.extras['extensions'] = %w(ext/ffi_c/extconf.rb gen/Rakefile)
 
 # RDoc
 PROJ.rdoc.exclude << '^ext\/'
 PROJ.rdoc.opts << '-x' << 'ext'
 
+# Ruby
+PROJ.ruby_opts = []
+PROJ.ruby_opts << '-I' << BUILD_EXT_DIR unless RUBY_PLATFORM == "java"
+
+#RSpec
+PROJ.spec.opts << '--color' << '-fs'
+
 TEST_DEPS = [ LIBTEST ]
 if RUBY_PLATFORM == "java"
   desc "Run all specs"
@@ -67,12 +79,12 @@ else
   desc "Run all specs"
   task :specs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -Ilib -I#{BUILD_DIR} -S spec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S spec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
   end
   desc "Run rubinius specs"
   task :rbxspecs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -Ilib -I#{BUILD_DIR} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
   end
 end
 
@@ -82,30 +94,31 @@ task :package => 'gem:package'
 desc "Install the gem locally"
 task :install => 'gem:install'
 
-unless USE_RAKE_COMPILER
-  file "#{BUILD_DIR}/Makefile" do
-    FileUtils.mkdir_p(BUILD_DIR) unless File.directory?(BUILD_DIR)
-    sh %{cd "#{BUILD_DIR}" && #{Gem.ruby} #{Dir.pwd}/ext/ffi_c/extconf.rb}
-  end
-  desc "Compile the native module"
-  task :compile => "#{BUILD_DIR}/Makefile" do
-    sh %{cd "#{BUILD_DIR}"; make}
-  end
-end
+
 desc "Clean all built files"
-task :clean do
-  FileUtils.rm_rf("build")
-  FileUtils.rm_rf("conftest.dSYM")
-  FileUtils.rm_f(Dir["pkg/*.gem"])
+task :distclean => :clobber do
+  FileUtils.rm_rf('build')
+  FileUtils.rm_rf(Dir['lib/**/ffi_c.so'])
+  FileUtils.rm_rf('lib/1.8')
+  FileUtils.rm_rf('lib/1.9')
+  FileUtils.rm_rf('conftest.dSYM')
+  FileUtils.rm_rf('pkg')
 end
+
+
+desc "Build the native test lib"
 task "build/libtest.#{LIBEXT}" do
-  sh %{#{GMAKE} -f libtest/GNUmakefile}
+  sh %{#{GMAKE} -f libtest/GNUmakefile CPU=#{Config::CONFIG['host_cpu']}}
 end
+
+
 desc "Build test helper lib"
 task :libtest => "build/libtest.#{LIBEXT}"
+
 desc "Test the extension"
-task :test => [ :specs, :rbxspecs ] do
-end
+task :test => [ :specs, :rbxspecs ]
+
+
 namespace :bench do
   ITER = ENV['ITER'] ? ENV['ITER'].to_i : 100000
   bench_libs = "-Ilib -I#{BUILD_DIR}" unless RUBY_PLATFORM == "java"
@@ -121,3 +134,9 @@ namespace :bench do
     end
   end
 end
+
+task 'spec:run' => TEST_DEPS
+task 'spec:specdoc' => TEST_DEPS
+
+task :default => :specs
+

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;
+VALUE rbffi_AbstractMemoryClass = Qnil;
+static ID id_to_ptr = 0;
+static ID id_call = 0;
+
+static VALUE
+memory_allocate(VALUE klass)
+{
+    AbstractMemory* memory;
+    VALUE obj;
+    obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
+    memory->ops = &rbffi_AbstractMemoryOps;
+
+    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,46 +107,26 @@ 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)
-{ 
-    AbstractMemory* memory = MEMORY(self);
-    long off = NUM2LONG(offset);
+static inline void*
+get_pointer_value(VALUE value)
+{
     const int type = TYPE(value);
-    checkBounds(memory, off, sizeof(void *));
-
-    if (rb_obj_is_kind_of(value, rb_FFI_Pointer_class) && type == T_DATA) {
-        void* tmp = memory_address(value);
-        memcpy(memory->address + off, &tmp, sizeof(tmp));
+    if (type == T_DATA && rb_obj_is_kind_of(value, rbffi_PointerClass)) {
+        return memory_address(value);
     } else if (type == T_NIL) {
-        void* tmp = NULL;
-        memcpy(memory->address + off, &tmp, sizeof(tmp));
+        return NULL;
     } else if (type == T_FIXNUM) {
-        uintptr_t tmp = (uintptr_t) FIX2INT(value);
-        memcpy(memory->address + off, &tmp, sizeof(tmp));
+        return (void *) (uintptr_t) FIX2INT(value);
     } else if (type == T_BIGNUM) {
-        uintptr_t tmp = (uintptr_t) NUM2ULL(value);
-        memcpy(memory->address + off, &tmp, sizeof(tmp));
-    } else if (rb_respond_to(value, to_ptr)) {
-        VALUE ptr = rb_funcall2(value, to_ptr, 0, NULL);
-        void* tmp = MEMORY_PTR(ptr);
-        memcpy(memory->address + off, &tmp, sizeof(tmp));
+        return (void *) (uintptr_t) NUM2ULL(value);
+    } else if (rb_respond_to(value, id_to_ptr)) {
+        return MEMORY_PTR(rb_funcall2(value, id_to_ptr, 0, NULL));
     } else {
         rb_raise(rb_eArgError, "value is not a pointer");
     }
-    return self;
 }
 
-static VALUE
-memory_get_pointer(VALUE self, VALUE offset)
-{
-    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);
-}
+NUM_OP(pointer, void *, get_pointer_value, rbffi_Pointer_NewInstance);
 
 static VALUE
 memory_put_callback(VALUE self, VALUE offset, VALUE proc, VALUE cbInfo)
@@ -136,8 +135,8 @@ memory_put_callback(VALUE self, VALUE offset, VALUE proc, VALUE cbInfo)
     long off = NUM2LONG(offset);
     checkBounds(memory, off, sizeof(void *));
 
-    if (rb_obj_is_kind_of(proc, rb_cProc)) {
-        VALUE callback = rb_FFI_NativeCallback_for_proc(proc, cbInfo);
+    if (rb_obj_is_kind_of(proc, rb_cProc) || rb_respond_to(proc, id_call)) {
+        VALUE callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
         void* code = ((NativeCallback *) DATA_PTR(callback))->code;
         memcpy(memory->address + off, &code, sizeof(code));
     } else {
@@ -178,15 +177,56 @@ memory_get_string(int argc, VALUE* argv, VALUE self)
             (end != NULL ? end - ptr->address - off : len));
 }
 
+static VALUE
+memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
+{
+    VALUE offset = Qnil, countnum = Qnil, retVal = Qnil;
+    AbstractMemory* ptr;
+    long off;
+    int count;
+
+    rb_scan_args(argc, argv, "11", &offset, &countnum);
+    off = NUM2LONG(offset);
+    count = (countnum == Qnil ? 0 : NUM2INT(countnum));
+    retVal = rb_ary_new2(count);
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+
+    if (countnum != Qnil) {
+        int i;
+
+        checkBounds(ptr, off, count * sizeof (char*));
+        
+        for (i = 0; i < count; ++i) {
+            const char* strptr = *((const char**) (ptr->address + off) + i);
+            rb_ary_push(retVal, (strptr == NULL ? Qnil : rb_tainted_str_new2(strptr)));
+        }
+
+    } else {
+        checkBounds(ptr, off, sizeof (char*));
+        for ( ; off < ptr->size - sizeof (void *); off += sizeof (void *)) {
+            const char* strptr = *(const char**) (ptr->address + off);
+            if (strptr == NULL) {
+                break;
+            }
+            rb_ary_push(retVal, rb_tainted_str_new2(strptr));
+        }
+    }
+
+    return retVal;
+}
+
 static VALUE
 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);
+
+    checkBounds(ptr, off, len + 1);
     if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
         rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
     }
@@ -215,6 +255,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) {
@@ -239,21 +281,64 @@ memory_address(VALUE obj)
 }
 
 AbstractMemory*
-rb_FFI_AbstractMemory_cast(VALUE obj, VALUE klass)
+rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass)
 {
     if (rb_obj_is_kind_of(obj, klass)) {
         AbstractMemory* memory;
         Data_Get_Struct(obj, AbstractMemory, memory);
         return memory;
     }
+
     rb_raise(rb_eArgError, "Invalid Memory object");
+    return NULL;
+}
+
+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 rbffi_AbstractMemoryOps = {
+    .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()
+rbffi_AbstractMemory_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_AbstractMemory_class = classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
+    VALUE classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
+    rbffi_AbstractMemoryClass = classMemory;
+    rb_global_variable(&rbffi_AbstractMemoryClass);
+
+    rb_define_alloc_func(classMemory, memory_allocate);
 #undef INT
 #define INT(type) \
     rb_define_method(classMemory, "put_" #type, memory_put_##type, 2); \
@@ -286,16 +371,11 @@ rb_FFI_AbstractMemory_Init()
     ALIAS(long_long, int64);
     
     if (sizeof(long) == 4) {
-        rb_define_alias(classMemory, "put_long", "put_int32");
-        rb_define_alias(classMemory, "put_ulong", "put_uint32");
-        rb_define_alias(classMemory, "get_long", "get_int32");
-        rb_define_alias(classMemory, "get_ulong", "get_uint32");
+        ALIAS(long, int32);
     } else {
-        rb_define_alias(classMemory, "put_long", "put_int64");
-        rb_define_alias(classMemory, "put_ulong", "put_uint64");
-        rb_define_alias(classMemory, "get_long", "get_int64");
-        rb_define_alias(classMemory, "get_ulong", "get_uint64");
+        ALIAS(long, int64);
     }
+
     rb_define_method(classMemory, "put_float32", memory_put_float32, 2);
     rb_define_method(classMemory, "get_float32", memory_get_float32, 1);
     rb_define_alias(classMemory, "put_float", "put_float32");
@@ -314,15 +394,19 @@ rb_FFI_AbstractMemory_Init()
     rb_define_alias(classMemory, "get_array_of_double", "get_array_of_float64");
     rb_define_method(classMemory, "put_pointer", memory_put_pointer, 2);
     rb_define_method(classMemory, "get_pointer", memory_get_pointer, 1);
+    rb_define_method(classMemory, "put_array_of_pointer", memory_put_array_of_pointer, 2);
+    rb_define_method(classMemory, "get_array_of_pointer", memory_get_array_of_pointer, 2);
     rb_define_method(classMemory, "put_callback", memory_put_callback, 3);
     rb_define_method(classMemory, "get_string", memory_get_string, -1);
     rb_define_method(classMemory, "put_string", memory_put_string, 2);
     rb_define_method(classMemory, "get_bytes", memory_get_bytes, 2);
     rb_define_method(classMemory, "put_bytes", memory_put_bytes, -1);
+    rb_define_method(classMemory, "get_array_of_string", memory_get_array_of_string, -1);
 
     rb_define_method(classMemory, "clear", memory_clear, 0);
     rb_define_method(classMemory, "total", memory_size, 0);
 
-    to_ptr = rb_intern("to_ptr");
+    id_to_ptr = rb_intern("to_ptr");
+    id_call = rb_intern("call");
 }
 

data/ext/ffi_c/AbstractMemory.h

@@ -5,14 +5,40 @@
 #include <sys/types.h>
 #include <stdint.h>
 
+#include "compat.h"
+
 #ifdef	__cplusplus
 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)
@@ -23,13 +49,17 @@ checkBounds(AbstractMemory* mem, long off, long len)
     }
 }
 
-#define MEMORY(obj) rb_FFI_AbstractMemory_cast((obj), rb_FFI_AbstractMemory_class)
+#define MEMORY(obj) rbffi_AbstractMemory_Cast((obj), rbffi_AbstractMemoryClass)
 #define MEMORY_PTR(obj) MEMORY((obj))->address
 #define MEMORY_LEN(obj) MEMORY((obj))->size
 
-extern AbstractMemory* rb_FFI_AbstractMemory_cast(VALUE obj, VALUE klass);
+extern void rbffi_AbstractMemory_Init(VALUE ffiModule);
+
+extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass);
+
+extern VALUE rbffi_AbstractMemoryClass;
+extern MemoryOps rbffi_AbstractMemoryOps;
 
-extern VALUE rb_FFI_AbstractMemory_class;
 #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 rbffi_AutoPointerClass = 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 = &rbffi_AbstractMemoryOps;
+
     return obj;
 }
 
@@ -31,7 +34,7 @@ static VALUE
 autoptr_set_parent(VALUE self, VALUE parent)
 {
     AutoPointer* p;
-    AbstractMemory* ptr = rb_FFI_AbstractMemory_cast(parent, rb_FFI_Pointer_class);
+    AbstractMemory* ptr = rbffi_AbstractMemory_Cast(parent, rbffi_PointerClass);
 
     Data_Get_Struct(self, AutoPointer, p);
     p->memory = *ptr;
@@ -43,21 +46,15 @@ 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()
+rbffi_AutoPointer_Init(VALUE moduleFFI)
 {
-    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);
+    rbffi_AutoPointerClass = rb_define_class_under(moduleFFI, "AutoPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_AutoPointerClass);
+    
+    rb_define_alloc_func(rbffi_AutoPointerClass, autoptr_allocate);
+    rb_define_protected_method(rbffi_AutoPointerClass, "parent=", autoptr_set_parent, 1);
 }

data/ext/ffi_c/AutoPointer.h

@@ -6,8 +6,8 @@
 extern "C" {
 #endif
 
-extern void rb_FFI_AutoPointer_Init(void);
-extern VALUE rb_FFI_AutoPointer_class;
+extern void rbffi_AutoPointer_Init(VALUE ffiModule);
+extern VALUE rbffi_AutoPointerClass;
 
 
 #ifdef	__cplusplus