ffi 0.4.0-x86-mswin32

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

@@ -0,0 +1,73 @@
+require 'ffi/pointer'
+module FFI
+  class MemoryPointer
+      # call-seq:
+      #   MemoryPointer.new(num) => MemoryPointer instance of <i>num</i> bytes
+      #   MemoryPointer.new(sym) => MemoryPointer instance with number
+      #                             of bytes need by FFI type <i>sym</i>
+      #   MemoryPointer.new(obj) => MemoryPointer instance with number
+      #                             of <i>obj.size</i> bytes
+      #   MemoryPointer.new(sym, count) => MemoryPointer instance with number
+      #                             of bytes need by length-<i>count</i> array
+      #                             of FFI type <i>sym</i>
+      #   MemoryPointer.new(obj, count) => MemoryPointer instance with number
+      #                             of bytes need by length-<i>count</i> array
+      #                             of <i>obj.size</i> bytes
+      #   MemoryPointer.new(arg) { |p| ... }
+      #
+      # Both forms create a MemoryPointer instance. The number of bytes to
+      # allocate is either specified directly or by passing an FFI type, which
+      # specifies the number of bytes needed for that type.
+      #
+      # The form without a block returns the MemoryPointer instance. The form
+      # 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.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
+
+      # Access the MemoryPointer like a C array, accessing the +which+ number
+      # element in memory. The position of the element is calculate from
+      # +@type_size+ and +which+. A new MemoryPointer object is returned, which
+      # points to the address of the element.
+      #
+      # Example:
+      #   ptr = MemoryPointer.new(:int, 20)
+      #   new_ptr = ptr[9]
+      #
+      # c-equiv:
+      #   int *ptr = (int*)malloc(sizeof(int) * 20);
+      #   int *new_ptr;
+      #   new_ptr = &ptr[9];
+      #
+#      def [](which)
+#        self + (which * type_size)
+#      end
+  end
+end

data/lib/ffi/platform.rb

@@ -0,0 +1,78 @@
+require 'rbconfig'
+module FFI
+  class PlatformError < FFI::NativeError; end
+
+  module Platform
+    OS = case Config::CONFIG['host_os'].downcase
+    when /linux/
+      "linux"
+    when /darwin/
+      "darwin"
+    when /freebsd/
+      "freebsd"
+    when /openbsd/
+      "openbsd"
+    when /sunos|solaris/
+      "solaris"
+    when /win|mingw/
+      "windows"
+    else
+      raise FFI::PlatformError, "Unknown operating system: #{Config::CONFIG['host_os']}"
+    end
+    ARCH = case CPU.downcase
+    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
+    private
+    def self.is_os(os)
+      OS == os
+    end
+    
+    NAME = "#{ARCH}-#{OS}"
+    IS_LINUX = is_os("linux")
+    IS_MAC = is_os("darwin")
+    IS_FREEBSD = is_os("freebsd")
+    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"
+    elsif IS_LINUX
+      "libc.so.6"
+    else
+      "c"
+    end
+    LIBPREFIX = IS_WINDOWS ? '' : 'lib'
+    LIBSUFFIX = case OS
+    when /darwin/
+      'dylib'
+    when /linux|bsd|solaris/
+      'so'
+    when /win/
+      'dll'
+    else
+      raise PlatformError, "Cannot determine shared library extension for #{OS}"
+    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
+  end
+end
+

data/lib/ffi/pointer.rb

@@ -0,0 +1,119 @@
+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 write_pointer(ptr)
+      put_pointer(0, ptr)
+    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_bytes(0, len)
+      else
+        get_string(0)
+      end
+    end
+    def read_string_length(len)
+      get_bytes(0, len)
+    end
+    def read_string_to_null
+      get_string(0)
+    end
+    def write_string_length(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_bytes(0, str, 0, len)
+    end
+    def read_array_of_type(type, reader, length)
+      ary = []
+      size = FFI.type_size(type)
+      tmp = self
+      length.times { |j|
+        ary << tmp.send(reader)
+        tmp += size unless j == length-1 # avoid OOB
+      }
+      ary
+    end
+
+    def write_array_of_type(type, writer, ary)
+      size = FFI.type_size(type)
+      tmp = self
+      ary.each_with_index {|i, j|
+        tmp.send(writer, i)
+        tmp += size unless j == ary.length-1 # avoid OOB
+      }
+      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
+
+    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

data/lib/ffi/struct.rb

@@ -0,0 +1,354 @@
+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] }
+    end
+    def offset_of(field_name)
+      @fields[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
+
+      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
+        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
+    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)
+      @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(@field_names, @fields, align(@size, @min_align), @min_align)
+    end
+
+    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)
+    end
+    def calc_current_size(offset, size)
+      @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
+        @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
+    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) }
+        mod.respond_to?(:find_type) ? mod : nil
+      rescue Exception => ex
+        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
+      mod = enclosing_module
+      spec[0].each do |name,type|
+        builder.add_field(name, find_type(type, mod))
+      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)
+        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