ffi 0.4.0 → 0.5.0

data/lib/ffi/union.rb

@@ -1,17 +1,12 @@
 require 'ffi/struct'
 
 module FFI
-  class UnionLayoutBuilder < FFI::StructLayoutBuilder
-    private
-    def calc_alignment_of(field_class, offset); 0; end
-    def calc_current_size(offset, size)
-      @size = size if size > @size
-    end
-  end
+
   class Union < FFI::Struct
-    private
     def self.builder
-      UnionLayoutBuilder.new
+      b = StructLayoutBuilder.new
+      b.union = true
+      b
     end
   end
 end

data/lib/ffi/variadic.rb

@@ -1,10 +1,5 @@
 module FFI
-  class VariadicInvoker
-    def VariadicInvoker.new(function, arg_types, rb_ret_type, ret_type, options)
-      invoker = self.__new(function, rb_ret_type, ret_type, options[:convention].to_s, options[:enums])
-      invoker.init(arg_types, options[:type_map])
-      invoker
-    end
+  class VariadicInvoker    
     def init(arg_types, type_map)
       @fixed = Array.new
       @type_map = type_map

data/spec/ffi/buffer_spec.rb

@@ -194,3 +194,9 @@ describe "Buffer#put_pointer" do
     p2.get_uint(0).should == 0xdeadbeef
   end
 end
+describe "Buffer#size" do
+  it "should return size" do
+    buf = FFI::Buffer.new 14
+    buf.size.should == 14
+  end
+end

data/spec/ffi/callback_spec.rb

@@ -157,7 +157,7 @@ describe "Callback" do
   it "returning :uint (0xffffffff)" do
     LibTest.testCallbackVrU32 { 0xffffffff }.should == 0xffffffff
   end
-  it "Callback returning :uint (-1)" do
+  it "returning :uint (-1)" do
     LibTest.testCallbackVrU32 { -1 }.should == 0xffffffff
   end
   it "returning :long (0)" do
@@ -233,6 +233,7 @@ describe "Callback" do
     it 'could be anonymous' do
       module LibTest
         extend FFI::Library
+        ffi_lib TestLibrary::PATH
         attach_function :testCallbackVrS8, :testClosureVrB, [ callback([ ], :char) ], :char
       end
       LibTest.testCallbackVrS8 { 0 }.should == 0
@@ -244,6 +245,7 @@ describe "Callback" do
     it "should not blow up when a callback is defined that returns a callback" do
       module LibTest
         extend FFI::Library
+        ffi_lib TestLibrary::PATH
         callback :cb_return_type_1, [ :short ], :short
         callback :cb_lookup_1, [ :short ], :cb_return_type_1
         attach_function :testReturnsCallback_1, :testReturnsClosure, [ :cb_lookup_1, :short ], :cb_return_type_1
@@ -253,6 +255,7 @@ describe "Callback" do
     it "should return a callback" do
       module LibTest
         extend FFI::Library
+        ffi_lib TestLibrary::PATH
         callback :cb_return_type, [ :int ], :int
         callback :cb_lookup, [ ], :cb_return_type
         attach_function :testReturnsCallback, :testReturnsClosure, [ :cb_lookup, :int ], :int
@@ -279,6 +282,7 @@ describe "Callback" do
     it "should return a method callback" do
       module LibTest
         extend FFI::Library
+        ffi_lib TestLibrary::PATH
         callback :cb_return_type, [ :int ], :int
         callback :cb_lookup, [ ], :cb_return_type
         attach_function :testReturnsCallback, :testReturnsClosure, [ :cb_lookup, :int ], :int
@@ -298,6 +302,7 @@ describe "Callback" do
     it 'should not blow up when a callback takes a callback as argument' do
       module LibTest
         extend FFI::Library
+        ffi_lib TestLibrary::PATH
         callback :cb_argument, [ :int ], :int
         callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
         attach_function :testCallbackAsArgument, :testArgumentClosure, [ :cb_with_cb_argument, :int ], :int
@@ -306,6 +311,7 @@ describe "Callback" do
     it 'should be able to use the callback argument' do
       module LibTest
         extend FFI::Library
+        ffi_lib TestLibrary::PATH
         callback :cb_argument, [ :int ], :int
         callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
         attach_function :testCallbackAsArgument, :testArgumentClosure, [ :cb_with_cb_argument, :cb_argument, :int ], :int
@@ -328,6 +334,7 @@ describe "Callback" do
     it 'function returns callable object' do
       module LibTest
         extend FFI::Library
+        ffi_lib TestLibrary::PATH
         callback :funcptr, [ :int ], :int
         attach_function :testReturnsFunctionPointer, [  ], :funcptr
       end
