ffi 0.2.0 → 0.3.0

data/lib/ffi/buffer.rb

@@ -1,25 +0,0 @@
-module FFI
-  class Buffer
-    def self.__calc_size(type)
-      if type.kind_of? Fixnum
-        type
-      elsif type.kind_of? Symbol
-        FFI.type_size(type)
-      else
-        type.size
-      end
-    end
-    def self.new(size, count=nil, clear=true)
-      self.__alloc_inout(self.__calc_size(size), count, clear)
-    end
-    def self.alloc_in(size, count=nil, clear=true)
-      self.__alloc_in(self.__calc_size(size), count, clear)
-    end
-    def self.alloc_out(size, count=nil, clear=true)
-      self.__alloc_out(self.__calc_size(size), count, clear)
-    end
-    def self.alloc_inout(size, count=nil, clear=true)
-      self.__alloc_inout(self.__calc_size(size), count, clear)
-    end
-  end
-end

data/lib/ffi/ffi.rb

@@ -48,6 +48,7 @@ require 'ffi/errno'
 require 'ffi/memorypointer'
 require 'ffi/buffer'
 require 'ffi/struct'
+require 'ffi/union'
 require 'ffi/managedstruct'
 require 'ffi/callback'
 require 'ffi/io'

data/lib/ffi/library.rb

@@ -1,19 +1,21 @@
 module FFI::Library
   DEFAULT = FFI::DynamicLibrary.open(nil, FFI::DynamicLibrary::RTLD_LAZY)
  
-  # TODO: Rubinius does *names here and saves the array. Multiple libs?
   def ffi_lib(*names)
-    mapped_names = names.map { |name| FFI.map_library_name(name) }
-    errors = Hash.new
-    ffi_libs = mapped_names.map do |name|
-      begin
-        FFI::DynamicLibrary.open(name, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_LOCAL)
-      rescue LoadError => ex
-        errors[name] = ex
-        nil
+    ffi_libs = []
+    names.each do |name|
+      [ name, FFI.map_library_name(name) ].each do |libname|
+        begin
+          lib = FFI::DynamicLibrary.open(libname, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_LOCAL)
+          if lib
+            ffi_libs << lib
+            break
+          end
+        rescue LoadError => ex
+        end
       end
-    end.compact
-    raise LoadError, "Could not open any of [#{mapped_names.join(", ")}]" if ffi_libs.empty?
+    end
+    raise LoadError, "Could not open any of [#{names.join(", ")}]" if ffi_libs.empty?
     @ffi_libs = ffi_libs
   end
   def ffi_convention(convention)
@@ -35,21 +37,8 @@ module FFI::Library
     convention = defined?(@ffi_convention) ? @ffi_convention : :default
 
     # Convert :foo to the native type
-    callback_count = 0
-    arg_types.map! { |e|
-      begin
-        find_type(e)
-      rescue FFI::TypeError => ex
-        if defined?(@ffi_callbacks) && @ffi_callbacks.has_key?(e)
-          callback_count += 1
-          @ffi_callbacks[e]
-        elsif e.is_a?(Class) && e < FFI::Struct
-          FFI::NativeType::POINTER
-        else
-          raise ex
-        end
-      end
-    }
+    arg_types.map! { |e| find_type(e) }
+    has_callback = arg_types.any? {|t| t.kind_of?(FFI::CallbackInfo)}
     options = Hash.new
     options[:convention] = convention
     options[:type_map] = @ffi_typedefs if defined?(@ffi_typedefs)
@@ -69,24 +58,97 @@ module FFI::Library
     params = (1..arity).map {|i| "a#{i}" }.join(",")
 
     # Always use rest args for functions with callback parameters
-    if callback_count > 0 || invoker.kind_of?(FFI::VariadicInvoker)
+    if has_callback || invoker.kind_of?(FFI::VariadicInvoker)
       params = "*args, &block"
     end
-    call = arity <= 3 && callback_count < 1 && !invoker.kind_of?(FFI::VariadicInvoker)? "call#{arity}" : "call"
+    call = arity <= 3 && !has_callback && !invoker.kind_of?(FFI::VariadicInvoker)? "call#{arity}" : "call"
 
     #
     # Attach the invoker to this module as 'mname'.
     #
-    self.module_eval <<-code
-      @@#{mname} = invoker
-      def self.#{mname}(#{params})
-        @@#{mname}.#{call}(#{params})
+    if !has_callback && !invoker.kind_of?(FFI::VariadicInvoker)
+      invoker.attach(self, mname.to_s)
+    else
+      self.module_eval <<-code
+        @@#{mname} = invoker
+        def self.#{mname}(#{params})
+          @@#{mname}.#{call}(#{params})
+        end
+        def #{mname}(#{params})
+          @@#{mname}.#{call}(#{params})
+        end
+      code
+    end
+    invoker
+  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|
+      begin
+        address = lib.find_symbol(cname.to_s)
+        break unless address.nil?
+      rescue LoadError
       end
