ffi 1.0.1-x86-mingw32 → 1.0.2-x86-mingw32

data/Rakefile

@@ -75,7 +75,7 @@ PROJ.name = 'ffi'
 PROJ.authors = 'Wayne Meissner'
 PROJ.email = 'wmeissner@gmail.com'
 PROJ.url = 'http://wiki.github.com/ffi/ffi'
-PROJ.version = '1.0.1'
+PROJ.version = '1.0.2'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 

data/ext/ffi_c/AbstractMemory.c

@@ -67,6 +67,15 @@ memory_put_##name(VALUE self, VALUE offset, VALUE value) \
     memory_op_put_##name(memory, NUM2LONG(offset), value); \
     return self; \
 } \
+static VALUE memory_write_##name(VALUE self, VALUE value); \
+static VALUE \
+memory_write_##name(VALUE self, VALUE value) \
+{ \
+    AbstractMemory* memory; \
+    Data_Get_Struct(self, AbstractMemory, memory); \
+    memory_op_put_##name(memory, 0, value); \
+    return self; \
+} \
 static VALUE memory_op_get_##name(AbstractMemory* memory, long off); \
 static VALUE \
 memory_op_get_##name(AbstractMemory* memory, long off) \
@@ -85,6 +94,14 @@ memory_get_##name(VALUE self, VALUE offset) \
     Data_Get_Struct(self, AbstractMemory, memory); \
     return memory_op_get_##name(memory, NUM2LONG(offset)); \
 } \
+static VALUE memory_read_##name(VALUE self); \
+static VALUE \
+memory_read_##name(VALUE self) \
+{ \
+    AbstractMemory* memory; \
+    Data_Get_Struct(self, AbstractMemory, memory); \
+    return memory_op_get_##name(memory, 0); \
+} \
 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); \
@@ -103,6 +120,12 @@ memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
     } \
     return self; \
 } \
+static VALUE memory_write_array_of_##name(VALUE self, VALUE ary); \
+static VALUE \
+memory_write_array_of_##name(VALUE self, VALUE ary) \
+{ \
+    return memory_put_array_of_##name(self, INT2FIX(0), ary); \
+} \
 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) \
@@ -120,6 +143,12 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
         rb_ary_push(retVal, fromNative(VAL(tmp, swap))); \
     } \
     return retVal; \
+} \
+static VALUE memory_read_array_of_##name(VALUE self, VALUE length); \
+static VALUE \
+memory_read_array_of_##name(VALUE self, VALUE length) \
+{ \
+    return memory_get_array_of_##name(self, INT2FIX(0), length); \
 }
 
 #define NOSWAP(x) (x)
