ffi 0.1.0

data/LICENSE

@@ -0,0 +1,51 @@
+Copyright (c) 2008, JRuby Project
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of the JRuby Project nor the names of its contributors 
+  may be used to endorse or promote products derived from this software 
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Copyright (c) 2007, Evan Phoenix
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of the Evan Phoenix nor the names of its contributors 
+  may be used to endorse or promote products derived from this software 
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require "spec/rake/spectask"
+require 'date'
+require 'fileutils'
+
+GEM = "ffi"
+GEM_VERSION = "0.1.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)"
+
+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)
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{ext,lib,nbproject,samples,specs}/**/*")
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new("specs") do |t|
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = Dir["spec/**/*_spec.rb"].sort
+end
+desc "Run rubinius specs"
+Spec::Rake::SpecTask.new("rbxspecs") do |t|
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = Dir["spec/rbx/*_spec.rb"].sort
+end
+
+if RUBY_PLATFORM == "java"
+  desc "Run specs"
+  task :specs do
+    sh %{#{Gem.ruby} -S spec #{Dir["specs/**/*_spec.rb"].join(" ")} -fs --color}
+  end
+  task :rbxspecs do
+    sh %{#{Gem.ruby} -S spec #{Dir["specs/rbx/**/*_spec.rb"].join(" ")} -fs --color}
+  end
+else
+  desc "Run specs"
+  task :specs do
+    ENV["MRI_FFI"] = "1"
+    sh %{#{Gem.ruby} -S spec #{Dir["specs/**/*_spec.rb"].join(" ")} -fs --color}
+  end
+  task :rbxspecs do
+    ENV["MRI_FFI"] = "1"
+    sh %{#{Gem.ruby} -S spec #{Dir["specs/rbx/**/*_spec.rb"].join(" ")} -fs --color}
+  end
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo #{Gem.ruby} -S gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+file "Makefile" do
+  sh %{#{Gem.ruby} ext/extconf.rb}
+end
+task :compile => "Makefile" do
+  sh %{make}
+end
+task :clean do
+  sh %{make clean} if File.exists?("Makefile")
+  FileUtils.rm_rf("build")
+  FileUtils.rm_f(Dir["pkg/*.gem", "Makefile"])
+end

data/ext/AbstractMemory.c

@@ -0,0 +1,254 @@
+#include <sys/types.h>
+#include <sys/param.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "MemoryPointer.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 caddr_t memory_address(VALUE self);
+VALUE rb_FFI_AbstractMemory_class = Qnil;
+static VALUE classMemory = Qnil;
+
+#define ADDRESS(self, offset) (memory_address((self)) + NUM2ULONG(offset))
+
+#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); \
+    type tmp = (type) toNative(value); \
+    checkBounds(memory, off, sizeof(type)); \
+    memcpy(memory->address + off, &tmp, sizeof(tmp)); \
+    return self; \
+} \
+static VALUE memory_get_##name(VALUE self, VALUE offset); \
+static VALUE \
+memory_get_##name(VALUE self, VALUE offset) \
+{ \
+    long off = NUM2LONG(offset); \
+    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self); \
+    type tmp; \
+    checkBounds(memory, off, sizeof(type)); \
+    memcpy(&tmp, memory->address + off, sizeof(tmp)); \
+    return fromNative(tmp); \
+} \
+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) \
+{ \
+    long count = RARRAY(ary)->len; \
+    long off = NUM2LONG(offset); \
+    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self); \
+    caddr_t address = memory->address; \
+    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)); \
+    } \
+    return self; \
+} \
+static VALUE memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length); \
+static VALUE \
+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; \
+    long i; \
+    checkBounds(memory, off, count * sizeof(type)); \
+    VALUE retVal = rb_ary_new2(count); \
+    for (i = off; i < last; ++i) { \
+        type tmp; \
+        memcpy(&tmp, address + (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(int16, int16_t, NUM2INT, INT2NUM);
+NUM_OP(uint16, u_int16_t, NUM2UINT, UINT2NUM);
+NUM_OP(int32, int32_t, NUM2INT, INT2NUM);
+NUM_OP(uint32, u_int32_t, NUM2UINT, UINT2NUM);
+NUM_OP(int64, int64_t, NUM2LL, LL2NUM);
+NUM_OP(uint64, u_int64_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);
+    long off = NUM2LONG(offset);
+    checkBounds(memory, off, sizeof(void *));
+    if (rb_obj_is_kind_of(value, rb_FFI_MemoryPointer_class)) {        
+        void* tmp = memory_address(value);
+        memcpy(memory->address + off, &tmp, sizeof(tmp));
+    } else if (TYPE(value) == T_NIL) {
+        void* tmp = NULL;
+        memcpy(memory->address + off, &tmp, sizeof(tmp));
+    } else if (TYPE(value) == T_FIXNUM) {
+        uintptr_t tmp = (uintptr_t) FIX2INT(value);
+        memcpy(memory->address + off, &tmp, sizeof(tmp));
+    } else if (TYPE(value) == T_BIGNUM) {
+        uintptr_t tmp = (uintptr_t) NUM2ULL(value);
+        memcpy(memory->address + off, &tmp, sizeof(tmp));
+    } else {
+        rb_raise(rb_eArgError, "value is not a pointer");
+    }
+    return self;
+}
+
+static VALUE
+memory_get_pointer(VALUE self, VALUE offset)
+{
+    AbstractMemory* memory = (AbstractMemory *) DATA_PTR(self);
+    long off = NUM2LONG(offset);
+    caddr_t tmp;
+    checkBounds(memory, off, sizeof(tmp));
+    memcpy(&tmp, memory->address + off, sizeof(tmp));
+    return rb_FFI_MemoryPointer_new(tmp);
+}
+
+static VALUE
+memory_clear(VALUE self)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    memset(ptr->address, 0, ptr->size);
+    return self;
+}
+
+static VALUE
+memory_size(VALUE self) 
+{
+    return LONG2FIX(((AbstractMemory *) DATA_PTR(self))->size);
+}
+
+static VALUE
+memory_get_string(int argc, VALUE* argv, VALUE self)
+{
+    VALUE length = Qnil, offset = Qnil;
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    long off, len;
+    int nargs = rb_scan_args(argc, argv, "11", &offset, &length);
+
+    off = NUM2LONG(offset);    
+    if (nargs > 1) {
+        len = NUM2LONG(length);
+    } else {        
+        caddr_t end;
+        checkBounds(ptr, off, 1);
+        end = memchr(ptr->address + off, 0, ptr->size - off);
+        len = ((end != NULL) ? end - ptr->address: ptr->size) - off;
+    }
+    checkBounds(ptr, off, len);
+    return rb_str_new((char *) ptr->address + off, len);
+}
+
+static VALUE
+memory_put_string(int argc, VALUE* argv, VALUE self)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    VALUE offset = Qnil, str = Qnil, length = Qnil;
+    bool nulTerminate = true;
+    long off, len;
+    int nargs = rb_scan_args(argc, argv, "21", &offset, &str, &length);
+    off = NUM2LONG(offset);
+    len = RSTRING_LEN(str);
+    if (nargs > 2 && length != Qnil) {
+        len = MIN(NUM2ULONG(length), len);
+        nulTerminate = false;
+    }
+    checkBounds(ptr, off, len);
+    memcpy(ptr->address + off, RSTRING_PTR(str), len);
+
+    if (nulTerminate) {
+        char nul = '\0';
+        memcpy(ptr->address + off + len, &nul, sizeof(nul));
+    }
+    return self;
+}
+static inline caddr_t
+memory_address(VALUE self)
+{
+    return ((AbstractMemory *)DATA_PTR((self)))->address;
+}
+
+void
+rb_FFI_AbstractMemory_Init()
+{
+    VALUE moduleFFI = rb_define_module("FFI");
+    rb_FFI_AbstractMemory_class = classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
+#undef INT
+#define INT(type) \
+    rb_define_method(classMemory, "put_" #type, memory_put_##type, 2); \
+    rb_define_method(classMemory, "get_" #type, memory_get_##type, 1); \
+    rb_define_method(classMemory, "put_u" #type, memory_put_u##type, 2); \
+    rb_define_method(classMemory, "get_u" #type, memory_get_u##type, 1); \
+    rb_define_method(classMemory, "put_array_of_" #type, memory_put_array_of_##type, 2); \
+    rb_define_method(classMemory, "get_array_of_" #type, memory_get_array_of_##type, 2); \
+    rb_define_method(classMemory, "put_array_of_u" #type, memory_put_array_of_u##type, 2); \
+    rb_define_method(classMemory, "get_array_of_u" #type, memory_get_array_of_u##type, 2);
+    
+    INT(int8);
+    INT(int16);
+    INT(int32);
+    INT(int64);
+    
+#define ALIAS(name, old) \
+    rb_define_alias(classMemory, "put_" #name, "put_" #old); \
+    rb_define_alias(classMemory, "get_" #name, "get_" #old); \
+    rb_define_alias(classMemory, "put_u" #name, "put_u" #old); \
+    rb_define_alias(classMemory, "get_u" #name, "get_u" #old); \
+    rb_define_alias(classMemory, "put_array_of_" #name, "put_array_of_" #old); \
+    rb_define_alias(classMemory, "get_array_of_" #name, "get_array_of_" #old); \
+    rb_define_alias(classMemory, "put_array_of_u" #name, "put_array_of_u" #old); \
+    rb_define_alias(classMemory, "get_array_of_u" #name, "get_array_of_u" #old);
+    
+    ALIAS(char, int8);
+    ALIAS(short, int16);
+    ALIAS(int, int32);
+    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");
+    } 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");
+    }
+    rb_define_method(classMemory, "put_float32", memory_put_float32, 2);
+    rb_define_method(classMemory, "get_float32", memory_get_float32, 1);
+    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_method(classMemory, "put_float64", memory_put_float64, 2);
+    rb_define_method(classMemory, "get_float64", memory_get_float64, 1);
+    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_method(classMemory, "put_pointer", memory_put_pointer, 2);
+    rb_define_method(classMemory, "get_pointer", memory_get_pointer, 1);
+    rb_define_method(classMemory, "get_string", memory_get_string, -1);
+    rb_define_method(classMemory, "put_string", memory_put_string, -1);
+    rb_define_method(classMemory, "clear", memory_clear, 0);
+    rb_define_method(classMemory, "total", memory_size, 0);
+}
+

data/ext/AbstractMemory.h

@@ -0,0 +1,36 @@
+/* 
+ * File:   AbstractMemory.h
+ * Author: wayne
+ *
+ * Created on August 28, 2008, 5:52 PM
+ */
+
+#ifndef _ABSTRACTMEMORY_H
+#define	_ABSTRACTMEMORY_H
+
+#include <sys/types.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    caddr_t address;
+    long size;
+} AbstractMemory;
+
+static inline void
+checkBounds(AbstractMemory* mem, long off, long len)
+{
+    if ((off | len | (off + len) | (mem->size - (off + len))) < 0) {
+        rb_raise(rb_eIndexError, "Memory access offset=%ld size=%ld is out of bounds",
+                off, len);
+    }
+}
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _ABSTRACTMEMORY_H */
+

data/ext/Buffer.c

@@ -0,0 +1,94 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+
+typedef struct Buffer {
+    AbstractMemory memory;
+    VALUE parent;
+} Buffer;
+
+static VALUE buffer_allocate(VALUE self, VALUE size, VALUE count, VALUE clear);
+static void buffer_release(Buffer* ptr);
+static void buffer_mark(Buffer* ptr);
+
+static VALUE classBuffer = Qnil;
+
+static VALUE
+buffer_allocate(VALUE self, VALUE size, VALUE count, VALUE clear)
+{
+    Buffer* p;
+
+    p = ALLOC(Buffer);
+    memset(p, 0, sizeof(*p));
+    p->memory.size = NUM2LONG(size) * (count == Qnil ? 1 : NUM2LONG(count));
+    p->memory.address = p->memory.size > 0 ? malloc(p->memory.size) : NULL;
+    p->parent = Qnil;
+
+    if (p->memory.address == NULL) {
+        int size = p->memory.size;
+        xfree(p);
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%u bytes", size);
+    }
+    if (TYPE(clear) == T_TRUE) {
+        memset(p->memory.address, 0, p->memory.size);
+    }
+    return Data_Wrap_Struct(classBuffer, buffer_mark, buffer_release, p);
+}
+
+static VALUE
+buffer_plus(VALUE self, VALUE offset)
+{
+    Buffer* ptr = (Buffer *) DATA_PTR(self);
+    Buffer* p;
+    long off = NUM2LONG(offset);
+
+    checkBounds(&ptr->memory, off, 1);
+    p = ALLOC(Buffer);
+    memset(p, 0, sizeof(*p));
+    p->memory.address = ptr->memory.address + off;;
+    p->memory.size = ptr->memory.size - off;
+    p->parent = self;
+    return Data_Wrap_Struct(classBuffer, buffer_mark, buffer_release, p);
+}
+
+static VALUE
+buffer_inspect(VALUE self)
+{
+    Buffer* ptr = (Buffer *) DATA_PTR(self);
+    char tmp[100];
+    snprintf(tmp, sizeof(tmp), "#<Buffer size=%ld>", ptr->memory.size);
+    return rb_str_new2(tmp);
+}
+
+static void
+buffer_release(Buffer* ptr)
+{
+    if (ptr->parent != Qnil && ptr->memory.address != NULL) {
+        free(ptr->memory.address);
+    }
+    xfree(ptr);
+
+}
+static void
+buffer_mark(Buffer* ptr)
+{
+    if (ptr->parent != Qnil) {
+        rb_gc_mark(ptr->parent);
+    }
+}
+
+void
+rb_FFI_Buffer_Init()
+{
+    VALUE moduleFFI = rb_define_module("FFI");
+    classBuffer = rb_define_class_under(moduleFFI, "Buffer", rb_FFI_AbstractMemory_class);
+    rb_define_singleton_method(classBuffer, "__alloc_inout", buffer_allocate, 3);
+    rb_define_singleton_method(classBuffer, "__alloc_out", buffer_allocate, 3);
+    rb_define_singleton_method(classBuffer, "__alloc_in", buffer_allocate, 3);
+    rb_define_method(classBuffer, "inspect", buffer_inspect, 0);
+    rb_define_method(classBuffer, "+", buffer_plus, 1);
+}
+