ffi 0.6.3-x86-mingw32 → 1.0.1-x86-mingw32

data/lib/ffi/types.rb

@@ -1,179 +1,150 @@
 #
-# Copyright (C) 2008, 2009 Wayne Meissner
-# Copyright (C) 2009 Luc Heinrich
-# Copyright (c) 2007, 2008 Evan Phoenix
+# Copyright (C) 2008-2010 Wayne Meissner
 # All rights reserved.
 #
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
+# This file is part of ruby-ffi.
 #
-# * 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 code is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License version 3 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+# version 3 for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
 #
-# 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.
 
 module FFI
-#  TypeDefs = Hash.new
-  def self.add_typedef(current, add)
-    if current.kind_of?(FFI::Type)
-      code = current
-    else
-      code = TypeDefs[current]
-      raise TypeError, "Unable to resolve type '#{current}'" unless code
-    end
 
-    TypeDefs[add] = code
+  def self.typedef(old, add)
+    TypeDefs[add] = self.find_type(old)
   end
-  def self.find_type(name, type_map = nil)
-    type_map = TypeDefs if type_map.nil?
-    code = type_map[name]
-    code = name if !code && name.kind_of?(FFI::Type)
-    raise TypeError, "Unable to resolve type '#{name}'" unless code
-    return code
-  end
-
-  # Converts a char
-  add_typedef(NativeType::INT8, :char)
 
-  # Converts an unsigned char
-  add_typedef(NativeType::UINT8, :uchar)
-
-  # Converts an 8 bit int
-  add_typedef(NativeType::INT8, :int8)
+  def self.add_typedef(old, add)
+    typedef old, add
+  end
 
-  # Converts an unsigned char
-  add_typedef(NativeType::UINT8, :uint8)
 
-  # Converts a short
-  add_typedef(NativeType::INT16, :short)
+  def self.find_type(name, type_map = nil)
+    if name.is_a?(Type)
+      name
 
-  # Converts an unsigned short
-  add_typedef(NativeType::UINT16, :ushort)
+    elsif type_map && type_map.has_key?(name)
+      type_map[name]
 
-  # Converts a 16bit int
-  add_typedef(NativeType::INT16, :int16)
+    elsif TypeDefs.has_key?(name)
+      TypeDefs[name]
 
-  # Converts an unsigned 16 bit int
-  add_typedef(NativeType::UINT16, :uint16)
+    elsif name.is_a?(DataConverter)
+      (type_map || TypeDefs)[name] = Type::Mapped.new(name)
+    
+    else
+      raise TypeError, "unable to resolve type '#{name}'"
+    end
+  end
 
