ffi 0.4.0-x86-mswin32

data/lib/ffi/tools/types_generator.rb

@@ -0,0 +1,123 @@
+require 'tempfile'
+
+module FFI
+  class TypesGenerator
+
+    ##
+    # Maps different C types to the C type representations we use
+
+    TYPE_MAP = {
+               "char" => :char,
+        "signed char" => :char,
+      "__signed char" => :char,
+      "unsigned char" => :uchar,
+
+               "short"     => :short,
+        "signed short"     => :short,
+        "signed short int" => :short,
+      "unsigned short"     => :ushort,
+      "unsigned short int" => :ushort,
+
+               "int" => :int,
+        "signed int" => :int,
+      "unsigned int" => :uint,
+
+               "long" => :long,
+               "long int" => :long,
+        "signed long" => :long,
+        "signed long int" => :long,
+      "unsigned long" => :ulong,
+      "unsigned long int" => :ulong,
+      "long unsigned int" => :ulong,
+
+               "long long"     => :long_long,
+               "long long int" => :long_long,
+        "signed long long"     => :long_long,
+        "signed long long int" => :long_long,
+      "unsigned long long"     => :ulong_long,
+      "unsigned long long int" => :ulong_long,
+
+      "char *" => :string,
+      "void *" => :pointer,
+    }
+
+    def self.generate(options = {})
+      typedefs = nil
+      Tempfile.open 'ffi_types_generator' do |io|
+        io.puts <<-C
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/resource.h>
+        C
+
+        io.close
+        typedefs = `gcc -E -x c #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -c #{io.path}`
+      end
+      
+      code = ""
+
+      typedefs.each_line do |type|
+        # We only care about single line typedef
+        next unless type =~ /typedef/
+        # Ignore unions or structs
+        next if type =~ /union|struct/
+        
+        # strip off the starting typedef and ending ;
+        type.gsub!(/^(.*typedef\s*)/, "")
+        type.gsub!(/\s*;\s*$/, "")
+    
+        parts = type.split(/\s+/)
+        def_type   = parts.join(" ")
+
+        # GCC does mapping with __attribute__ stuf, also see
+        # http://hal.cs.berkeley.edu/cil/cil016.html section 16.2.7.  Problem
+        # with this is that the __attribute__ stuff can either occur before or
+        # after the new type that is defined...
+        if type =~ /__attribute__/
+          if parts.last =~ /__QI__|__HI__|__SI__|__DI__|__word__/
+
+            # In this case, the new type is BEFORE __attribute__ we need to
+            # find the final_type as the type before the part that starts with
+            # __attribute__
+            final_type = ""
+            parts.each do |p|
+              break if p =~ /__attribute__/
+              final_type = p
+            end
+          else
+            final_type = parts.pop
+          end
+          
+          def_type = case type
+                     when /__QI__/   then "char"
+                     when /__HI__/   then "short"
+                     when /__SI__/   then "int"
+                     when /__DI__/   then "long long"
+                     when /__word__/ then "long"
+                     else                 "int"
+                     end
+
+          def_type = "unsigned #{def_type}" if type =~ /unsigned/
+        else
+          final_type = parts.pop
+          def_type   = parts.join(" ")
+        end
+        
+        if type = TYPE_MAP[def_type]
+          code << "rbx.platform.typedef.#{final_type} = #{type}\n"
+          TYPE_MAP[final_type] = TYPE_MAP[def_type]
+        else
+          # Fallback to an ordinary pointer if we don't know the type
+          if def_type =~ /\*/
+            code << "rbx.platform.typedef.#{final_type} = pointer\n"
+            TYPE_MAP[final_type] = :pointer
+          end
+        end
+      end
+
+      code
+    end
+
+  end
+end
+

data/lib/ffi/types.rb