@@ -337,7 +344,7 @@ describe "Callback" do
   end
 
 end
-describe "primitive argument" do
+describe "Callback with " do
   #
   # Test callbacks that take an argument, returning void
   #
@@ -355,6 +362,8 @@ describe "primitive argument" do
 
     callback :cbLrV, [ :long ], :void
     callback :cbULrV, [ :ulong ], :void
+    callback :cbArV, [ :string ], :void
+    callback :cbPrV, [ :pointer], :void
 
     callback :cbS64rV, [ :long_long ], :void
     attach_function :testCallbackCrV, :testClosureBrV, [ :cbS8rV, :char ], :void
@@ -369,6 +378,8 @@ describe "primitive argument" do
     attach_function :testCallbackULrV, :testClosureULrV, [ :cbULrV, :ulong ], :void
 
     attach_function :testCallbackLLrV, :testClosureLLrV, [ :cbS64rV, :long_long ], :void
+    attach_function :testCallbackArV, :testClosurePrV, [ :cbArV, :string ], :void
+    attach_function :testCallbackPrV, :testClosurePrV, [ :cbPrV, :pointer], :void
   end
   it ":char (0) argument" do
     v = 0xdeadbeef
@@ -556,5 +567,25 @@ describe "primitive argument" do
     LibTest.testCallbackLLrV(-1) { |i| v = i }
     v.should == -1
   end
-  
+  it ":string argument" do
+    v = nil
+    LibTest.testCallbackArV("Hello, World") { |i| v = i }
+    v.should == "Hello, World"
+  end
+  it ":string (nil) argument" do
+    v = "Hello, World"
+    LibTest.testCallbackArV(nil) { |i| v = i }
+    v.should be_nil
+  end
+  it ":pointer argument" do
+    v = nil
+    magic = FFI::Pointer.new(0xdeadbeef)
+    LibTest.testCallbackPrV(magic) { |i| v = i }
+    v.should == magic
+  end
+  it ":pointer (nil) argument" do
+    v = "Hello, World"
+    LibTest.testCallbackPrV(nil) { |i| v = i }
+    v.should == FFI::Pointer::NULL
+  end
 end # unless true