-  # Converts an int
-  add_typedef(NativeType::INT32, :int)
+  TypeDefs.merge!({
+      # The C void type; only useful for function return types
+      :void => Type::VOID,
 
-  # Converts an unsigned int
-  add_typedef(NativeType::UINT32, :uint)
+      # C boolean type
+      :bool => Type::BOOL,
 
-  # Converts a 32 bit int
-  add_typedef(NativeType::INT32, :int32)
+      # C nul-terminated string
+      :string => Type::STRING,
 
-  # Converts an unsigned 16 bit int
-  add_typedef(NativeType::UINT32, :uint32)
+      # C signed char
+      :char => Type::CHAR,
+      # C unsigned char
+      :uchar => Type::UCHAR,
 
-  # Converts a long
-  add_typedef(NativeType::LONG, :long)
+      # C signed short
+      :short => Type::SHORT,
+      # C unsigned short
+      :ushort => Type::USHORT,
 
-  # Converts an unsigned long
-  add_typedef(NativeType::ULONG, :ulong)
+      # C signed int
+      :int => Type::INT,
+      # C unsigned int
+      :uint => Type::UINT,
 
-  # Converts a 64 bit int
-  add_typedef(NativeType::INT64, :int64)
+      # C signed long
+      :long => Type::LONG,
 
-  # Converts an unsigned 64 bit int
-  add_typedef(NativeType::UINT64, :uint64)
+      # C unsigned long
+      :ulong => Type::ULONG,
 
-  # Converts a long long
-  add_typedef(NativeType::INT64, :long_long)
+      # C signed long long integer
+      :long_long => Type::LONG_LONG,
 
-  # Converts an unsigned long long
-  add_typedef(NativeType::UINT64, :ulong_long)
+      # C unsigned long long integer
+      :ulong_long => Type::ULONG_LONG,
 
-  # Converts a float
-  add_typedef(NativeType::FLOAT32, :float)
+      # C single precision float
+      :float => Type::FLOAT,
 
-  # Converts a double
-  add_typedef(NativeType::FLOAT64, :double)
+      # C double precision float
+      :double => Type::DOUBLE,
 
-  # Converts a pointer to opaque data
-  add_typedef(NativeType::POINTER, :pointer)
+      # Native memory address
+      :pointer => Type::POINTER,
 
-  # For when a function has no return value
-  add_typedef(NativeType::VOID, :void)
+      # 8 bit signed integer
+      :int8 => Type::INT8,
+      # 8 bit unsigned integer
+      :uint8 => Type::UINT8,
 
-  # Converts NUL-terminated C strings
-  add_typedef(NativeType::STRING, :string)
+      # 16 bit signed integer
+      :int16 => Type::INT16,
+      # 16 bit unsigned integer
+      :uint16 => Type::UINT16,
 
-  # Converts FFI::Buffer objects
-  add_typedef(NativeType::BUFFER_IN, :buffer_in)
-  add_typedef(NativeType::BUFFER_OUT, :buffer_out)
-  add_typedef(NativeType::BUFFER_INOUT, :buffer_inout)
+      # 32 bit signed integer
+      :int32 => Type::INT32,
+      # 32 bit unsigned integer
+      :uint32 => Type::UINT32,
 
-  add_typedef(NativeType::VARARGS, :varargs)
-  
-  add_typedef(NativeType::ENUM, :enum)
-  add_typedef(NativeType::BOOL, :bool)
+      # 64 bit signed integer
+      :int64 => Type::INT64,
+      # 64 bit unsigned integer
+      :uint64 => Type::UINT64,
 
-  # Use for a C struct with a char [] embedded inside.
-  add_typedef(NativeType::CHAR_ARRAY, :char_array)
+      :buffer_in => Type::BUFFER_IN,
+      :buffer_out => Type::BUFFER_OUT,
+      :buffer_inout => Type::BUFFER_INOUT,
 
-  TypeSizes = {
-    1 => :char,
-    2 => :short,
-    4 => :int,
-    8 => :long_long,
-  }
-  SizeTypes.merge!({
-    NativeType::INT8 => 1,
-    NativeType::UINT8 => 1,
-    NativeType::INT16 => 2,
-    NativeType::UINT16 => 2,
-    NativeType::INT32 => 4,
-    NativeType::UINT32 => 4,
-    NativeType::INT64 => 8,
-    NativeType::UINT64 => 8,
-    NativeType::FLOAT32 => 4,
-    NativeType::FLOAT64 => 8,
-    NativeType::LONG => FFI::Platform::LONG_SIZE / 8,
-    NativeType::ULONG => FFI::Platform::LONG_SIZE / 8,
-    NativeType::POINTER => FFI::Platform::ADDRESS_SIZE / 8,
+      # Used in function prototypes to indicate the arguments are variadic
+      :varargs => Type::VARARGS,
   })
 
-  def self.size_to_type(size)
-    if sz = TypeSizes[size]
-      return sz
+  # Returns a [ String, Pointer ] tuple so the C memory for the string can be freed
+  class StrPtrConverter
+    extend DataConverter
+    native_type Type::POINTER
+
+    def self.from_native(val, ctx)
+      [ val.null? ? Qnil : val.get_string(0), val ]
     end
 
-    # Be like C, use int as the default type size.
-    return :int
   end
+
+  typedef(StrPtrConverter, :strptr)
+
   def self.type_size(type)
-    if sz = SizeTypes[find_type(type)]
-      return sz
-    end
-    raise ArgumentError, "Unknown native type"
+    find_type(type).size
   end
 
   # Load all the platform dependent types
   begin
-    File.open(File.join(FFI::Platform::CONF_DIR, 'types.conf'), "r") do |f|
+    File.open(File.join(Platform::CONF_DIR, 'types.conf'), "r") do |f|
       prefix = "rbx.platform.typedef."
       f.each_line { |line|
         if line.index(prefix) == 0
           new_type, orig_type = line.chomp.slice(prefix.length..-1).split(/\s*=\s*/)
-          add_typedef(orig_type.to_sym, new_type.to_sym)
+          typedef(orig_type.to_sym, new_type.to_sym)
         end
       }
     end

data/lib/ffi/union.rb

@@ -1,3 +1,23 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+#
+# All rights reserved.
+#
+# This file is part of ruby-ffi.
+#
+# This code is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License version 3 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+# version 3 for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+#
+
 require 'ffi/struct'
 
 module FFI

data/lib/ffi/variadic.rb

@@ -1,31 +1,21 @@
 #
 # Copyright (C) 2008, 2009 Wayne Meissner
 # Copyright (C) 2009 Luc Heinrich
-# 
 # All rights reserved.
 #
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
+# This file is part of ruby-ffi.
 #
-# * 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 code is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License version 3 only, as
+# published by the Free Software Foundation.
 #
-# 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.
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+# version 3 for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
 
 module FFI
   class VariadicInvoker    
@@ -33,9 +23,11 @@ module FFI
       @fixed = Array.new
       @type_map = type_map
       arg_types.each_with_index do |type, i|
-        @fixed << type unless type == FFI::NativeType::VARARGS
+        @fixed << type unless type == Type::VARARGS
       end
     end
+
+
     def call(*args, &block)
       param_types = Array.new(@fixed)
       param_values = Array.new
@@ -50,5 +42,24 @@ module FFI
       end
       invoke(param_types, param_values, &block)
     end
+
+    #
+    # Attach the invoker to module +mod+ as +mname+
+    #
+    def attach(mod, mname)
+      invoker = self
+      params = "*args"
+      call = "call"
+      mod.module_eval <<-code
+      @@#{mname} = invoker
+      def self.#{mname}(#{params})
+        @@#{mname}.#{call}(#{params})
+      end
+      def #{mname}(#{params})
+        @@#{mname}.#{call}(#{params})
+      end
+      code
+      invoker
+    end
   end
 end

data/spec/ffi/async_callback_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "async callback" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    AsyncIntCallback = callback [ :int ], :void
+
+#    @blocking = true
+    attach_function :testAsyncCallback, [ AsyncIntCallback, :int ], :void, :blocking => true
+  end
+
+  unless RUBY_VERSION =~ /1.8/
+    it ":int (0x7fffffff) argument" do
+      v = 0xdeadbeef
+      called = false
+      cb = Proc.new {|i| v = i; called = true }
+      LibTest.testAsyncCallback(cb, 0x7fffffff) 
+      called.should be_true
+      v.should == 0x7fffffff
+    end
+  end
+end

data/spec/ffi/callback_spec.rb

@@ -31,6 +31,10 @@ describe "Callback" do
   module LibTest
     extend FFI::Library
     ffi_lib TestLibrary::PATH
+    class S8F32S32 < FFI::Struct
+      layout :s8, :char, :f32, :float, :s32, :int
+    end
+
     callback :cbVrS8, [ ], :char
     callback :cbVrU8, [ ], :uchar
     callback :cbVrS16, [ ], :short
@@ -49,6 +53,10 @@ describe "Callback" do
     callback :cbLrV, [ :long ], :void
     callback :cbULrV, [ :ulong ], :void
     callback :cbLrV, [ :long_long ], :void
+    callback :cbVrT, [ ], S8F32S32.by_value
+    callback :cbTrV, [ S8F32S32.by_value ], :void
+    callback :cbYrV, [ S8F32S32.ptr ], :void
+    callback :cbVrY, [ ], S8F32S32.ptr
 
     attach_function :testCallbackVrS8, :testClosureVrB, [ :cbVrS8 ], :char
     attach_function :testCallbackVrU8, :testClosureVrB, [ :cbVrU8 ], :uchar
@@ -62,7 +70,10 @@ describe "Callback" do
     attach_function :testCallbackVrS64, :testClosureVrLL, [ :cbVrS64 ], :long_long
     attach_function :testCallbackVrU64, :testClosureVrLL, [ :cbVrU64 ], :ulong_long
     attach_function :testCallbackVrP, :testClosureVrP, [ :cbVrP ], :pointer
+    attach_function :testCallbackVrY, :testClosureVrP, [ :cbVrY ], S8F32S32.ptr
     attach_function :testCallbackCrV, :testClosureBrV, [ :cbCrV, :char ], :void
+    attach_function :testCallbackVrT, :testClosureVrT, [ :cbVrT ], S8F32S32.by_value
+    attach_function :testCallbackTrV, :testClosureTrV, [ :cbTrV, S8F32S32.ptr ], :void
     attach_variable :cbVrS8, :gvar_pointer, :cbVrS8
     attach_variable :pVrS8, :gvar_pointer, :pointer
     attach_function :testGVarCallbackVrS8, :testClosureVrB, [ :pointer ], :char
@@ -217,6 +228,33 @@ describe "Callback" do
     LibTest.testCallbackVrP { p }.should == p
   end
 
+
+  it "returning struct by value" do
+    s = LibTest::S8F32S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x1eefbeef
+    s[:f32] = 1.234567
+    ret = LibTest.testCallbackVrT { s }
+    ret[:s8].should == s[:s8]
+    ret[:f32].should == s[:f32]
+    ret[:s32].should == s[:s32]
+
+  end
+
+  it "struct by value parameter" do
+    s = LibTest::S8F32S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x1eefbeef
+    s[:f32] = 1.234567
+    s2 = LibTest::S8F32S32.new
+    LibTest.testCallbackTrV(s) do |struct|
+      s2[:s8] = struct[:s8]
+      s2[:f32] = struct[:f32]
+      s2[:s32] = struct[:s32]
+    end
+  end
+
+  
   it "global variable" do
     proc = Proc.new { 0x1e }
     LibTest.cbVrS8 = proc
@@ -344,6 +382,8 @@ describe "Callback" do
   end
 
 end
+
+
 describe "Callback with " do
   #
   # Test callbacks that take an argument, returning void
@@ -351,6 +391,11 @@ describe "Callback with " do
   module LibTest
     extend FFI::Library
     ffi_lib TestLibrary::PATH
+
+    class S8F32S32 < FFI::Struct
+      layout :s8, :char, :f32, :float, :s32, :int
+    end
+
     callback :cbS8rV, [ :char ], :void
     callback :cbU8rV, [ :uchar ], :void
     callback :cbS16rV, [ :short ], :void
@@ -364,6 +409,7 @@ describe "Callback with " do
     callback :cbULrV, [ :ulong ], :void
     callback :cbArV, [ :string ], :void
     callback :cbPrV, [ :pointer], :void
+    callback :cbYrV, [ S8F32S32.ptr ], :void
 
     callback :cbS64rV, [ :long_long ], :void
     attach_function :testCallbackCrV, :testClosureBrV, [ :cbS8rV, :char ], :void
@@ -380,6 +426,7 @@ describe "Callback with " do
     attach_function :testCallbackLLrV, :testClosureLLrV, [ :cbS64rV, :long_long ], :void
     attach_function :testCallbackArV, :testClosurePrV, [ :cbArV, :string ], :void
     attach_function :testCallbackPrV, :testClosurePrV, [ :cbPrV, :pointer], :void
+    attach_function :testCallbackYrV, :testClosurePrV, [ :cbYrV, S8F32S32.in ], :void
   end
   it ":char (0) argument" do
     v = 0xdeadbeef
@@ -588,4 +635,19 @@ describe "Callback with " do
     LibTest.testCallbackPrV(nil) { |i| v = i }
     v.should == FFI::Pointer::NULL
   end
+  it "struct by reference argument" do
+    v = nil
+    magic = LibTest::S8F32S32.new
+    LibTest.testCallbackYrV(magic) { |i| v = i }
+    v.class.should == magic.class
+    v.pointer == magic.pointer
+  end
+
+  it "struct by reference argument with nil value" do
+    v = LibTest::S8F32S32.new
+    LibTest.testCallbackYrV(nil) { |i| v = i }
+    v.is_a?(FFI::Struct).should be_true
+    v.pointer.should == FFI::Pointer::NULL
+  end
+
 end # unless true