ffi 0.2.0 → 0.3.0

data/README.rdoc

@@ -0,0 +1,19 @@
+ruby-ffi
+    by Wayne Meissner
+    http://kenai.com/projects/ruby-ffi
+
+== DESCRIPTION:
+
+A Ruby foreign function interface
+
+== FEATURES/PROBLEMS:
+
+== SYNOPSIS:
+
+== REQUIREMENTS:
+
+== DOWNLOAD/INSTALL:
+
+== LICENSE:
+
+See LICENSE file.

data/Rakefile

@@ -1,104 +1,114 @@
 require 'rubygems'
-require 'rake/gempackagetask'
-require 'rubygems/specification'
+
+USE_RAKE_COMPILER = (RUBY_VERSION =~ /1\.9.*/ || RUBY_PLATFORM =~ /java/) ? false : true
+if USE_RAKE_COMPILER
+  gem 'rake-compiler', '>=0.3.0'
+  require 'rake/extensiontask'
+end
+
 require 'date'
 require 'fileutils'
 require 'rbconfig'
 
-GEM = "ffi"
-GEM_VERSION = "0.2.0"
-AUTHOR = "Wayne Meissner"
-EMAIL = "wmeissner@gmail.com"
-HOMEPAGE = "http://kenai.com/projects/ruby-ffi"
-SUMMARY = "A Ruby foreign function interface (compatible with Rubinius and JRuby FFI)"
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+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}"
+
+# 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.rubyforge.name = 'ffi'
+
+PROJ.readme_file = 'README.rdoc'
+
+# Annoucement
+PROJ.ann.paragraphs
+PROJ.ann.email[:from] = 'wmeissner@gmail.com'
+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.platform = Gem::Platform::RUBY
+PROJ.gem.extensions = %w(ext/ffi_c/extconf.rb gen/Rakefile)
+
+# RDoc
+PROJ.rdoc.exclude << '^ext\/'
+PROJ.rdoc.opts << '-x' << 'ext'
 
-spec = Gem::Specification.new do |s|
-  s.name = GEM
-  s.version = GEM_VERSION
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "LICENSE"]
-  s.summary = SUMMARY
-  s.description = s.summary
-  s.author = AUTHOR
-  s.email = EMAIL
-  s.homepage = HOMEPAGE
-  s.rubyforge_project = 'ffi' 
-  s.extensions = %w(ext/extconf.rb gen/Rakefile)
-  
-  s.require_path = 'lib'
-  s.autorequire = GEM
-  s.files = %w(LICENSE README Rakefile) + Dir.glob("{ext,lib,nbproject,samples,specs}/**/*")
-end
 TEST_DEPS = [ LIBTEST ]
 if RUBY_PLATFORM == "java"
   desc "Run all specs"
   task :specs => TEST_DEPS do
