ffi 0.3.5 → 0.4.0

data/ext/ffi_c/rbffi.h

@@ -8,14 +8,12 @@ extern "C" {
 #endif
 
 #define MAX_PARAMETERS (32)
-    
-extern void rb_FFI_AbstractMemory_Init(void);
-extern void rb_FFI_MemoryPointer_Init(void);
-extern void rb_FFI_Buffer_Init(void);
-extern void rb_FFI_Callback_Init(void);
-extern void rb_FFI_Invoker_Init(void);
-extern VALUE rb_FFI_AbstractMemory_class;
-extern int rb_FFI_type_size(VALUE type);
+
+extern void rbffi_Type_Init(VALUE ffiModule);
+extern void rbffi_Buffer_Init(VALUE ffiModule);
+extern void rbffi_Invoker_Init(VALUE ffiModule);
+extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
+extern int rbffi_type_size(VALUE type);
 
 #ifdef	__cplusplus
 }

data/lib/ffi.rb

@@ -1,2 +1,11 @@
-require 'ffi_c'
+begin
+  if RUBY_VERSION =~ /1.8/
+    require '1.8/ffi_c'
+  elsif RUBY_VERSION =~ /1.9/
+    require '1.9/ffi_c'
+  end
+rescue Exception
+  require 'ffi_c'
+end
+
 require 'ffi/ffi'

data/lib/ffi/autopointer.rb

@@ -28,7 +28,7 @@ module FFI
     # release(), which by default does nothing.
     #
     def initialize(ptr, proc=nil, &block)
-      raise ArgumentError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
+      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
         || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
       free_lambda = if proc and proc.is_a? Method
                       AutoPointer.finalize(ptr, AutoPointer.method_to_proc(proc))

data/lib/ffi/enum.rb

@@ -0,0 +1,78 @@
+module FFI
+
+  class Enums
+
+    def initialize
+      @all_enums = Array.new
+      @tagged_enums = Hash.new
+      @symbol_map = Hash.new
+    end
+
+    def <<(enum)
+      @all_enums << enum
+      @tagged_enums[enum.tag] = enum unless enum.tag.nil?
+      @symbol_map.merge!(enum.symbol_map)
+    end
+
+    def find(query)
+      if @tagged_enums.has_key?(query)
+        @tagged_enums[query]
+      else
+        @all_enums.detect { |enum| enum.symbols.include?(query) }
+      end
+    end
+
+    def __map_symbol(symbol)
+      @symbol_map[symbol]
+    end
+
+  end
+
+  class Enum
+    attr_reader :tag
+
+    def initialize(info, tag=nil)
+      @tag = tag
+      @kv_map = Hash.new
+      @vk_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            @kv_map[i] = value
+            @vk_map[value] = i
+            last_cst = i
+            value += 1
+          when Integer
+            @kv_map[last_cst] = i
+            @vk_map[i] = last_cst
+            value = i+1
+          end
+        end
+      end
+    end
+
+    def symbols
+      @kv_map.keys
+    end
+
+    def [](query)
+      case query
+      when Symbol
+        @kv_map[query]
+      when Integer
+        @vk_map[query]
+      end
+    end
+    alias find []
+
+    def symbol_map
+      @kv_map
+    end
+    alias to_h symbol_map
+
+  end
+
+end

data/lib/ffi/ffi.rb

@@ -30,8 +30,6 @@ module FFI
   #  Specialised error classes
   class NativeError < LoadError; end
   
-  class TypeError < NativeError; end
-  
   class SignatureError < NativeError; end
   
   class NotFoundError < NativeError
@@ -54,6 +52,7 @@ require 'ffi/callback'
 require 'ffi/io'
 require 'ffi/autopointer'
 require 'ffi/variadic'
+require 'ffi/enum'
 
 module FFI
   
@@ -67,7 +66,7 @@ module FFI
     end
     lib
   end