@@ -0,0 +1,153 @@
+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
+  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)
+
+  # Converts an unsigned char
+  add_typedef(NativeType::UINT8, :uint8)
+
+  # Converts a short
+  add_typedef(NativeType::INT16, :short)
+
+  # Converts an unsigned short
+  add_typedef(NativeType::UINT16, :ushort)
+
+  # Converts a 16bit int
+  add_typedef(NativeType::INT16, :int16)
+
+  # Converts an unsigned 16 bit int
+  add_typedef(NativeType::UINT16, :uint16)
+
+  # Converts an int
+  add_typedef(NativeType::INT32, :int)
+
+  # Converts an unsigned int
+  add_typedef(NativeType::UINT32, :uint)
+
+  # Converts a 32 bit int
+  add_typedef(NativeType::INT32, :int32)
+
+  # Converts an unsigned 16 bit int
+  add_typedef(NativeType::UINT32, :uint32)
+
+  # Converts a long
+  add_typedef(NativeType::LONG, :long)
+
+  # Converts an unsigned long
+  add_typedef(NativeType::ULONG, :ulong)
+
+  # Converts a 64 bit int
+  add_typedef(NativeType::INT64, :int64)
+
+  # Converts an unsigned 64 bit int
+  add_typedef(NativeType::UINT64, :uint64)
+
+  # Converts a long long
+  add_typedef(NativeType::INT64, :long_long)
+
+  # Converts an unsigned long long
+  add_typedef(NativeType::UINT64, :ulong_long)
+
+  # Converts a float
+  add_typedef(NativeType::FLOAT32, :float)
+
+  # Converts a double
+  add_typedef(NativeType::FLOAT64, :double)
+
+  # Converts a pointer to opaque data
+  add_typedef(NativeType::POINTER, :pointer)
+
+  # For when a function has no return value
+  add_typedef(NativeType::VOID, :void)
+
+  # Converts NUL-terminated C strings
+  add_typedef(NativeType::STRING, :string)
+
+  # 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)
+
+  add_typedef(NativeType::VARARGS, :varargs)
+  
+  add_typedef(NativeType::ENUM, :enum)
+  add_typedef(NativeType::BOOL, :bool)
+
+  # Use for a C struct with a char [] embedded inside.
+  add_typedef(NativeType::CHAR_ARRAY, :char_array)
+
+  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,
+  })
+
+  def self.size_to_type(size)
+    if sz = TypeSizes[size]
+      return sz
+    end
+
+    # Be like C, use int as the default type size.
+    return :int
+  end
+  def self.type_size(type)
+    if sz = SizeTypes[find_type(type)]
+      return sz
+    end
+    raise ArgumentError, "Unknown native type"
+  end
+
+  # Load all the platform dependent types
+  begin
+    File.open(File.join(FFI::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)
+        end
+      }
+    end
+  rescue Errno::ENOENT
+  end
+end

data/lib/ffi/union.rb

@@ -0,0 +1,17 @@
+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
+    end
+  end
+end

data/lib/ffi/variadic.rb

@@ -0,0 +1,30 @@
+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
+    def init(arg_types, type_map)
+      @fixed = Array.new
+      @type_map = type_map
+      arg_types.each_with_index do |type, i|
+        @fixed << type unless type == FFI::NativeType::VARARGS
+      end
+    end
+    def call(*args, &block)
+      param_types = Array.new(@fixed)
+      param_values = Array.new
+      @fixed.each_with_index do |t, i|
+        param_values << args[i]
+      end
+      i = @fixed.length
+      while i < args.length
+        param_types << FFI.find_type(args[i], @type_map)
+        param_values << args[i + 1]
+        i += 2
+      end
+      invoke(param_types, param_values, &block)
+    end
+  end
+end

data/spec/ffi/bool_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "Function with primitive boolean arguments and return values" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :bool_return_true, [ ], :bool
+    attach_function :bool_return_false, [ ], :bool
+    attach_function :bool_return_val, [ :bool ], :bool
+    attach_function :bool_reverse_val, [ :bool ], :bool
+  end
+  it "bools" do
+    LibTest.bool_return_true.should == true
+    LibTest.bool_return_false.should == false
+
+    LibTest.bool_return_val(true).should == true
+    LibTest.bool_return_val(false).should == false
+
+    LibTest.bool_reverse_val(true).should == false
+    LibTest.bool_reverse_val(false).should == true
+  end
+  it "raise error on invalid types" do
+    lambda { LibTest.bool_return_val(nil) }.should raise_error(::TypeError)
+  end
+end

data/spec/ffi/buffer_spec.rb

