ffi 0.1.1 → 0.2.0

data/lib/ffi/io.rb

@@ -0,0 +1,7 @@
+module FFI
+  module IO
+    def self.for_fd(fd, mode = "r")
+      ::IO.for_fd(fd, mode)
+    end
+  end
+end

data/lib/ffi/library.rb

@@ -0,0 +1,116 @@
+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
+      end
+    end.compact
+    raise LoadError, "Could not open any of [#{mapped_names.join(", ")}]" if ffi_libs.empty?
+    @ffi_libs = ffi_libs
+  end
+  def ffi_convention(convention)
+    @ffi_convention = convention
+  end
+  ##
+  # Attach C function +name+ to this module.
+  #
+  # If you want to provide an alternate name for the module function, supply
+  # it after the +name+, otherwise the C function name will be used.#
+  #
+  # After the +name+, the C function argument types are provided as an Array.
+  #
+  # The C function return type is provided last.
+
+  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
+    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
+    }
+    options = Hash.new
+    options[:convention] = convention
+    options[:type_map] = @ffi_typedefs if defined?(@ffi_typedefs)
+    # Try to locate the function in any of the libraries
+    invokers = []
+    libraries.each do |lib|
+      begin
+        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
+
+    # Setup the parameter list for the module function as (a1, a2)
+    arity = arg_types.length
+    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)
+      params = "*args, &block"
+    end
+    call = arity <= 3 && callback_count < 1 && !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})
+      end
+      def #{mname}(#{params})
+        @@#{mname}.#{call}(#{params})
+      end
+    code
+    invoker
+  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) })
+  end
+  def typedef(current, add)
+    @ffi_typedefs = Hash.new unless defined?(@ffi_typedefs)
+    if current.kind_of? Integer
+      code = current
+    else
+      code = @ffi_typedefs[current] || FFI.find_type(current)
+    end
+
+    @ffi_typedefs[add] = code
+  end
+  def find_type(name)
+    code = if defined?(@ffi_typedefs)
+      @ffi_typedefs[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

data/lib/ffi/managedstruct.rb

@@ -0,0 +1,55 @@
+module FFI
+  #
+  #  FFI::ManagedStruct allows custom garbage-collection of your FFI::Structs.
+  #
+  #  The typical use case would be when interacting with a library
+  #  that has a nontrivial memory management design, such as a linked
+  #  list or a binary tree.
+  #
+  #  When the Struct instance is garbage collected, FFI::ManagedStruct will
+  #  invoke the class's release() method during object finalization.
+  #
+  #  Example usage:
+  #    module MyLibrary
+  #      ffi_lib "libmylibrary"
+  #      attach_function :new_dlist, [], :pointer
+  #      attach_function :destroy_dlist, [:pointer], :void
+  #    end
+  #
+  #    class DoublyLinkedList < FFI::ManagedStruct
+  #      @@@
+  #      struct do |s|
+  #        s.name 'struct dlist'
+  #        s.include 'dlist.h'
+  #        s.field :head, :pointer
+  #        s.field :tail, :pointer
+  #      end
+  #      @@@
+  #
+  #      def self.release ptr
+  #        MyLibrary.destroy_dlist(ptr)
+  #      end
+  #    end
+  #
+  #    begin
+  #      ptr = DoublyLinkedList.new(MyLibrary.new_dlist)
+  #      #  do something with the list
+  #    end
+  #    # struct is out of scope, and will be GC'd using DoublyLinkedList#release
+  #
+  #
+  class ManagedStruct < FFI::Struct
+
+    # call-seq:
+    #   ManagedStruct.new(pointer)
+    #   ManagedStruct.new
+    #
+    # When passed a pointer, create a new ManagedStruct which will invoke the class method release() on 
+    def initialize(pointer=nil)
+      raise NoMethodError, "release() not implemented for class #{self}" unless self.class.respond_to? :release
+      raise ArgumentError, "Must supply a pointer to memory for the Struct" unless pointer
+      super FFI::AutoPointer.new(pointer, self.class.method(:release))
+    end
+
+  end
+end

data/lib/ffi/memorypointer.rb

@@ -1,3 +1,4 @@
+require 'ffi/pointer'
 module FFI
   class MemoryPointer
       # call-seq:
@@ -69,101 +70,7 @@ module FFI
         raise ArgumentError, "unknown type size" unless @type_size
         self + (which * @type_size)
       end
-      # Write +obj+ as a C int at the memory pointed to.
-      def write_int(obj)
-        put_int32(0, obj)
-      end
-
-      # Read a C int from the memory pointed to.
-      def read_int
-        get_int32(0)
-      end
-
-      # Write +obj+ as a C long at the memory pointed to.
-      def write_long(obj)
-        put_long(0, obj)
-      end
-
-      # Read a C long from the memory pointed to.
-      def read_long
-        get_long(0)
-      end
-      # Write +obj+ as a C long long at the memory pointed to.
-      def write_long_long(obj)
-        put_int64(0, obj)
-      end
-
-      # Read a C long long from the memory pointed to.
-      def read_long_long
-        get_int64(0)
-      end
-      def read_pointer
-        get_pointer(0)
-      end
-      def read_float
-        get_float32(0)
-      end
-      def write_float(obj)
-        put_float32(0, obj)
-      end
-      
-      def read_string(len=nil)
-        if len
-          get_string(0, len)
-        else
-          get_string(0)
-        end
-      end
-      def read_string_length(len)
-        get_string(0, len)
-      end
-      def read_string_to_null
-        get_string(0)
-      end
-      def write_string_length(str, len)
-        put_string(0, str, 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)
-      end
-      def read_array_of_type(type, reader, length)
-        ary = []
-        size = FFI.type_size(type)
-        tmp = self
-        length.times {
-          ary << tmp.send(reader)
-          tmp += size
-        }
-        ary
-      end
-
-      def write_array_of_type(type, writer, ary)
-        size = FFI.type_size(type)
-        tmp = self
-        ary.each {|i|
-          tmp.send(writer, i)
-          tmp += size
-        }
-        self
-      end
-      def read_array_of_int(length)
-        get_array_of_int32(0, length)
-      end
-
-      def write_array_of_int(ary)
-        put_array_of_int32(0, ary)
-      end
-
-      def read_array_of_long(length)
-        get_array_of_long(0, length)
-      end
-
-      def write_array_of_long(ary)
-        put_array_of_long(0, ary)
-      end
-    end
+  end
 end
 
-MemoryPointer = FFI::MemoryPointer
+MemoryPointer = FFI::MemoryPointer

data/lib/ffi/platform.rb

@@ -20,10 +20,12 @@ module FFI
       raise FFI::PlatformError, "Unknown operating system: #{OS_}"
     end
     ARCH = case CPU.downcase
-    when /i?86|x86|i86pc/
-      "i386"
     when /amd64|x86_64/
       "x86_64"
+    when /i?86|x86|i86pc/
+      "i386"
+    when /ppc|powerpc/
+      "powerpc"
     else
       raise FFI::PlatformError, "Unknown cpu architecture: #{ARCH_}"
     end
@@ -39,6 +41,7 @@ module FFI
     IS_OPENBSD = is_os("openbsd")
     IS_WINDOWS = is_os("windows")
     IS_BSD = IS_MAC || IS_FREEBSD || IS_OPENBSD
+    CONF_DIR = File.dirname(__FILE__)
     public
     LIBC = if IS_WINDOWS
       "msvcrt"
@@ -50,11 +53,11 @@ module FFI
     LIBPREFIX = IS_WINDOWS ? '' : 'lib'
     LIBSUFFIX = case OS
     when /darwin/
-      '.dylib'
+      'dylib'
     when /linux|bsd|solaris/
-      '.so'
+      'so'
     when /win/
-      '.dll'
+      'dll'
     else
       raise PlatformError, "Cannot determine shared library extension for #{OS}"
     end

data/lib/ffi/pointer.rb

@@ -0,0 +1,105 @@
+require 'ffi/platform'
+module FFI
+  class Pointer
+    SIZE = Platform::ADDRESS_SIZE / 8
+
+    # Return the size of a pointer on the current platform, in bytes
+    def self.size
+      SIZE
+    end
+    # Write +obj+ as a C int at the memory pointed to.
+    def write_int(obj)
+      put_int32(0, obj)
+    end
+
+    # Read a C int from the memory pointed to.
+    def read_int
+      get_int32(0)
+    end
+
+    # Write +obj+ as a C long at the memory pointed to.
+    def write_long(obj)
+      put_long(0, obj)
+    end
+
+    # Read a C long from the memory pointed to.
+    def read_long
+      get_long(0)
+    end
+    # Write +obj+ as a C long long at the memory pointed to.
+    def write_long_long(obj)
+      put_int64(0, obj)
+    end
+
+    # Read a C long long from the memory pointed to.
+    def read_long_long
+      get_int64(0)
+    end
+    def read_pointer
+      get_pointer(0)
+    end
+    def read_float
+      get_float32(0)
+    end
+    def write_float(obj)
+      put_float32(0, obj)
+    end
+
+    def read_string(len=nil)
+      if len
+        get_string(0, len)
+      else
+        get_string(0)
+      end
+    end
+    def read_string_length(len)
+      get_string(0, len)
+    end
+    def read_string_to_null
+      get_string(0)
+    end
+    def write_string_length(str, len)
+      put_string(0, str, 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)
+    end
+    def read_array_of_type(type, reader, length)
+      ary = []
+      size = FFI.type_size(type)
+      tmp = self
+      length.times {
+        ary << tmp.send(reader)
+        tmp += size
+      }
+      ary
+    end
+
+    def write_array_of_type(type, writer, ary)
+      size = FFI.type_size(type)
+      tmp = self
+      ary.each {|i|
+        tmp.send(writer, i)
+        tmp += size
+      }
+      self
+    end
+    def read_array_of_int(length)
+      get_array_of_int32(0, length)
+    end
+
+    def write_array_of_int(ary)
+      put_array_of_int32(0, ary)
+    end
+
+    def read_array_of_long(length)
+      get_array_of_long(0, length)
+    end
+
+    def write_array_of_long(ary)
+      put_array_of_long(0, ary)
+    end
+  end
+end

data/lib/ffi/struct.rb

@@ -14,10 +14,6 @@ module FFI
     end
   end
   class StructLayoutBuilder
-    LONG_ALIGN = Platform::ARCH =~ /sparc.*/ ? 64 : Platform::LONG_SIZE
-    ADDRESS_ALIGN = Platform::ARCH =~ /sparc.*/ ? 64 : Platform::ADDRESS_SIZE
-    FLOAT_ALIGN = Platform::ARCH =~ /sparc.*/ ? 64 : Platform::ADDRESS_SIZE
-    DOUBLE_ALIGN = Platform::ARCH =~ /sparc.*/ ? 64 : Platform::ADDRESS_SIZE
     class Field
       def initialize(off)
         @off = off
@@ -38,6 +34,7 @@ module FFI
     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
@@ -47,6 +44,7 @@ module FFI
     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
@@ -56,6 +54,7 @@ module FFI
     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
@@ -65,6 +64,7 @@ module FFI
     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
@@ -74,6 +74,7 @@ module FFI
     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
@@ -83,6 +84,7 @@ module FFI
     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
@@ -92,7 +94,7 @@ module FFI
     end
     class Signed64 < Field
       def self.size; 64; end
-      def self.align; LONG_ALIGN; end
+      def self.align; Platform::INT64_ALIGN; end
       def put(ptr, val)
         ptr.put_int64(@off, val)
       end
@@ -102,7 +104,7 @@ module FFI
     end
     class Unsigned64 < Field
       def self.size; 64; end
-      def self.align; LONG_ALIGN; end
+      def self.align; Platform::INT64_ALIGN; end
       def put(ptr, val)
         ptr.put_uint64(@off, val)
       end
@@ -110,6 +112,47 @@ module FFI
         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)