-  def self.create_invoker(lib, name, args, ret, options = { :convention => :default })
+  def self.create_invoker(lib, name, args, ret_type, native_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
 
@@ -82,14 +81,14 @@ module FFI
     else
       raise LoadError, "Invalid library '#{lib}'"
     end
-    function = library.find_symbol(name)
+    function = library.find_function(name)
     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(library, function, args, find_type(ret), options)
+      invoker = FFI::VariadicInvoker.new(function, args, ret_type, find_type(native_ret_type), options)
     else
-      invoker = FFI::Invoker.new(library, function, args, find_type(ret), options[:convention].to_s)
+      invoker = FFI::Invoker.new(function, args, ret_type, find_type(native_ret_type), options[:convention].to_s, options[:enums])
     end
     raise NotFoundError.new(name, library.name) unless invoker
     return invoker

data/lib/ffi/io.rb

@@ -3,5 +3,19 @@ module FFI
     def self.for_fd(fd, mode = "r")
       ::IO.for_fd(fd, mode)
     end
+
+    #
+    # A version of IO#read that reads into a native buffer
+    # 
+    # This will be optimized at some future time to eliminate the double copy
+    #
+    def self.native_read(io, buf, len)
+      tmp = io.read(len)
+      return -1 unless tmp
+      buf.put_bytes(0, tmp)
+      tmp.length
+    end
+
   end
-end
+end
+

data/lib/ffi/library.rb

@@ -3,6 +3,7 @@ module FFI::Library
  
   def ffi_lib(*names)
     ffi_libs = []
+    errors = {}
     names.each do |name|
       [ name, FFI.map_library_name(name) ].each do |libname|
         begin
@@ -11,11 +12,17 @@ module FFI::Library
             ffi_libs << lib
             break
           end
-        rescue LoadError => ex
+        rescue Exception => ex
+          errors[name] = ex
         end
       end
     end
-    raise LoadError, "Could not open any of [#{names.join(", ")}]" if ffi_libs.empty?
+    if ffi_libs.empty?
+      msgs = []
+      errors.each {|name, ex| msgs << "Failed to load library '#{name}': #{ex.message}" }
+      raise LoadError.new(msgs.join('\n'))
+    end
+
     @ffi_libs = ffi_libs
   end
   def ffi_convention(convention)
@@ -33,20 +40,21 @@ module FFI::Library
 
   def attach_function(mname, a3, a4, a5=nil)
     cname, arg_types, ret_type = a5 ? [ a3, a4, a5 ] : [ mname.to_s, a3, a4 ]
-    libraries = defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
-    convention = defined?(@ffi_convention) ? @ffi_convention : :default
 
     # Convert :foo to the native type
     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[:convention] = defined?(@ffi_convention) ? @ffi_convention : :default
     options[:type_map] = @ffi_typedefs if defined?(@ffi_typedefs)
+    options[:enums] = @ffi_enums if defined?(@ffi_enums)
+
     # Try to locate the function in any of the libraries
     invokers = []
+    libraries = defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
     libraries.each do |lib|
       begin
-        invokers << FFI.create_invoker(lib, cname.to_s, arg_types, find_type(ret_type), options)
+        invokers << FFI.create_invoker(lib, cname.to_s, arg_types, ret_type, find_type(ret_type), options)
       rescue LoadError => ex
       end if invokers.empty?
     end
@@ -87,7 +95,7 @@ module FFI::Library
     address = nil
     libraries.each do |lib|
       begin
-        address = lib.find_symbol(cname.to_s)
+        address = lib.find_variable(cname.to_s)
         break unless address.nil?
       rescue LoadError
       end
@@ -120,7 +128,7 @@ module FFI::Library
       if ffi_type.is_a?(FFI::CallbackInfo)
         op = :callback
       else
-        raise FFI::TypeError, "Cannot access library variable of type #{type}"
+        raise TypeError, "Cannot access library variable of type #{type}"
       end
     end
     #
@@ -150,20 +158,72 @@ module FFI::Library
     end
     address
   end
-  def callback(name, args, ret)
-    @ffi_callbacks = Hash.new unless defined?(@ffi_callbacks)
-    @ffi_callbacks[name] = FFI::CallbackInfo.new(find_type(ret), args.map { |e| find_type(e) })
+
+  def callback(*args)
+    raise ArgError, "wrong number of arguments" if args.length < 2 || args.length > 3
+    name, params, ret = if args.length == 3
+      args
+    else
+      [ nil, args[0], args[1] ]
+    end
+    cb = FFI::CallbackInfo.new(find_type(ret), params.map { |e| find_type(e) })
+
+    # Add to the symbol -> type map (unless there was no name)
+    unless name.nil?
+      @ffi_callbacks = Hash.new unless defined?(@ffi_callbacks)
+      @ffi_callbacks[name] = cb
+    end
+
+    cb
   end
-  def typedef(current, add)
+  
+  def typedef(current, add, info=nil)
     @ffi_typedefs = Hash.new unless defined?(@ffi_typedefs)
-    if current.kind_of? Integer
-      code = current
+    code = if current.kind_of?(FFI::Type)
+      current
+    elsif current == :enum
+      if add.kind_of?(Array)
+        self.enum(add)
+      else
+        self.enum(info, add)
+      end
     else
-      code = @ffi_typedefs[current] || FFI.find_type(current)
+      @ffi_typedefs[current] || FFI.find_type(current)
     end
 
     @ffi_typedefs[add] = code
   end
+
+  def enum(*args)
+    #
+    # enum can be called as:
+    # enum :zero, :one, :two  # unnamed enum
+    # enum [ :zero, :one, :two ] # equivalent to above
+    # enum :foo, [ :zero, :one, :two ] create an enum named :foo
+    #
+    name, values = if args[0].kind_of?(Symbol) && args[1].kind_of?(Array)
+      [ args[0], args[1] ]
+    elsif args[0].kind_of?(Array)
+      [ nil, args[0] ]
+    else
+      [ nil, args ]
+    end
+    @ffi_enums = FFI::Enums.new unless defined?(@ffi_enums)
+    @ffi_enums << (e = FFI::Enum.new(values, name))
+
+    # If called as enum :foo, [ :zero, :one, :two ], add a typedef alias
+    typedef(e, name) if name
+    e
+  end
+
+  def enum_type(name)
+    @ffi_enums.find(name) if defined?(@ffi_enums)
+  end
+
+  def enum_value(symbol)
+    @ffi_enums.__map_symbol(symbol)
+  end
+
   def find_type(name)
     code = if defined?(@ffi_typedefs) && @ffi_typedefs.has_key?(name)
       @ffi_typedefs[name]
@@ -171,12 +231,13 @@ module FFI::Library
       @ffi_callbacks[name]
     elsif name.is_a?(Class) && name < FFI::Struct
       FFI::NativeType::POINTER
+    elsif name.kind_of?(FFI::Type)
+      name
     end
-    code = name if !code && name.kind_of?(FFI::CallbackInfo)
     if code.nil? || code.kind_of?(Symbol)
       FFI.find_type(name)
     else
       code
     end
   end
-end
+end

data/lib/ffi/pointer.rb

@@ -52,13 +52,13 @@ module FFI
 
     def read_string(len=nil)
       if len
-        get_string(0, len)
+        get_bytes(0, len)
       else
         get_string(0)
       end
     end
     def read_string_length(len)
-      get_string(0, len)
+      get_bytes(0, len)
     end
     def read_string_to_null
       get_string(0)

data/lib/ffi/struct.rb

@@ -1,5 +1,6 @@
 require 'ffi/platform'
 module FFI
+
   class StructLayout
     attr_reader :size, :align
 
@@ -13,6 +14,7 @@ module FFI
       @fields[field_name].offset
     end
   end
+
   class StructLayoutBuilder
     class Field
       def size
@@ -31,6 +33,7 @@ module FFI
         const_get(:ALIGN)
       end
     end
+
     def self.struct_field_class_from(type)
       klass_name = type.name.split('::').last
       code = <<-code
@@ -39,7 +42,7 @@ module FFI
           class << self
             attr_reader :info
             def size
-              #{type.size} * 8
+              #{type.size}
             end
             def align
               #{type.align}
@@ -53,6 +56,7 @@ module FFI
       code
       self.module_eval(code)
     end
+
     def self.array_field_class_from(type, num)
       klass_name = type.name.split('::').last
       code = <<-code
@@ -80,22 +84,32 @@ module FFI
       code
       self.module_eval(code)
     end
+
     class CallbackField < Field
-      def self.size; Platform::ADDRESS_SIZE; end
-      def self.align; Platform::ADDRESS_ALIGN; end
+      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
+
       def get(ptr)
         raise ArgumentError, "Cannot get callback fields"
       end
     end
+
     def initialize
       @field_names = []
       @fields = {}
       @size = 0
       @min_align = 1
     end
+
     def native_field_class_from(type)
       case type
       when :char, NativeType::INT8
@@ -128,15 +142,19 @@ module FFI
         StringField
       end
     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) ||