@@ -0,0 +1,196 @@
+require "rubygems"
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+include FFI
+LongSize = FFI::Platform::LONG_SIZE / 8
+
+describe "Buffer#total" do
+  [1,2,3].each do |i|
+    { :char => 1, :uchar => 1, :short => 2, :ushort => 2, :int => 4, 
+      :uint => 4, :long => LongSize, :ulong => LongSize, 
+      :long_long => 8, :ulong_long => 8, :float => 4, :double => 8
+    }.each_pair do |t, s|
+      it "Buffer.alloc_in(#{t}, #{i}).total == #{i * s}" do
+        Buffer.alloc_in(t, i).total.should == i * s
+      end
+      it "Buffer.alloc_out(#{t}, #{i}).total == #{i * s}" do
+        Buffer.alloc_out(t, i).total.should == i * s
+      end
+      it "Buffer.alloc_inout(#{t}, #{i}).total == #{i * s}" do
+        Buffer.alloc_inout(t, i).total.should == i * s
+      end
+    end
+  end
+end
+
+describe "Buffer#put_char" do
+  bufsize = 4
+  (0..127).each do |i|
+    (0..bufsize-1).each do |offset|
+      it "put_char(#{offset}, #{i}).get_char(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_char(offset, i).get_char(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_uchar" do
+  bufsize = 4
+  (0..255).each do |i|
+    (0..bufsize-1).each do |offset|
+      it "Buffer.put_uchar(#{offset}, #{i}).get_uchar(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_uchar(offset, i).get_uchar(offset).should == i
+      end
+    end
+  end 
+end
+describe "Buffer#put_short" do
+  bufsize = 4
+  [0, 1, 128, 32767].each do |i|
+    (0..bufsize-2).each do |offset|
+      it "put_short(#{offset}, #{i}).get_short(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_short(offset, i).get_short(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_ushort" do
+  bufsize = 4
+  [ 0, 1, 128, 32767, 65535, 0xfee1, 0xdead, 0xbeef, 0xcafe ].each do |i|
+    (0..bufsize-2).each do |offset|
+      it "put_ushort(#{offset}, #{i}).get_ushort(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_ushort(offset, i).get_ushort(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_int" do
+  bufsize = 8
+  [0, 1, 128, 32767, 0x7ffffff ].each do |i|
+    (0..bufsize-4).each do |offset|
+      it "put_int(#{offset}, #{i}).get_int(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_int(offset, i).get_int(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_uint" do
+  bufsize = 8
+  [ 0, 1, 128, 32767, 65535, 0xfee1dead, 0xcafebabe, 0xffffffff ].each do |i|
+    (0..bufsize-4).each do |offset|
+      it "put_uint(#{offset}, #{i}).get_uint(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_uint(offset, i).get_uint(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_long" do
+  bufsize = 16
+  [0, 1, 128, 32767, 0x7ffffff ].each do |i|
+    (0..bufsize-LongSize).each do |offset|
+      it "put_long(#{offset}, #{i}).get_long(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_long(offset, i).get_long(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_ulong" do
+  bufsize = 16
+  [ 0, 1, 128, 32767, 65535, 0xfee1dead, 0xcafebabe, 0xffffffff ].each do |i|
+    (0..bufsize-LongSize).each do |offset|
+      it "put_ulong(#{offset}, #{i}).get_ulong(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_ulong(offset, i).get_ulong(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_long_long" do
+  bufsize = 16
+  [0, 1, 128, 32767, 0x7ffffffffffffff ].each do |i|
+    (0..bufsize-8).each do |offset|
+      it "put_long_long(#{offset}, #{i}).get_long_long(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_long_long(offset, i).get_long_long(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_ulong_long" do
+  bufsize = 16
+  [ 0, 1, 128, 32767, 65535, 0xdeadcafebabe, 0x7fffffffffffffff ].each do |i|
+    (0..bufsize-8).each do |offset|
+      it "put_ulong_long(#{offset}, #{i}).get_ulong_long(#{offset}) == #{i}" do
+        Buffer.alloc_in(bufsize).put_ulong_long(offset, i).get_ulong_long(offset).should == i
+      end
+    end
+  end
+end
+describe "Reading/Writing binary strings" do
+  it "Buffer#put_bytes" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str);
+    s2 = buf.get_bytes(0, 11);
+    s2.should == str
+  end
+  it "Buffer#put_bytes with index and length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str, 5, 6);
+    s2 = buf.get_bytes(0, 6);
+    s2.should == str[5..-1]
+  end
+  it "Buffer#put_bytes with only index" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str, 5);
+    s2 = buf.get_bytes(0, 6);
+    s2.should == str[5..-1]
+  end
+  it "Buffer#put_bytes with index > str.length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.put_bytes(0, str, 12); }.should raise_error
+  end
+  it "Buffer#put_bytes with length > str.length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.put_bytes(0, str, 0, 12); }.should raise_error
+  end
+   it "Buffer#put_bytes with negative index" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.put_bytes(0, str, -1, 12); }.should raise_error
+  end
+end
+describe "Reading/Writing ascii strings" do
+  it "Buffer#put_string with string containing zero byte" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_string(0, str);
+    s2 = buf.get_bytes(0, 11);
+    s2.should == str
+  end
+  it "Buffer#get_string with string containing zero byte" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str);
+    s2 = buf.get_string(0, 11);
+    s2.should == "hello"
+  end
+  it "Buffer#put_string without length should NUL terminate" do
+    str = "hello"
+    buf = FFI::Buffer.new 1024
+    buf.put_string(0, str);
+    s2 = buf.get_bytes(0, 6);
+    s2.should == "hello\0"
+  end
+end
+describe "Buffer#put_pointer" do
+  it "put_pointer(0, p).get_pointer(0) == p" do
+    p = MemoryPointer.new :ulong_long
+    p.put_uint(0, 0xdeadbeef)
+    buf = Buffer.alloc_inout 8
+    p2 = buf.put_pointer(0, p).get_pointer(0)
+    p2.should_not be_nil
+    p2.should == p
+    p2.get_uint(0).should == 0xdeadbeef
+  end
+end