ffi 0.5.0-x86-mingw32

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,88 @@
+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
+      Config::CONFIG['host_os'].downcase
+    end
+
+    ARCH = case CPU.downcase
+    when /amd64|x86_64/
+      "x86_64"
+    when /i?86|x86|i86pc/
+      "i386"
+    when /ppc|powerpc/
+      "powerpc"
+    else
+      Config::CONFIG['host_cpu']
+    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 /windows/
+      'dll'
+    else
+      # 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
+  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,183 @@
+require 'ffi/platform'
+module FFI
+
+  class StructLayout
+
+    def offsets
+      members.map { |m| [ m, self[m].offset ] }
+    end
+
+    def offset_of(field_name)
+      self[field_name].offset
+    end
+  end
+
+  
+  class Struct
+
+    def size
+      self.class.size
+    end
+
+    def alignment
+      self.class.alignment
+    end
+    alias_method :align, :alignment
+
+    def offset_of(name)
+      self.class.offset_of(name)
+    end
+
+    def members
+      self.class.members
+    end
+
+    def values
+      members.map { |m| self[m] }
+    end
+
+    def offsets
+      self.class.offsets
+    end
+
+    def clear
+      pointer.clear
+      self
+    end
+
+    def to_ptr
+      pointer
+    end
+
+    def self.size
+      defined?(@layout) ? @layout.size : defined?(@size) ? @size : 0
+    end
+
+    def self.size=(size)
+      raise ArgumentError, "Size already set" if defined?(@size) || defined?(@layout)
+      @size = size
+    end
+
+    def self.alignment
+      @layout.alignment
+    end
+
+    def self.align
+      @layout.alignment
+    end
+
+    def self.members
+      @layout.members
+    end
+
+    def self.offsets
+      @layout.offsets
+    end
+
+    def self.offset_of(name)
+      @layout.offset_of(name)
+    end
+
+    def self.in
+      :buffer_in
+    end
+
+    def self.out
+      :buffer_out
+    end
+
+    def self.by_value
+      ::FFI::StructByValue.new(self)
+    end
+
+
+
+    class << self
+      public
+
+      def layout(*spec)
+        return @layout if spec.size == 0
+
+        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
+
+
+      protected
+
+      def callback(params, ret)
+        mod = enclosing_module
+        FFI::CallbackInfo.new(find_type(ret, mod), params.map { |e| find_type(e, mod) })
+      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 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
+
+
+      private
+
+      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
+
+      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
+    end
+  end
+end