@@ -492,10 +521,18 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     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, "write_" #type, memory_write_##type, 1); \
+    rb_define_method(classMemory, "read_" #type, memory_read_##type, 0); \
+    rb_define_method(classMemory, "write_u" #type, memory_write_u##type, 1); \
+    rb_define_method(classMemory, "read_u" #type, memory_read_u##type, 0); \
     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);
+    rb_define_method(classMemory, "get_array_of_u" #type, memory_get_array_of_u##type, 2); \
+    rb_define_method(classMemory, "write_array_of_" #type, memory_write_array_of_##type, 1); \
+    rb_define_method(classMemory, "read_array_of_" #type, memory_read_array_of_##type, 1); \
+    rb_define_method(classMemory, "write_array_of_u" #type, memory_write_array_of_u##type, 1); \
+    rb_define_method(classMemory, "read_array_of_u" #type, memory_read_array_of_u##type, 1);
     
     INT(int8);
     INT(int16);
@@ -508,10 +545,18 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     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, "write_" #name, "write_" #old); \
+    rb_define_alias(classMemory, "read_" #name, "read_" #old); \
+    rb_define_alias(classMemory, "write_u" #name, "write_u" #old); \
+    rb_define_alias(classMemory, "read_u" #name, "read_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);
+    rb_define_alias(classMemory, "get_array_of_u" #name, "get_array_of_u" #old); \
+    rb_define_alias(classMemory, "write_array_of_" #name, "write_array_of_" #old); \
+    rb_define_alias(classMemory, "read_array_of_" #name, "read_array_of_" #old); \
+    rb_define_alias(classMemory, "write_array_of_u" #name, "write_array_of_u" #old); \
+    rb_define_alias(classMemory, "read_array_of_u" #name, "read_array_of_u" #old);
     
     ALIAS(char, int8);
     ALIAS(short, int16);
@@ -522,22 +567,35 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     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, "write_float", memory_write_float32, 1);
+    rb_define_method(classMemory, "read_float", memory_read_float32, 0);
     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, "write_array_of_float", memory_write_array_of_float32, 1);
+    rb_define_method(classMemory, "read_array_of_float", memory_read_array_of_float32, 1);
     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, "write_double", memory_write_float64, 1);
+    rb_define_method(classMemory, "read_double", memory_read_float64, 0);
     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, "write_array_of_double", memory_write_array_of_float64, 1);
+    rb_define_method(classMemory, "read_array_of_double", memory_read_array_of_float64, 1);
     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, "write_pointer", memory_write_pointer, 1);
+    rb_define_method(classMemory, "read_pointer", memory_read_pointer, 0);
     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, "write_array_of_pointer", memory_write_array_of_pointer, 1);
+    rb_define_method(classMemory, "read_array_of_pointer", memory_read_array_of_pointer, 1);
+
     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/ffi_c/Struct.c

@@ -44,6 +44,7 @@
 #include "Struct.h"
 #include "StructByValue.h"
 #include "ArrayType.h"
+#include "MappedType.h"
 
 typedef struct InlineArray_ {
     VALUE rbMemory;
@@ -285,8 +286,8 @@ struct_set_pointer(VALUE self, VALUE pointer)
     layout = struct_layout(self);
 
     if (layout->base.ffiType->size > memory->size) {
-        rb_raise(rb_eArgError, "memory of %d bytes too small for struct %s (expected at least %d)",
-                memory->size, rb_obj_classname(self), layout->base.ffiType->size);
+        rb_raise(rb_eArgError, "memory of %ld bytes too small for struct %s (expected at least %ld)",
+                memory->size, rb_obj_classname(self), (long) layout->base.ffiType->size);
     }
     
     s->pointer = MEMORY(pointer);
@@ -399,6 +400,10 @@ inline_array_initialize(VALUE self, VALUE rbMemory, VALUE rbField)
     Data_Get_Struct(array->arrayType->rbComponentType, Type, array->componentType);
     
     array->op = get_memory_op(array->componentType);
+    if (array->op == NULL && array->componentType->nativeType == NATIVE_MAPPED) {
+        array->op = get_memory_op(((MappedType *) array->componentType)->type);
+    }
+    
     array->length = array->arrayType->length;
 
     return self;
@@ -432,7 +437,15 @@ inline_array_aref(VALUE self, VALUE rbIndex)
     Data_Get_Struct(self, InlineArray, array);
 
     if (array->op != NULL) {
-        return array->op->get(array->memory, inline_array_offset(array, NUM2INT(rbIndex)));
+        VALUE rbNativeValue = array->op->get(array->memory, 
+                inline_array_offset(array, NUM2INT(rbIndex)));
+        if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
+            return rb_funcall(((MappedType *) array->componentType)->rbConverter, 
+                    rb_intern("from_native"), 2, rbNativeValue, Qnil);
+        } else {
+            return rbNativeValue; 
+        }
+        
     } else if (array->componentType->nativeType == NATIVE_STRUCT) {
         VALUE rbOffset = INT2NUM(inline_array_offset(array, NUM2INT(rbIndex)));
         VALUE rbLength = INT2NUM(array->componentType->ffiType->size);
@@ -454,8 +467,13 @@ inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
     Data_Get_Struct(self, InlineArray, array);
 
     if (array->op != NULL) {
+        if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
+            rbValue = rb_funcall(((MappedType *) array->componentType)->rbConverter, 
+                    rb_intern("to_native"), 2, rbValue, Qnil);
+        }
         array->op->put(array->memory, inline_array_offset(array, NUM2INT(rbIndex)),
             rbValue);
+        
     } else if (array->componentType->nativeType == NATIVE_STRUCT) {
         int offset = inline_array_offset(array, NUM2INT(rbIndex));
         Struct* s;
@@ -494,25 +512,8 @@ inline_array_each(VALUE self)
 
     Data_Get_Struct(self, InlineArray, array);
     
-    if (array->op != NULL) {
-        for (i = 0; i < array->length; ++i) {
-            int offset = inline_array_offset(array, i);
-            rb_yield(array->op->get(array->memory, offset));
-        }
-    } else if (array->componentType->nativeType == NATIVE_STRUCT) {
-        for (i = 0; i < array->length; ++i) {
-            VALUE rbOffset = UINT2NUM(inline_array_offset(array, i));
-            VALUE rbLength = UINT2NUM(array->componentType->ffiType->size);
-            VALUE rbPointer = rb_funcall(array->rbMemory, rb_intern("slice"), 2, rbOffset, rbLength);
-
-            rb_yield(rb_class_new_instance(1, &rbPointer, ((StructByValue *) array->componentType)->rbStructClass));
-        }
-    } else {
-        ArrayType* arrayType;
-        Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
-
-        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(arrayType->rbComponentType));
-        return Qnil;
+    for (i = 0; i < array->length; ++i) {
+        rb_yield(inline_array_aref(self, INT2FIX(i)));
     }
 
     return self;
@@ -530,8 +531,7 @@ inline_array_to_a(VALUE self)
 
     
     for (i = 0; i < array->length; ++i) {
-        int offset = inline_array_offset(array, i);
-        rb_ary_push(obj, array->op->get(array->memory, offset));
+        rb_ary_push(obj, inline_array_aref(self, INT2FIX(i)));
     }
 
     return obj;

data/lib/ffi/pointer.rb

@@ -27,48 +27,6 @@ module FFI
     def self.size
       SIZE
     end
-    # Write +obj+ as a C int at the memory pointed to.
-    def write_int(obj)
-      put_int32(0, obj)
-    end
-
-    # Read a C int from the memory pointed to.
-    def read_int
-      get_int32(0)
-    end
-
-    # Write +obj+ as a C long at the memory pointed to.
-    def write_long(obj)
-      put_long(0, obj)
-    end
-
-    # Read a C long from the memory pointed to.
-    def read_long
-      get_long(0)
-    end
-    # Write +obj+ as a C long long at the memory pointed to.
-    def write_long_long(obj)
-      put_int64(0, obj)
-    end
-
-    # Read a C long long from the memory pointed to.
-    def read_long_long
-      get_int64(0)
-    end
-
-    def read_pointer
-      get_pointer(0)
-    end
-    def write_pointer(ptr)
-      put_pointer(0, ptr)
-    end
-
-    def read_float
-      get_float32(0)
-    end
-    def write_float(obj)
-      put_float32(0, obj)
-    end
 
     def read_string(len=nil)
       if len
@@ -77,15 +35,19 @@ module FFI
         get_string(0)
       end
     end
+
     def read_string_length(len)
       get_bytes(0, len)
     end
+
     def read_string_to_null
       get_string(0)
     end
+
     def write_string_length(str, len)
       put_bytes(0, str, 0, len)
     end
+
     def write_string(str, len=nil)
       len = str.bytesize unless len
       # Write the string data without NUL termination
@@ -112,29 +74,5 @@ module FFI
       }
       self
     end
-    def read_array_of_int(length)
-      get_array_of_int32(0, length)
-    end
-
-    def write_array_of_int(ary)
-      put_array_of_int32(0, ary)
-    end
-
-    def read_array_of_long(length)
-      get_array_of_long(0, length)
-    end
-
-    def write_array_of_long(ary)
-      put_array_of_long(0, ary)
-    end
-
-    def read_array_of_pointer(length)
-      read_array_of_type(:pointer, :read_pointer, length)
-    end
-
-    def write_array_of_pointer(ary)
-      write_array_of_type(:pointer, :write_pointer, ary)
-    end
-
   end
 end

data/spec/ffi/struct_spec.rb

@@ -306,11 +306,13 @@ describe "Struct tests" do
   end
   module EnumFields
     extend FFI::Library
-    enum :test_enum, [:c1, 10, :c2, 20, :c3, 30, :c4, 40]
+    TestEnum = enum :test_enum, [:c1, 10, :c2, 20, :c3, 30, :c4, 40]
     class TestStruct < FFI::Struct
-      layout :a, :int, :c, :test_enum
+      layout :a, :int, :c, :test_enum, 
+        :d, [ TestEnum, TestEnum.symbols.length ]
     end
   end
+  
   it ":enum field r/w" do
     s = EnumFields::TestStruct.new
     s[:c] = :c3
@@ -318,6 +320,22 @@ describe "Struct tests" do
     s.pointer.get_uint(FFI::Type::INT32.size).should == 30
     s[:c].should == :c3
   end
+  
+  it "array of :enum field" do
+    s = EnumFields::TestStruct.new
+    EnumFields::TestEnum.symbols.each_with_index do |val, i|
+      s[:d][i] = val
+    end
+    
+    EnumFields::TestEnum.symbols.each_with_index do |val, i|
+      s.pointer.get_uint(FFI::Type::INT32.size * (2 + i)).should == EnumFields::TestEnum[val]
+    end
+    
+    s[:d].each_with_index do |val, i|
+      val.should == EnumFields::TestEnum.symbols[i]
+    end
+  end
+  
   module CallbackMember
     extend FFI::Library
     ffi_lib TestLibrary::PATH
@@ -626,13 +644,13 @@ describe "Struct allocation" do
     class S < FFI::Struct
       layout :i, :uint
     end
-    S.new(Pointer::NULL).null?.should be_true
+    S.new(FFI::Pointer::NULL).null?.should be_true
   end
 
   it "null? should be false when initialized with non-NULL pointer" do
     class S < FFI::Struct
       layout :i, :uint
     end
-    S.new(MemoryPointer.new(S)).null?.should be_false
+    S.new(FFI::MemoryPointer.new(S)).null?.should be_false
   end
 end

data/tasks/extension.rake

@@ -14,6 +14,14 @@ spec = Gem::Specification.new do |s|
   s.require_path = 'lib'
   s.files = PROJ.gem.files
   s.add_dependency *PROJ.gem.dependencies.flatten
+  PROJ.gem.extras.each do |msg, val|
+    case val
+    when Proc
+      val.call(s.send(msg))
+    else
+      s.send "#{msg}=", val
+    end
+  end
 end
 
 Rake::ExtensionTask.new('ffi_c', spec) do |ext|

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: ffi
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 2
+  version: 1.0.2
 platform: x86-mingw32
 authors: 
 - Wayne Meissner
@@ -9,19 +14,24 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-03 00:00:00 +10:00
+date: 2010-12-17 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
         version: 0.8.7
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: |-
   Ruby-FFI is a ruby extension for programmatically loading dynamic
   libraries, binding functions within them, and calling those functions
@@ -416,21 +426,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      segments: 
+      - 1
+      - 9
+      - 2
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: ffi
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Ruby-FFI is a ruby extension for programmatically loading dynamic libraries, binding functions within them, and calling those functions from Ruby code