data/spec/ffi/function_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe FFI::Function do
+  before do
+    module LibTest
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      attach_function :testFunctionAdd, [:int, :int, :pointer], :int
+    end
+    @libtest = FFI::DynamicLibrary.open(TestLibrary::PATH, 
+                                        FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
+  end
+  it 'is initialized with a signature and a block' do
+    FFI::Function.new(:int, []) { }
+  end
+  it 'raises an error when passing a wrong signature' do
+    lambda { FFI::Function.new([], :int).new { } }.should raise_error TypeError 
+  end
+  it 'returns a native pointer' do
+    FFI::Function.new(:int, []) { }.kind_of? FFI::Pointer
+  end
+  it 'can be used as callback from C passing to it a block' do
+    function_add = FFI::Function.new(:int, [:int, :int]) { |a, b| a + b }
+    LibTest.testFunctionAdd(10, 10, function_add).should == 20
+  end
+  it 'can be used as callback from C passing to it a Proc object' do
+    function_add = FFI::Function.new(:int, [:int, :int], Proc.new { |a, b| a + b })
+    LibTest.testFunctionAdd(10, 10, function_add).should == 20
+  end
+  it 'can be used to wrap an existing function pointer' do
+    FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd')).call(10, 10).should == 20
+  end
+  it 'can be attached to a module' do
+    module Foo; end
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    fp.attach(Foo, 'add')
+    Foo.add(10, 10).should == 20
+  end
+  it 'can be used to extend an object' do
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    foo = Object.new
+    class << foo
+      def singleton_class
+        class << self; self; end
+      end
+    end
+    fp.attach(foo.singleton_class, 'add')
+    foo.add(10, 10).should == 20    
+  end
+  it 'can wrap a blocking function' do
+    unless RUBY_VERSION =~ /1.8/
+      fp = FFI::Function.new(:void, [ :int ], @libtest.find_function('testBlocking'), :blocking => true)
+      time = Time.now
+      threads = []
+      threads << Thread.new { fp.call(2) }
+      threads << Thread.new(time) { (Time.now - time).should < 1 }
+      threads.each { |t| t.join }
+    end
+  end
+  it 'autorelease flag is set to true by default' do
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    fp.autorelease?.should be_true
+  end
+  it 'can explicity free itself' do
+    fp = FFI::Function.new(:int, []) { }
+    fp.free
+    lambda { fp.free }.should raise_error RuntimeError
+  end
+  it 'can\'t explicity free itself if not previously allocated' do
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    lambda { fp.free }.should raise_error RuntimeError
+  end
+end

data/spec/ffi/library_spec.rb

@@ -1,57 +1,61 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 describe "Library" do
-  it "attach_function with no library specified" do
-    lambda {
-      Module.new do |m|
-        m.extend FFI::Library
-        attach_function :getpid, [ ], :uint
-      end
-    }.should_not raise_error
-  end
-  it "attach_function :getpid from this process" do
-    lambda {
-      Module.new do |m|
-        m.extend FFI::Library
-        attach_function :getpid, [ ], :uint
-      end.getpid.should == Process.pid
-    }.should_not raise_error
-  end
-  it "attach_function :getpid from [ 'c', 'libc.so.6'] " do
-    lambda {
-      Module.new do |m|
-        m.extend FFI::Library
-        ffi_lib 'c', 'libc.so.6'
-        attach_function :getpid, [ ], :uint
-      end.getpid.should == Process.pid
-    }.should_not raise_error
-  end
-  it "attach_function :getpid from [ 'libc.so.6', 'c' ] " do
-    lambda {
-      Module.new do |m|
-        m.extend FFI::Library
-        ffi_lib 'libc.so.6', 'c'
-        attach_function :getpid, [ ], :uint
-      end.getpid.should == Process.pid
-    }.should_not raise_error
-  end
-  it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef', nil, 'c' ] " do
-    lambda {
-      Module.new do |m|
-        m.extend FFI::Library
-        ffi_lib 'libfubar.so.0xdeadbeef', nil, 'c'
-        attach_function :getpid, [ ], :uint
-      end.getpid.should == Process.pid
-    }.should_not raise_error
-  end
-  it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef' ] " do
-    lambda {
-      Module.new do |m|
-        m.extend FFI::Library
-        ffi_lib 'libfubar.so.0xdeadbeef'
-        attach_function :getpid, [ ], :uint
-      end.getpid.should == Process.pid
-    }.should raise_error(LoadError)
+
+  unless Config::CONFIG['target_os'] =~ /mingw/ || Config::CONFIG['target_os'] =~ /win/
+    it "attach_function with no library specified" do
+      lambda {
+        Module.new do |m|
+          m.extend FFI::Library
+          attach_function :getpid, [ ], :uint
+        end
+      }.should_not raise_error
+    end
+    it "attach_function :getpid from this process" do
+      lambda {
+        Module.new do |m|
+          m.extend FFI::Library
+          attach_function :getpid, [ ], :uint
+        end.getpid.should == Process.pid
+      }.should_not raise_error
+    end
+    it "attach_function :getpid from [ 'c', 'libc.so.6'] " do
+      lambda {
+        Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib 'c', 'libc.so.6'
+          attach_function :getpid, [ ], :uint
+        end.getpid.should == Process.pid
+      }.should_not raise_error
+    end
+    it "attach_function :getpid from [ 'libc.so.6', 'c' ] " do
+      lambda {
+        Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib 'libc.so.6', 'c'
+          attach_function :getpid, [ ], :uint
+        end.getpid.should == Process.pid
+      }.should_not raise_error
+    end
+    it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef', nil, 'c' ] " do
+      lambda {
+        Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib 'libfubar.so.0xdeadbeef', nil, 'c'
+          attach_function :getpid, [ ], :uint
+        end.getpid.should == Process.pid
+      }.should_not raise_error
+    end
+    it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef' ] " do
+      lambda {
+        Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib 'libfubar.so.0xdeadbeef'
+          attach_function :getpid, [ ], :uint
+        end.getpid.should == Process.pid
+      }.should raise_error(LoadError)
+    end
   end
+
   def gvar_lib(name, type)
     Module.new do |m|
       m.extend FFI::Library
@@ -141,4 +145,4 @@ describe "Library" do
     lib.gvar = val
     lib.get.should == val
   end
-end
+end

data/spec/ffi/pointer_spec.rb

@@ -182,13 +182,13 @@ describe "AutoPointer#new" do
   class AutoPointerSubclass < FFI::AutoPointer
     def self.release(ptr); end
   end
-  it "MemoryPointer argument raises ArgumentError" do
+  it "MemoryPointer argument raises TypeError" do
     lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(::TypeError)
   end
-  it "AutoPointer argument raises ArgumentError" do
+  it "AutoPointer argument raises TypeError" do
     lambda { AutoPointerSubclass.new(AutoPointerSubclass.new(LibTest.ptr_from_address(0))) }.should raise_error(::TypeError)
   end
-  it "Buffer argument raises ArgumentError" do
+  it "Buffer argument raises TypeError" do
     lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(::TypeError)
   end
 

data/spec/ffi/struct_callback_spec.rb

@@ -5,11 +5,13 @@ describe FFI::Struct, ' with inline callback functions' do
     module CallbackMember
       extend FFI::Library
       ffi_lib TestLibrary::PATH
+      DUMMY_CB = callback :dummy_cb, [ :int ], :int
       class TestStruct < FFI::Struct
         layout \
           :add, callback([ :int, :int ], :int),
-          :sub, callback([ :int, :int ], :int)
-        end
+          :sub, callback([ :int, :int ], :int),
+          :cb_with_cb_parameter, callback([ DUMMY_CB, :int ], :int)
+      end
       attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
       attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
     end
@@ -22,7 +24,7 @@ describe FFI::Struct, ' with inline callback functions' do
         layout \
           :add, callback([ :int, :int ], :int),
           :sub, callback([ :int, :int ], :int)
-        end
+      end
       attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
       attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
     end
@@ -37,5 +39,26 @@ describe FFI::Struct, ' with inline callback functions' do
 
     CallbackMember.struct_call_add_cb(ts, 1, 2).should == 3
   end
+
+  it 'should return callable object from []' do
+    module CallbackMember
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      class TestStruct < FFI::Struct
+        layout \
+          :add, callback([ :int, :int ], :int),
+          :sub, callback([ :int, :int ], :int)
+      end
+      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
+      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
+    end
+
+    s = CallbackMember::TestStruct.new
+    add = Proc.new { |a,b| a+b}
+    s[:add] = add
+    fn = s[:add]
+    fn.respond_to?(:call).should be_true
+    fn.call(1, 2).should == 3
+  end
 end
 

data/spec/ffi/struct_spec.rb

@@ -379,6 +379,59 @@ describe FFI::Struct, ' with a nested struct field'  do
   end
 end
 
+describe FFI::Struct, ' by value'  do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+
+    class S8S32 < FFI::Struct
+      layout :s8, :char, :s32, :int
+    end
+    attach_function :struct_return_s8s32, [ ], S8S32.by_value
+    attach_function :struct_s8s32_set, [ :char, :int ], S8S32.by_value
+    attach_function :struct_s8s32_get_s8, [ S8S32.by_value ], :char
+    attach_function :struct_s8s32_get_s32, [ S8S32.by_value ], :int
+    attach_function :struct_s8s32_s32_ret_s32, [ S8S32.by_value, :int ], :int
+    attach_function :struct_s8s32_s64_ret_s64, [ S8S32.by_value, :long_long ], :long_long
+  end
+
+  it 'return using pre-set values' do
+    s = LibTest.struct_return_s8s32
+    s[:s8].should == 0x7f
+    s[:s32].should == 0x12345678
+  end
+
+  it 'return using passed in values' do
+    s = LibTest.struct_s8s32_set(123, 456789)
+    s[:s8].should == 123
+    s[:s32].should == 456789
+  end
+
+  it 'parameter' do
+    s = LibTest::S8S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x34567890
+    LibTest.struct_s8s32_get_s8(s).should == 0x12
+    LibTest.struct_s8s32_get_s32(s).should == 0x34567890
+  end
+
+  it 'parameter with following s32' do
+    s = LibTest::S8S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x34567890
+    
+    LibTest.struct_s8s32_s32_ret_s32(s, 0x1eefdead).should == 0x1eefdead
+  end
+
+  it 'parameter with following s64' do
+    s = LibTest::S8S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x34567890
+
+    LibTest.struct_s8s32_s64_ret_s64(s, 0xdeadcafebabe).should == 0xdeadcafebabe
+  end
+end
+
 describe FFI::Struct, ' with an array field'  do
   module LibTest
     extend FFI::Library
@@ -399,9 +452,9 @@ describe FFI::Struct, ' with an array field'  do
     @s = LibTest::StructWithArray.new(LibTest.struct_make_struct_with_array(0, 1, 2, 3, 4))
     @s[:a].to_a.should == [0, 1, 2, 3, 4]
   end
-  it 'should cache array object for successive calls' do
-    @s[:a].object_id.should == @s[:a].object_id
-  end
+#  it 'should cache array object for successive calls' do
+#    @s[:a].object_id.should == @s[:a].object_id
+#  end
   it 'should return the size of the array field in bytes' do
     @s = LibTest::StructWithArray.new(LibTest.struct_make_struct_with_array(0, 1, 2, 3, 4))
     @s[:a].size.should == 20