-      def #{mname}(#{params})
-        @@#{mname}.#{call}(#{params})
+    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 FFI::TypeError, "Cannot access library variable of type #{type}"
       end
-    code
-    invoker
+    end
+    #
+    # 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
+    address
   end
   def callback(name, args, ret)
     @ffi_callbacks = Hash.new unless defined?(@ffi_callbacks)
@@ -103,8 +165,12 @@ module FFI::Library
     @ffi_typedefs[add] = code
   end
   def find_type(name)
-    code = if defined?(@ffi_typedefs)
+    code = if defined?(@ffi_typedefs) && @ffi_typedefs.has_key?(name)
       @ffi_typedefs[name]
+    elsif defined?(@ffi_callbacks) && @ffi_callbacks.has_key?(name)
+      @ffi_callbacks[name]
+    elsif name.is_a?(Class) && name < FFI::Struct
+      FFI::NativeType::POINTER
     end
     code = name if !code && name.kind_of?(FFI::CallbackInfo)
     if code.nil? || code.kind_of?(Symbol)

data/lib/ffi/memorypointer.rb

@@ -23,34 +23,34 @@ module FFI
       # with a block yields the MemoryPointer instance and frees the memory
       # when the block returns. The value returned is the value of the block.
 
-      def self.new(type, count=nil, clear=true)
-        size = if type.kind_of? Fixnum
-          type
-        elsif type.kind_of? Symbol
-          FFI.type_size(type)
-        else
-          type.size
-        end
-        ptr = self.__allocate(size, count, clear)
-        ptr.type_size = size
-        if block_given?
-          begin
-            value = yield ptr
-          ensure
-            ptr.free
-          end
-          value
-        else
-          ptr
-        end
-      end
+#      def self.new(type, count=nil, clear=true)
+#        size = if type.kind_of? Fixnum
+#          type
+#        elsif type.kind_of? Symbol
+#          FFI.type_size(type)
+#        else
+#          type.size
+#        end
+#        ptr = self.__allocate(size, count, clear)
+#        ptr.type_size = size
+#        if block_given?
+#          begin
+#            value = yield ptr
+#          ensure
+#            ptr.free
+#          end
+#          value
+#        else
+#          ptr
+#        end
+#      end
       def self.from_string(s)
         ptr = self.new(s.length + 1, 1, false)
         ptr.put_string(0, s)
         ptr
       end
       # Indicates how many bytes the type that the pointer is cast as uses.
-      attr_accessor :type_size
+      # attr_accessor :type_size
 
       # Access the MemoryPointer like a C array, accessing the +which+ number
       # element in memory. The position of the element is calculate from
@@ -66,11 +66,8 @@ module FFI
       #   int *new_ptr;
       #   new_ptr = &ptr[9];
       #
-      def [](which)
-        raise ArgumentError, "unknown type size" unless @type_size
-        self + (which * @type_size)
-      end
+#      def [](which)
+#        self + (which * type_size)
+#      end
   end
 end
-
-MemoryPointer = FFI::MemoryPointer

data/lib/ffi/platform.rb

@@ -14,10 +14,10 @@ module FFI
       "openbsd"
     when /sunos|solaris/
       "solaris"
-    when /win/
+    when /win|mingw/
       "windows"
     else
-      raise FFI::PlatformError, "Unknown operating system: #{OS_}"
+      raise FFI::PlatformError, "Unknown operating system: #{Config::CONFIG['host_os']}"
     end
     ARCH = case CPU.downcase
     when /amd64|x86_64/

data/lib/ffi/pointer.rb

@@ -35,9 +35,14 @@ module FFI
     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
@@ -59,20 +64,20 @@ module FFI
       get_string(0)
     end
     def write_string_length(str, len)
-      put_string(0, str, len)
+      put_bytes(0, str, 0, len)
     end
     def write_string(str, len=nil)
       len = str.size unless len
       # Write the string data without NUL termination
-      put_string(0, str, len)
+      put_bytes(0, str, 0, len)
     end
     def read_array_of_type(type, reader, length)
       ary = []
       size = FFI.type_size(type)
       tmp = self