+      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)
+      end
+      def get(ptr)
+        ptr.get_float64(@off)
+      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)
+      end
+      def get(ptr)
+        ptr.get_pointer(@off)
+      end
+    end
+    class StringField < 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"
+      end
+      def get(ptr)
+        strp = ptr.get_pointer(@off)
+        (strp.nil? || strp.null?) ? nil : strp.get_string(0)
+      end
+    end
     def initialize
       @fields = {}
       @size = 0
@@ -136,6 +179,14 @@ module FFI
         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
       else
         raise ArgumentError, "Unknown type: #{type}"
       end
@@ -202,62 +253,66 @@ module FFI
       @pointer.clear
       self
     end
+    def to_ptr
+      @pointer
+    end
+    def self.in
+      :buffer_in
+    end
+    def self.out
+      :buffer_out
+    end
   end
   class Struct < BaseStruct
-    def self.jruby_layout(spec)
+    private
+    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
+      end
+    end
+    def self.find_type(type, mod = nil)
+      return 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
+      mod = enclosing_module
       spec[0].each do |name,type|
-        builder.add_field(name, FFI.find_type(type))
+        builder.add_field(name, find_type(type, mod))
       end
       builder.build
     end
-    def self.rubinius_layout(spec)
+    def self.array_layout(spec)
       builder = FFI::StructLayoutBuilder.new