@@ -144,24 +162,24 @@ module FFI
         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)
+      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
     end
+
     def build
-      align = @min_align / 8
-      StructLayout.new @field_names, @fields, align + ((@size - 1) & ~(align - 1)), @min_align
+      StructLayout.new(@field_names, @fields, align(@size, @min_align), @min_align)
     end
-    def align(offset, bits)
-      bytes = bits / 8
-      mask = bytes - 1;
-      off = offset;
-      ((off & mask) != 0) ? (off & ~mask) + bytes : off
+
+    def align(offset, align)
+      align + ((offset - 1) & ~(align - 1))
     end
+
     private
     def calc_alignment_of(field_class, offset)
       offset ? offset.to_i : align(@size, field_class.align)
@@ -170,81 +188,112 @@ module FFI
       @size = offset + size
     end
   end
+
   class Struct
     class Array
       include Enumerable
+
       def initialize(ptr, type, num)
         @pointer, @type, @num = ptr, type, num
       end
-      def to_ptr 
+
+      def to_ptr
         @pointer 
       end
+
       def to_a
         get_array_data(@pointer)
       end
+
       def size
-        @num * @type.size / 8
+        @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 / 8)
+          array << @type.new(0).get(ptr + index * @type.size)
         end
       end
     end
+
     def self.size
       @size
     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)
     end
+
     def size
       self.class.size
     end
+
     def align
       self.class.align
     end
+
     def members
       layout.members
     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
+
     def to_ptr
       pointer
     end
+
     def self.in
       :buffer_in
     end
+
     def self.out
       :buffer_out
     end
+
+    protected
+
+    def self.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 self.enclosing_module
       begin
         mod = self.name.split("::")[0..-2].inject(Object) { |obj, c| obj.const_get(c) }
@@ -253,13 +302,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 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 = self.builder
@@ -269,6 +321,7 @@ module FFI
       end
       builder.build
     end
+
     def self.array_layout(spec)
       builder = self.builder
       mod = enclosing_module
@@ -288,6 +341,7 @@ module FFI
       end
       builder.build
     end
+
     public
     def self.layout(*spec)
       return @layout if spec.size == 0