-      length.times {
+      length.times { |j|
         ary << tmp.send(reader)
-        tmp += size
+        tmp += size unless j == length-1 # avoid OOB
       }
       ary
     end
@@ -80,9 +85,9 @@ module FFI
     def write_array_of_type(type, writer, ary)
       size = FFI.type_size(type)
       tmp = self
-      ary.each {|i|
+      ary.each_with_index {|i, j|
         tmp.send(writer, i)
-        tmp += size
+        tmp += size unless j == ary.length-1 # avoid OOB
       }
       self
     end
@@ -101,5 +106,14 @@ module FFI
     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
+end

data/lib/ffi/struct.rb

@@ -1,164 +1,103 @@
 require 'ffi/platform'
 module FFI
   class StructLayout
-    def initialize(fields, size)
-      @fields = fields
-      @size = size
+    attr_reader :size, :align
+
+    def members
+      @field_names
     end
-    
-    def [](name)
-      @fields[name]
+    def offsets
+      @fields.map { |name, field| [name, field.offset] }.sort { |a, b| a[1] <=> b[1] }
     end
-    def size
-      @size
+    def offset_of(field_name)
+      @fields[field_name].offset
     end
   end
   class StructLayoutBuilder
     class Field
-      def initialize(off)
-        @off = off
-      end
-      
-      def offset
-        @off
-      end
       def size
-        self.size
+        self.class.size
       end
       def align
-        self.align
-      end
-      def self.align
-        self.size
-      end
-    end
-    class Signed8 < Field
-      def self.size; 8; end
-      def self.align; Platform::INT8_ALIGN; end
-      def put(ptr, val)
-        ptr.put_int8(@off, val)
-      end
-      def get(ptr)
-        ptr.get_int8(@off)
-      end
-    end
-    class Unsigned8 < Field
-      def self.size; 8; end
-      def self.align; Platform::INT8_ALIGN; end
-      def put(ptr, val)
-        ptr.put_uint8(@off, val)
-      end
-      def get(ptr)
-        ptr.get_uint8(@off)
-      end
-    end
-    class Signed16 < Field
-      def self.size; 16; end
-      def self.align; Platform::INT16_ALIGN; end
-      def put(ptr, val)
-        ptr.put_int16(@off, val)
-      end
-      def get(ptr)
-        ptr.get_int16(@off)
-      end
-    end
-    class Unsigned16 < Field
-      def self.size; 16; end
-      def self.align; Platform::INT16_ALIGN; end
-      def put(ptr, val)
-        ptr.put_uint16(@off, val)
-      end
-      def get(ptr)
-        ptr.get_uint16(@off)
-      end
-    end
-    class Signed32 < Field
-      def self.size; 32; end
-      def self.align; Platform::INT32_ALIGN; end
-      def put(ptr, val)
-        ptr.put_int32(@off, val)
-      end
-      def get(ptr)
-        ptr.get_int32(@off)
-      end
-    end
-    class Unsigned32 < Field
-      def self.size; 32; end
-      def self.align; Platform::INT32_ALIGN; end
-      def put(ptr, val)
-        ptr.put_uint32(@off, val)
-      end
-      def get(ptr)
-        ptr.get_uint32(@off)
-      end
-    end
-    class Signed64 < Field
-      def self.size; 64; end
-      def self.align; Platform::INT64_ALIGN; end
-      def put(ptr, val)
-        ptr.put_int64(@off, val)
-      end
-      def get(ptr)
-        ptr.get_int64(@off)
-      end
-    end
-    class Unsigned64 < Field
-      def self.size; 64; end
-      def self.align; Platform::INT64_ALIGN; end
-      def put(ptr, val)
-        ptr.put_uint64(@off, val)
-      end
-      def get(ptr)
-        ptr.get_uint64(@off)
-      end
-    end
-    class FloatField < Field
-      def self.size; Platform::FLOAT_SIZE; end
-      def self.align; Platform::FLOAT_ALIGN; end
-      def put(ptr, val)
-        ptr.put_float32(@off, val)
+        self.class.align
       end
-      def get(ptr)
-        ptr.get_float32(@off)
-      end
-    end
-    class DoubleField < Field
-      def self.size; Platform::DOUBLE_SIZE; end
-      def self.align; Platform::DOUBLE_ALIGN; end
-      def put(ptr, val)
-        ptr.put_float64(@off, val)
+      def offset
+        @off
       end
-      def get(ptr)
-        ptr.get_float64(@off)
+      def self.size
+        const_get(:SIZE)
       end
-    end
-    class PointerField < Field
-      def self.size; Platform::ADDRESS_SIZE; end
-      def self.align; Platform::ADDRESS_ALIGN; end
-      def put(ptr, val)
-        ptr.put_pointer(@off, val)
+      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} * 8
+            end
+            def align
+              #{type.align}
+            end
+          end
+        def get(ptr)
+          self.class.info.new(ptr + @off)
+        end
       end
-      def get(ptr)
-        ptr.get_pointer(@off)
+      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 StringField < Field
+    class CallbackField < Field
       def self.size; Platform::ADDRESS_SIZE; end
       def self.align; Platform::ADDRESS_ALIGN; end
-      def put(ptr, val)
-        raise ArgumentError, "Cannot set :string fields"
+      def put(ptr, proc)
+        ptr.put_callback(@off, proc, @info)
       end
       def get(ptr)
-        strp = ptr.get_pointer(@off)
-        (strp.nil? || strp.null?) ? nil : strp.get_string(0)
+        raise ArgumentError, "Cannot get callback fields"
       end
     end
     def initialize
+      @field_names = []
       @fields = {}
       @size = 0
+      @min_align = 1
     end
-    def add_field(name, type, offset=nil)
-      field_class = case type
+    def native_field_class_from(type)
+      case type
       when :char, NativeType::INT8
         Signed8
       when :uchar, NativeType::UINT8
@@ -187,17 +126,35 @@ module FFI
         PointerField
       when :string, NativeType::STRING
         StringField
-      else
-        raise ArgumentError, "Unknown type: #{type}"
       end
-      
-      size = field_class.size / 8
-      off = offset ? offset.to_i : align(@size, field_class.align)
-      @fields[name] = field_class.new(off)
-      @size = off + size
+    end
+    def callback_field_class_from(type)
+      return CallbackField, type if type.is_a?(FFI::CallbackInfo)
+    end
+    def struct_field_class_from(type)
+      self.class.struct_field_class_from(type) if type.is_a?(Class) and type < FFI::Struct
+    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)
+    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}"
+    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 / 8)
+      @field_names << name
+      @fields[name] = field_class.new(off, info)
+      @min_align = field_class.align if field_class.align > @min_align
     end
     def build