+      mod = enclosing_module
       i = 0
       while i < spec.size
-        name, type, offset = spec[i, 3]
-      
-        code = FFI.find_type(type)
-        builder.add_field(name, code, offset)
-        i += 3
+        name, type = spec[i, 2]
+        i += 2
+        code = find_type(type, mod)
+        # If the next param is a Fixnu, 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)
+        end
       end
       builder.build
     end
+    public
     def self.layout(*spec)
-
+      
       return @layout if spec.size == 0
-      cspec = spec[0].kind_of?(Hash) ? jruby_layout(spec) : rubinius_layout(spec)
+      cspec = spec[0].kind_of?(Hash) ? hash_layout(spec) : array_layout(spec)
 
       @layout = cspec unless self == FFI::Struct
       @size = cspec.size
       return cspec
     end
-    def self.config(base, *fields)
-      config = Config::CONFIG
-      @size = config["#{base}.sizeof"]
-    
-      builder = StructLayoutBuilder.new
-    
-      fields.each do |field|
-        offset = config["#{base}.#{field}.offset"]
-        size   = config["#{base}.#{field}.size"]
-        type   = config["#{base}.#{field}.type"]
-        type   = type ? type.to_sym : FFI.size_to_type(size)
-
-        code = FFI.find_type type
-        if (code == NativeType::CHAR_ARRAY)
-          builder.add_char_array(field.to_s, size, offset)
-        else
-          builder.add_field(field.to_s, code, offset)
-        end
-      end
-      cspec = builder.build
-    
-      @layout = cspec
-      @size = cspec.size if @size < cspec.size
-    
-      return cspec
-    end
   end
 end