ffi 0.4.0-x86-mswin32 → 0.5.0-x86-mswin32

data/ext/ffi_c/libffi.darwin.mk

@@ -47,9 +47,9 @@ build_ffi = \
 
 $(LIBFFI):
 	@for arch in $(ARCHES); do $(call build_ffi,$$arch);done	
-	# Assemble into a FAT (i386, ppc) library
+	# Assemble into a FAT (x86_64, i386, ppc) library
 	@mkdir -p $(BUILD_DIR)/libffi/.libs
-	env MACOSX_DEPLOYMENT_TARGET=10.4 /usr/bin/libtool -static -o $@ \
+	/usr/bin/libtool -static -o $@ \
 	    $(foreach arch, $(ARCHES),$(BUILD_DIR)/libffi-$(arch)/.libs/libffi_convenience.a)
 	@mkdir -p $(LIBFFI_BUILD_DIR)/include
 	$(RM) $(LIBFFI_BUILD_DIR)/include/ffi.h

data/ext/ffi_c/rbffi.h

@@ -9,9 +9,12 @@ extern "C" {
 
 #define MAX_PARAMETERS (32)
 
+extern VALUE rbffi_FFIModule;
+    
 extern void rbffi_Type_Init(VALUE ffiModule);
 extern void rbffi_Buffer_Init(VALUE ffiModule);
 extern void rbffi_Invoker_Init(VALUE ffiModule);
+extern void rbffi_Variadic_Init(VALUE ffiModule);
 extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
 extern int rbffi_type_size(VALUE type);
 

data/lib/ffi/ffi.rb

@@ -66,7 +66,9 @@ module FFI
     end
     lib
   end
-  def self.create_invoker(lib, name, args, ret_type, native_ret_type, options = { :convention => :default })
+
+
+  def self.create_invoker(lib, name, args, ret_type, options = { :convention => :default })
     # Current artificial limitation based on JRuby::FFI limit
     raise SignatureError, 'FFI functions may take max 32 arguments!' if args.size > 32
 
@@ -85,12 +87,13 @@ module FFI
     raise NotFoundError.new(name, library.name) unless function
 
     args = args.map {|e| find_type(e) }
-    if args.length > 0 && args[args.length - 1] == FFI::NativeType::VARARGS
-      invoker = FFI::VariadicInvoker.new(function, args, ret_type, find_type(native_ret_type), options)
+    invoker = if args.length > 0 && args[args.length - 1] == FFI::NativeType::VARARGS
+      FFI::VariadicInvoker.new(function, args, find_type(ret_type), options)
     else
-      invoker = FFI::Invoker.new(function, args, ret_type, find_type(native_ret_type), options[:convention].to_s, options[:enums])
+      FFI::Function.new(find_type(ret_type), args, function, options)
     end
     raise NotFoundError.new(name, library.name) unless invoker
+
     return invoker
   end
 end

data/lib/ffi/library.rb

@@ -28,6 +28,22 @@ module FFI::Library
   def ffi_convention(convention)
     @ffi_convention = convention
   end
+
+  def ffi_libraries
+    unless defined?(@ffi_libs) or self.name.nil?
+      libs = []
+      # Try the exact name (e.g. User32) and all lower case (e.g. LibC -> libc)
+      [ self.name, self.name.downcase ].each do |name|
+        begin
+          libs << FFI::DynamicLibrary.open(name, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
+        rescue Exception
+        end
+      end
+      @ffi_libs = libs unless libs.empty?
+    end
+    defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
+  end
+
   ##
   # Attach C function +name+ to this module.
   #
@@ -51,15 +67,14 @@ module FFI::Library
 
     # Try to locate the function in any of the libraries
     invokers = []
-    libraries = defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
-    libraries.each do |lib|
+    ffi_libraries.each do |lib|
       begin
-        invokers << FFI.create_invoker(lib, cname.to_s, arg_types, ret_type, find_type(ret_type), options)
+        invokers << FFI.create_invoker(lib, cname.to_s, arg_types, find_type(ret_type), options)
       rescue LoadError => ex
       end if invokers.empty?
     end
     invoker = invokers.compact.shift
-    raise FFI::NotFoundError.new(cname.to_s, libraries.map { |lib| lib.name }) unless invoker
+    raise FFI::NotFoundError.new(cname.to_s, ffi_libraries.map { |lib| lib.name }) unless invoker
 
     # Setup the parameter list for the module function as (a1, a2)
     arity = arg_types.length
@@ -91,71 +106,31 @@ module FFI::Library
   end
   def attach_variable(mname, a1, a2 = nil)
     cname, type = a2 ? [ a1, a2 ] : [ mname.to_s, a1 ]
-    libraries = defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
     address = nil
-    libraries.each do |lib|
+    ffi_libraries.each do |lib|
       begin
         address = lib.find_variable(cname.to_s)
         break unless address.nil?
       rescue LoadError
       end
     end
-    raise FFI::NotFoundError.new(cname, libraries) if address.nil?
-    case ffi_type = find_type(type)
-    when :pointer, FFI::NativeType::POINTER
-      op = :pointer
-    when :char, FFI::NativeType::INT8
-      op = :int8
-    when :uchar, FFI::NativeType::UINT8
-      op = :uint8
-    when :short, FFI::NativeType::INT16
-      op = :int16
-    when :ushort, FFI::NativeType::UINT16
-      op = :uint16
-    when :int, FFI::NativeType::INT32
-      op = :int32
-    when :uint, FFI::NativeType::UINT32
-      op = :uint32
-    when :long, FFI::NativeType::LONG
-      op = :long
-    when :ulong, FFI::NativeType::ULONG
-      op = :ulong
-    when :long_long, FFI::NativeType::INT64
-      op = :int64
-    when :ulong_long, FFI::NativeType::UINT64
-      op = :uint64
-    else
-      if ffi_type.is_a?(FFI::CallbackInfo)
-        op = :callback
-      else
-        raise TypeError, "Cannot access library variable of type #{type}"
-      end
-    end
+
+    raise FFI::NotFoundError.new(cname, ffi_libraries) if address.nil? || address.null?
+    s = FFI::Struct.new(address, :gvar, find_type(type))
+    
     #
     # Attach to this module as mname/mname=
     #
-    if op == :callback
-      self.module_eval <<-code
-        @@ffi_gvar_#{mname} = address
-        @@ffi_gvar_#{mname}_cbinfo = ffi_type
-        def self.#{mname}
-          raise ArgError, "Cannot get callback fields"
-        end
-        def self.#{mname}=(value)
-          @@ffi_gvar_#{mname}.put_callback(0, value, @@ffi_gvar_#{mname}_cbinfo)
-        end
-        code
-    else
-      self.module_eval <<-code
-        @@ffi_gvar_#{mname} = address
-        def self.#{mname}
-          @@ffi_gvar_#{mname}.get_#{op.to_s}(0)
-        end
-        def self.#{mname}=(value)
-          @@ffi_gvar_#{mname}.put_#{op.to_s}(0, value)
-        end
-        code
-    end
+    self.module_eval <<-code
+      @@ffi_gvar_#{mname} = s
+      def self.#{mname}
+        @@ffi_gvar_#{mname}[:gvar]
+      end
+      def self.#{mname}=(value)
+        @@ffi_gvar_#{mname}[:gvar] = value
+      end
+    code
+    
     address
   end
 

data/lib/ffi/platform.rb

@@ -17,8 +17,9 @@ module FFI
     when /win|mingw/
       "windows"
     else
-      raise FFI::PlatformError, "Unknown operating system: #{Config::CONFIG['host_os']}"
+      Config::CONFIG['host_os'].downcase
     end
+
     ARCH = case CPU.downcase
     when /amd64|x86_64/
       "x86_64"
@@ -27,8 +28,9 @@ module FFI
     when /ppc|powerpc/
       "powerpc"
     else
-      raise FFI::PlatformError, "Unknown cpu architecture: #{ARCH_}"
+      Config::CONFIG['host_cpu']
     end
+
     private
     def self.is_os(os)
       OS == os
@@ -43,6 +45,7 @@ module FFI
     IS_BSD = IS_MAC || IS_FREEBSD || IS_OPENBSD
     CONF_DIR = File.dirname(__FILE__)
     public
+
     LIBC = if IS_WINDOWS
       "msvcrt"
     elsif IS_LINUX
@@ -50,26 +53,33 @@ module FFI
     else
       "c"
     end
+
     LIBPREFIX = IS_WINDOWS ? '' : 'lib'
+
     LIBSUFFIX = case OS
     when /darwin/
       'dylib'
     when /linux|bsd|solaris/
       'so'
-    when /win/
+    when /windows/
       'dll'
     else
-      raise PlatformError, "Cannot determine shared library extension for #{OS}"
+      # Punt and just assume a sane unix (i.e. anything but AIX)
+      'so'
     end
+
     def self.bsd?
       IS_BSD
     end
+
     def self.windows?
       IS_WINDOWS
     end
+
     def self.mac?
       IS_MAC
     end
+
     def self.unix?
       !IS_WINDOWS
     end

data/lib/ffi/struct.rb

@@ -2,353 +2,182 @@ require 'ffi/platform'
 module FFI
 
   class StructLayout
-    attr_reader :size, :align
 
-    def members
-      @field_names
-    end
     def offsets
-      @fields.map { |name, field| [name, field.offset] }.sort { |a, b| a[1] <=> b[1] }
+      members.map { |m| [ m, self[m].offset ] }
     end
+
     def offset_of(field_name)
-      @fields[field_name].offset
+      self[field_name].offset
     end
   end
 
-  class StructLayoutBuilder
-    class Field
-      def size
-        self.class.size
-      end
-      def align
-        self.class.align
-      end
-      def offset
-        @off
-      end
-      def self.size
-        const_get(:SIZE)
-      end
-      def self.align
-        const_get(:ALIGN)
-      end
-    end
-
-    def self.struct_field_class_from(type)
-      klass_name = type.name.split('::').last
-      code = <<-code
-      class StructField_#{klass_name} < Field
-        @info = #{type}
-          class << self
-            attr_reader :info
-            def size
-              #{type.size}
-            end
-            def align
-              #{type.align}
-            end
-          end
-        def get(ptr)
-          self.class.info.new(ptr + @off)
-        end
-      end
-      StructField_#{klass_name}
-      code
-      self.module_eval(code)
-    end
-
-    def self.array_field_class_from(type, num)
-      klass_name = type.name.split('::').last
-      code = <<-code
-      class ArrayField_#{klass_name}_#{num} < Field
-        @info = #{type}
-        @num = #{num}
-          class << self
-            attr_reader :info, :num
-            def size
-              #{type.size} * #{num}
-            end
-            def align
-              #{type.align}
-            end
-          end
-        def get(ptr)
-          @array ? @array : get_array_data(ptr)
-        end
-        private
-        def get_array_data(ptr)
-          @array = FFI::Struct::Array.new(ptr + @off, self.class.info, self.class.num)
-        end
-      end
-      ArrayField_#{klass_name}_#{num}
-      code
-      self.module_eval(code)
-    end
-
-    class CallbackField < Field
-      def self.size
-        FFI::Type::POINTER.size
-      end
-
-      def self.align
-        FFI::Type::POINTER.alignment
-      end
-
-      def put(ptr, proc)
-        ptr.put_callback(@off, proc, @info)
-      end
+  
+  class Struct
 
-      def get(ptr)
-        raise ArgumentError, "Cannot get callback fields"
-      end
+    def size
+      self.class.size
     end
 
-    def initialize
-      @field_names = []
-      @fields = {}
-      @size = 0
-      @min_align = 1
+    def alignment
+      self.class.alignment
     end
+    alias_method :align, :alignment
 
-    def native_field_class_from(type)
-      case type
-      when :char, NativeType::INT8
-        Signed8
-      when :uchar, NativeType::UINT8
-        Unsigned8      
-      when :short, NativeType::INT16
-        Signed16
-      when :ushort, NativeType::UINT16
-        Unsigned16
-      when :long, NativeType::LONG
-        FFI::Platform::LONG_SIZE == 32 ? Signed32 : Signed64
-      when :ulong, NativeType::ULONG
-        FFI::Platform::LONG_SIZE == 32 ? Unsigned32 : Unsigned64
-      when :int, NativeType::INT32
-        Signed32
-      when :uint, NativeType::UINT32
-        Unsigned32
-      when :long_long, NativeType::INT64
-        Signed64
-      when :ulong_long, NativeType::UINT64
-        Unsigned64
-      when :float, NativeType::FLOAT32
-        FloatField
-      when :double, NativeType::FLOAT64
-        DoubleField
-      when :pointer, NativeType::POINTER
-        PointerField
-      when :string, NativeType::STRING
-        StringField
-      end
+    def offset_of(name)
+      self.class.offset_of(name)
     end
 
-    def callback_field_class_from(type)
-      return CallbackField, type if type.is_a?(FFI::CallbackInfo)
+    def members
+      self.class.members
     end
 
-    def struct_field_class_from(type)
-      self.class.struct_field_class_from(type) if type.is_a?(Class) and type < FFI::Struct
+    def values
+      members.map { |m| self[m] }
     end
 
-    def array_field_class_from(type)
-      self.class.array_field_class_from(field_class_from(type[0]), type[1]) if type.is_a?(Array)
+    def offsets
+      self.class.offsets
     end
 
-    def field_class_from(type)
-      field_class = native_field_class_from(type) ||
-        callback_field_class_from(type) ||
-        array_field_class_from(type) ||
-        struct_field_class_from(type)
-      field_class or raise ArgumentError, "Unknown type: #{type}"
+    def clear
+      pointer.clear
+      self
     end
 
-    def add_field(name, type, offset = nil)
-      field_class, info = field_class_from(type)
-      off = calc_alignment_of(field_class, offset)
-      calc_current_size(off, field_class.size)
-      @field_names << name
-      @fields[name] = field_class.new(off, info)
-      @min_align = field_class.align if field_class.align > @min_align
+    def to_ptr
+      pointer
     end
 
-    def build
-      StructLayout.new(@field_names, @fields, align(@size, @min_align), @min_align)
+    def self.size
+      defined?(@layout) ? @layout.size : defined?(@size) ? @size : 0
     end
 
-    def align(offset, align)
-      align + ((offset - 1) & ~(align - 1))
+    def self.size=(size)
+      raise ArgumentError, "Size already set" if defined?(@size) || defined?(@layout)
+      @size = size
     end
 
-    private
-    def calc_alignment_of(field_class, offset)
-      offset ? offset.to_i : align(@size, field_class.align)
-    end
-    def calc_current_size(offset, size)
-      @size = offset + size
+    def self.alignment
+      @layout.alignment
     end
-  end
 
-  class Struct
-    class Array
-      include Enumerable
-
-      def initialize(ptr, type, num)
-        @pointer, @type, @num = ptr, type, num
-      end
-
-      def to_ptr
-        @pointer 
-      end
-
-      def to_a
-        get_array_data(@pointer)
-      end
-
-      def size
-        @num * @type.size
-      end
-
-      def each(&blk)
-        to_a.each(&blk)
-      end
-
-      private
-      def get_array_data(ptr)
-        (0..@num - 1).inject([]) do |array, index| 
-          array << @type.new(0).get(ptr + index * @type.size)
-        end
-      end
-    end
-
-    def self.size
-      @size
+    def self.align
+      @layout.alignment
     end
 
     def self.members
       @layout.members
     end
 
-    def self.align
-      @layout.align
-    end
-
     def self.offsets
       @layout.offsets
     end
 
-    def self.offset_of(field_name)
-      @layout.offset_of(field_name)
+    def self.offset_of(name)
+      @layout.offset_of(name)
     end
 
-    def size
-      self.class.size
+    def self.in
+      :buffer_in
     end
 
-    def align
-      self.class.align
+    def self.out
+      :buffer_out
     end
 
-    def members
-      layout.members
+    def self.by_value
+      ::FFI::StructByValue.new(self)
     end
 
-    def values
-      layout.members.map { |m| self[m] }
-    end
-    def offsets
-      self.class.offsets
-    end
 
-    def offset_of(field_name)
-      self.class.offset_of(field_name)
-    end
 
-    def clear
-      pointer.clear
-      self
-    end
+    class << self
+      public
 
-    def to_ptr
-      pointer
-    end
+      def layout(*spec)
+        return @layout if spec.size == 0
 
-    def self.in
-      :buffer_in
-    end
+        builder = FFI::StructLayoutBuilder.new
+        builder.union = self < Union
+        if spec[0].kind_of?(Hash)
+          hash_layout(builder, spec)
+        else
+          array_layout(builder, spec)
+        end
+        builder.size = @size if defined?(@size) && @size > builder.size
+        cspec = builder.build
+        @layout = cspec unless self == FFI::Struct
+        @size = cspec.size
+        return cspec
+      end
 
-    def self.out
-      :buffer_out
-    end
 
-    protected
+      protected
 
-    def self.callback(params, ret)
-      mod = enclosing_module
-      FFI::CallbackInfo.new(find_type(ret, mod), params.map { |e| find_type(e, mod) })
-    end
+      def callback(params, ret)
+        mod = enclosing_module
+        FFI::CallbackInfo.new(find_type(ret, mod), params.map { |e| find_type(e, mod) })
+      end
 
-    private
 
-    def self.builder
-      StructLayoutBuilder.new
-    end
+      def enclosing_module
+        begin
+          mod = self.name.split("::")[0..-2].inject(Object) { |obj, c| obj.const_get(c) }
+          mod.respond_to?(:find_type) ? mod : nil
+        rescue Exception => ex
+          nil
+        end
+      end
 
-    def self.enclosing_module
-      begin
-        mod = self.name.split("::")[0..-2].inject(Object) { |obj, c| obj.const_get(c) }
-        mod.respond_to?(:find_type) ? mod : nil
-      rescue Exception => ex
-        nil
+      def find_type(type, mod = nil)
+        if (type.kind_of?(Class) && type < FFI::Struct) || type.is_a?(::Array)
+          type
+        elsif mod
+          mod.find_type(type)
+        end || FFI.find_type(type)
       end
-    end
 
-    def self.is_a_struct?(type)
-      type.is_a?(Class) and type < Struct
-    end
 
-    def self.find_type(type, mod = nil)
-      return type if is_a_struct?(type) or type.is_a?(::Array)
-      mod ? mod.find_type(type) : FFI.find_type(type)
-    end
+      private
 
-    def self.hash_layout(spec)
-      raise "Ruby version not supported" if RUBY_VERSION =~ /1.8.*/
-      builder = self.builder
-      mod = enclosing_module
-      spec[0].each do |name,type|
-        builder.add_field(name, find_type(type, mod))
+      def hash_layout(builder, spec)
+        raise "Ruby version not supported" if RUBY_VERSION =~ /1.8.*/
+        mod = enclosing_module
+        spec[0].each do |name,type|
+          if type.kind_of?(Class) && type < Struct
+            builder.add_struct(name, type)
+          elsif type.kind_of?(::Array)
+            builder.add_array(name, find_type(type[0], mod), type[1])
+          else
+            builder.add_field(name, find_type(type, mod))
+          end
+        end
       end
-      builder.build
-    end
 
-    def self.array_layout(spec)
-      builder = self.builder
-      mod = enclosing_module
-      i = 0
-      while i < spec.size
-        name, type = spec[i, 2]
-        i += 2
-        code = find_type(type, mod) 
-        # If the next param is a Fixnum, it specifies the offset
-        if spec[i].kind_of?(Fixnum)
-          offset = spec[i]
-          i += 1
-          builder.add_field(name, code, offset)
-        else
-          builder.add_field(name, code)
+      def array_layout(builder, spec)
+        mod = enclosing_module
+        i = 0
+        while i < spec.size
+          name, type = spec[i, 2]
+          i += 2
+
+          # If the next param is a Integer, it specifies the offset
+          if spec[i].kind_of?(Integer)
+            offset = spec[i]
+            i += 1
+          else
+            offset = nil
+          end
+          if type.kind_of?(Class) && type < Struct
+            builder.add_struct(name, type, offset)
+          elsif type.kind_of?(::Array)
+            builder.add_array(name, find_type(type[0], mod), type[1], offset)
+          else
+            builder.add_field(name, find_type(type, mod), offset)
+          end
         end
       end
-      builder.build
-    end
-
-    public
-    def self.layout(*spec)
-      return @layout if spec.size == 0
-      cspec = spec[0].kind_of?(Hash) ? hash_layout(spec) : array_layout(spec)
-      @layout = cspec unless self == FFI::Struct
-      @size = cspec.size
-      return cspec
     end
   end
 end