-      StructLayout.new @fields, @size
+      align = @min_align / 8
+      StructLayout.new @field_names, @fields, align + ((@size - 1) & ~(align - 1)), @min_align
     end
     def align(offset, bits)
       bytes = bits / 8
@@ -205,28 +162,38 @@ module FFI
       off = offset;
       ((off & mask) != 0) ? (off & ~mask) + bytes : off
     end
-  end
-  class BaseStruct
-    Buffer = FFI::Buffer
-    attr_reader :pointer
-
-    def initialize(pointer = nil, *spec)
-      @cspec = self.class.layout(*spec)
-
-      if pointer then
-        @pointer = pointer
-      else
-        @pointer = MemoryPointer.new size
-      end
-    end
-    def self.alloc_inout(clear = true)
-      self.new(Buffer.alloc_inout(@size, 1, clear))
+    private
+    def calc_alignment_of(field_class, offset)
+      offset ? offset.to_i : align(@size, field_class.align)
     end
-    def self.alloc_in(clear = true)
-      self.new(Buffer.alloc_in(@size, 1, clear))
+    def calc_current_size(offset, size)
+      @size = offset + size
     end
-    def self.alloc_out(clear = true)
-      self.new(Buffer.alloc_out(@size, 1, clear))
+  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 / 8
+      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 / 8)
+        end
+      end
     end
     def self.size
       @size
@@ -234,27 +201,39 @@ module FFI
     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)
+    end
     def size
       self.class.size
     end
-    def [](field)
-      @cspec[field].get(@pointer)
-    end
-    def []=(field, val)
-      @cspec[field].put(@pointer, val)
+    def align
+      self.class.align
     end
     def members
-      @cspec.members
+      layout.members
     end
     def values
-      @cspec.members.map { |m| self[m] }
+      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
+      pointer.clear
       self
     end
     def to_ptr
-      @pointer
+      pointer
     end
     def self.in
       :buffer_in
@@ -262,9 +241,10 @@ module FFI
     def self.out
       :buffer_out
     end
-  end
-  class Struct < BaseStruct
     private
+    def self.builder
+      StructLayoutBuilder.new
+    end
     def self.enclosing_module
       begin
         mod = self.name.split("::")[0..-2].inject(Object) { |obj, c| obj.const_get(c) }
@@ -273,12 +253,16 @@ module FFI
         nil
       end
     end
+    def self.is_a_struct?(type)
+      type.is_a?(Class) and type < Struct
+    end
     def self.find_type(type, mod = nil)
-      return mod ? mod.find_type(type) : FFI.find_type(type)
+      return type if is_a_struct?(type) or type.is_a?(::Array)
+      mod ? mod.find_type(type) : FFI.find_type(type)
     end
     def self.hash_layout(spec)
       raise "Ruby version not supported" if RUBY_VERSION =~ /1.8.*/
-      builder = FFI::StructLayoutBuilder.new
+      builder = self.builder
       mod = enclosing_module
       spec[0].each do |name,type|
         builder.add_field(name, find_type(type, mod))
@@ -286,14 +270,14 @@ module FFI
       builder.build
     end
     def self.array_layout(spec)
-      builder = FFI::StructLayoutBuilder.new
+      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 Fixnu, it specifies the offset
+        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
@@ -306,10 +290,8 @@ module FFI
     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