-    sh %{#{Gem.ruby} -S spec #{Dir["specs/**/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -S spec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
   end
   desc "Run rubinius specs"
   task :rbxspecs => TEST_DEPS do
-    sh %{#{Gem.ruby} -S spec #{Dir["specs/rbx/**/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
   end
 else
   TEST_DEPS.unshift :compile
   desc "Run all specs"
   task :specs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -Ibuild -Ilib -S spec #{Dir["specs/**/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ilib -I#{BUILD_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} -Ibuild -Ilib -S spec #{Dir["specs/rbx/**/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -Ilib -I#{BUILD_DIR} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
   end
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
+desc "Build all packages"
+task :package => 'gem:package'
 
-desc "install the gem locally"
-task :install => [:package] do
-  sh %{sudo #{Gem.ruby} -S gem install pkg/#{GEM}-#{GEM_VERSION}}
-end
+desc "Install the gem locally"
+task :install => 'gem:install'
 
-desc "create a gemspec file"
-task :make_spec do
-  File.open("#{GEM}.gemspec", "w") do |file|
-    file.puts spec.to_ruby
+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
-file "build/Makefile" do
-  FileUtils.mkdir_p("build") unless File.directory?("build")
-  sh %{cd build && #{Gem.ruby} ../ext/extconf.rb}
-end
-desc "Compile the native module"
-task :compile => "build/Makefile" do
-  sh %{cd build; make}
 end
 desc "Clean all built files"
 task :clean do
-  sh %{cd build;make distclean} if File.exists?("build/Makefile")
   FileUtils.rm_rf("build")
   FileUtils.rm_rf("conftest.dSYM")
   FileUtils.rm_f(Dir["pkg/*.gem"])
-  FileUtils.rm_f("Makefile")
 end
 task "build/libtest.#{LIBEXT}" do
   sh %{#{GMAKE} -f libtest/GNUmakefile}
 end
-
+desc "Build test helper lib"
+task :libtest => "build/libtest.#{LIBEXT}"
 desc "Test the extension"
 task :test => [ :specs, :rbxspecs ] do
-
 end
 namespace :bench do
   ITER = ENV['ITER'] ? ENV['ITER'].to_i : 100000
-  bench_libs = "-Ibuild -Ilib" unless RUBY_PLATFORM == "java"
+  bench_libs = "-Ilib -I#{BUILD_DIR}" unless RUBY_PLATFORM == "java"
   bench_files = Dir["bench/bench_*.rb"].reject { |f| f == "bench_helper.rb" }
   bench_files.each do |bench|
     task File.basename(bench, ".rb")[6..-1] => TEST_DEPS do
@@ -110,4 +120,4 @@ namespace :bench do
       sh %{#{Gem.ruby} #{bench_libs} #{bench}}
     end
   end
-end
+end

data/ext/{AbstractMemory.c → ffi_c/AbstractMemory.c}

@@ -7,6 +7,7 @@
 #include "compat.h"
 #include "AbstractMemory.h"
 #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);
@@ -15,23 +16,18 @@ 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 caddr_t memory_address(VALUE self);
+static inline char* memory_address(VALUE self);
 VALUE rb_FFI_AbstractMemory_class = Qnil;
 static VALUE classMemory = Qnil;
 static ID to_ptr = 0;
 
-#define ADDRESS(self, offset) (memory_address((self)) + NUM2ULONG(offset))
-#ifndef RARRAY_LEN
-#  define RARRAY_LEN(ary) RARRAY(ary)->len
-#endif
-
 #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) \
 { \
     long off = NUM2LONG(offset); \
-    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self); \
+    AbstractMemory* memory = MEMORY(self); \
     type tmp = (type) toNative(value); \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(memory->address + off, &tmp, sizeof(tmp)); \
@@ -42,7 +38,7 @@ static VALUE \
 memory_get_##name(VALUE self, VALUE offset) \
 { \
     long off = NUM2LONG(offset); \
-    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self); \
+    AbstractMemory* memory = MEMORY(self); \
     type tmp; \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(&tmp, memory->address + off, sizeof(tmp)); \
@@ -54,13 +50,12 @@ memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
 { \
     long count = RARRAY_LEN(ary); \
     long off = NUM2LONG(offset); \
-    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self); \
-    caddr_t address = memory->address; \
+    AbstractMemory* memory = MEMORY(self); \
     long i; \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; i++) { \
-        type tmp = (type) toNative(rb_ary_entry(ary, i)); \
-        memcpy(address + off + (i * sizeof(type)), &tmp, sizeof(tmp)); \
+        type tmp = (type) toNative(RARRAY_PTR(ary)[i]); \
+        memcpy(memory->address + off + (i * sizeof(type)), &tmp, sizeof(tmp)); \
     } \
     return self; \
 } \
@@ -70,35 +65,33 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
 { \
     long count = NUM2LONG(length); \
     long off = NUM2LONG(offset); \
-    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self); \
-    caddr_t address = memory->address; \
-    long last = off + count; \
+    AbstractMemory* memory = MEMORY(self); \
     long i; \
     checkBounds(memory, off, count * sizeof(type)); \
     VALUE retVal = rb_ary_new2(count); \
-    for (i = off; i < last; ++i) { \
+    for (i = 0; i < count; ++i) { \
         type tmp; \
-        memcpy(&tmp, address + (i * sizeof(type)), sizeof(tmp)); \
+        memcpy(&tmp, memory->address + off + (i * sizeof(type)), sizeof(tmp)); \
         rb_ary_push(retVal, fromNative(tmp)); \
     } \
     return retVal; \
 }
 
 NUM_OP(int8, int8_t, NUM2INT, INT2NUM);
-NUM_OP(uint8, u_int8_t, NUM2UINT, UINT2NUM);
+NUM_OP(uint8, uint8_t, NUM2UINT, UINT2NUM);
 NUM_OP(int16, int16_t, NUM2INT, INT2NUM);
-NUM_OP(uint16, u_int16_t, NUM2UINT, UINT2NUM);
+NUM_OP(uint16, uint16_t, NUM2UINT, UINT2NUM);
 NUM_OP(int32, int32_t, NUM2INT, INT2NUM);
-NUM_OP(uint32, u_int32_t, NUM2UINT, UINT2NUM);
+NUM_OP(uint32, uint32_t, NUM2UINT, UINT2NUM);
 NUM_OP(int64, int64_t, NUM2LL, LL2NUM);
-NUM_OP(uint64, u_int64_t, NUM2ULL, ULL2NUM);
+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 = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* memory = MEMORY(self);
     long off = NUM2LONG(offset);
     const int type = TYPE(value);
     checkBounds(memory, off, sizeof(void *));
@@ -117,12 +110,8 @@ memory_put_pointer(VALUE self, VALUE offset, VALUE 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);
-        if (rb_obj_is_kind_of(ptr, rb_FFI_Pointer_class) && TYPE(ptr) == T_DATA) {
-            void* tmp = memory_address(ptr);
-            memcpy(memory->address + off, &tmp, sizeof(tmp));
-        } else {
-            rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
-        }
+        void* tmp = MEMORY_PTR(ptr);
+        memcpy(memory->address + off, &tmp, sizeof(tmp));
     } else {
         rb_raise(rb_eArgError, "value is not a pointer");
     }
@@ -132,18 +121,36 @@ memory_put_pointer(VALUE self, VALUE offset, VALUE value)
 static VALUE
 memory_get_pointer(VALUE self, VALUE offset)
 {
-    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* memory = MEMORY(self);
     long off = NUM2LONG(offset);
-    caddr_t tmp;
+    void* tmp;
     checkBounds(memory, off, sizeof(tmp));
     memcpy(&tmp, memory->address + off, sizeof(tmp));
     return rb_FFI_Pointer_new(tmp);
 }
 
+static VALUE
+memory_put_callback(VALUE self, VALUE offset, VALUE proc, VALUE cbInfo)
+{
+    AbstractMemory* memory = MEMORY(self);
+    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);
+        void* code = ((NativeCallback *) DATA_PTR(callback))->code;
+        memcpy(memory->address + off, &code, sizeof(code));
+    } else {
+        rb_raise(rb_eArgError, "parameter is not a proc");
+    }
+
+    return self;
+}
+
 static VALUE
 memory_clear(VALUE self)
 {
-    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* ptr = MEMORY(self);
     memset(ptr->address, 0, ptr->size);
     return self;
 }
@@ -151,16 +158,16 @@ memory_clear(VALUE self)
 static VALUE
 memory_size(VALUE self) 
 {
-    return LONG2FIX(((AbstractMemory *) DATA_PTR(self))->size);
+    return LONG2FIX((MEMORY(self))->size);
 }
 
 static VALUE
 memory_get_string(int argc, VALUE* argv, VALUE self)
 {
     VALUE length = Qnil, offset = Qnil;
-    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* ptr = MEMORY(self);
     long off, len;
-    caddr_t end;
+    char* end;
     int nargs = rb_scan_args(argc, argv, "11", &offset, &length);
 
     off = NUM2LONG(offset);
@@ -174,7 +181,7 @@ memory_get_string(int argc, VALUE* argv, VALUE self)
 static VALUE
 memory_put_string(VALUE self, VALUE offset, VALUE str)
 {
-    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* ptr = MEMORY(self);
     long off, len;
 
     off = NUM2LONG(offset);
@@ -191,7 +198,7 @@ memory_put_string(VALUE self, VALUE offset, VALUE str)
 static VALUE
 memory_get_bytes(VALUE self, VALUE offset, VALUE length)
 {
-    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* ptr = MEMORY(self);
     long off, len;
     
     off = NUM2LONG(offset);
@@ -203,7 +210,7 @@ memory_get_bytes(VALUE self, VALUE offset, VALUE length)
 static VALUE
 memory_put_bytes(int argc, VALUE* argv, VALUE self)
 {
-    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* ptr = MEMORY(self);
     VALUE offset = Qnil, str = Qnil, rbIndex = Qnil, rbLength = Qnil;
     long off, len, idx;
     int nargs = rb_scan_args(argc, argv, "22", &offset, &str, &rbIndex, &rbLength);
@@ -225,10 +232,21 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
-static inline caddr_t
-memory_address(VALUE self)
+static inline char*
+memory_address(VALUE obj)
 {
-    return ((AbstractMemory *)DATA_PTR((self)))->address;
+    return ((AbstractMemory *) DATA_PTR(obj))->address;
+}
+
+AbstractMemory*
+rb_FFI_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");
 }
 
 void
@@ -280,14 +298,23 @@ rb_FFI_AbstractMemory_Init()
     }
     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");
+    rb_define_alias(classMemory, "get_float", "get_float32");
     rb_define_method(classMemory, "put_array_of_float32", memory_put_array_of_float32, 2);
     rb_define_method(classMemory, "get_array_of_float32", memory_get_array_of_float32, 2);
+    rb_define_alias(classMemory, "put_array_of_float", "put_array_of_float32");
+    rb_define_alias(classMemory, "get_array_of_float", "get_array_of_float32");
     rb_define_method(classMemory, "put_float64", memory_put_float64, 2);
     rb_define_method(classMemory, "get_float64", memory_get_float64, 1);
+    rb_define_alias(classMemory, "put_double", "put_float64");
+    rb_define_alias(classMemory, "get_double", "get_float64");
     rb_define_method(classMemory, "put_array_of_float64", memory_put_array_of_float64, 2);
     rb_define_method(classMemory, "get_array_of_float64", memory_get_array_of_float64, 2);
+    rb_define_alias(classMemory, "put_array_of_double", "put_array_of_float64");
+    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_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);

data/ext/{AbstractMemory.h → ffi_c/AbstractMemory.h}

@@ -1,21 +1,16 @@
-/* 
- * File:   AbstractMemory.h
- * Author: wayne
- *
- * Created on August 28, 2008, 5:52 PM
- */
-
 #ifndef _ABSTRACTMEMORY_H
 #define	_ABSTRACTMEMORY_H
 
+#include <sys/param.h>
 #include <sys/types.h>
+#include <stdint.h>
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
 typedef struct {
-    caddr_t address;
+    char* address; // Use char* instead of void* to ensure adding to it works correctly
     long size;
 } AbstractMemory;
 
@@ -28,6 +23,13 @@ checkBounds(AbstractMemory* mem, long off, long len)
     }
 }
 
+#define MEMORY(obj) rb_FFI_AbstractMemory_cast((obj), rb_FFI_AbstractMemory_class)
+#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 VALUE rb_FFI_AbstractMemory_class;
 #ifdef	__cplusplus
 }
 #endif