gir_ffi 0.0.8 → 0.0.9

data/History.txt

@@ -1,3 +1,14 @@
+== 0.0.9 / 2011-05-02
+
+* More complete support for the basic types.
+* Improved support for GList, GSList, GStrv, and GValue.
+* Add support for GHashTable, GVariant, GByteArray, and GArray.
+* Generate constants.
+* When setting up a module, set up its dependencies as well.
+* Test against the GIMarshallingTests test namespace.
+* Use minitest/spec for testing.
+* Various bug fixes and internal improvements.
+
 == 0.0.8 / 2011-04-08
 
 * Generate modules with names starting with a lowercase letter (like

data/TODO.rdoc

@@ -28,6 +28,11 @@ two cases are not distinguished.
 Update: generic pointers have been declared 'not introspectable', so
 handling them can be removed.
 
+== Handle fundamental objects that are not GObject.
+
+This is a big one. See commit 1e9822c7817062a9b853269b9418fd78782090b5 in
+gobject-introspection, and TestFundamentalObject in Regress.
+
 == Check binding of GObject:
 
 (11:37:03 PM) walters: the basic story is that GObject should be manually bound

data/examples/01_empty_window.rb

@@ -6,7 +6,6 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'gir_ffi'
 
 GirFFI.setup :Gtk, '2.0'
-GirFFI.setup :GObject
 
 Gtk.init
 win = Gtk::Window.new :toplevel

data/examples/02_hello_world.rb

@@ -6,7 +6,6 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'gir_ffi'
 
 GirFFI.setup :Gtk, '2.0'
-GirFFI.setup :GObject
 
 Gtk.init
 

data/examples/03_upgraded_hello_world.rb

@@ -6,7 +6,6 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'gir_ffi'
 
 GirFFI.setup :Gtk, '2.0'
-GirFFI.setup :GObject
 
 callback = lambda { |widget, data|
   puts "Hello again - #{data} was pressed"

data/examples/04_webkit.rb

@@ -2,7 +2,6 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'gir_ffi'
 
-GirFFI.setup :Gtk, '2.0'
 GirFFI.setup :WebKit, '1.0'
 
 Gtk.init

data/lib/gir_ffi/arg_helper.rb

@@ -1,36 +1,44 @@
 require 'gir_ffi/allocation_helper'
+require 'gir_ffi/builder'
 
 module GirFFI
   module ArgHelper
+    SIMPLE_G_TYPES = [
+      :gint8, :gint16, :gint, :gint32, :gint64,
+      :guint8, :guint16, :guint32, :guint64,
+      :gfloat, :gdouble]
+
+    def self.setup_array_to_inptr_handler_for *types
+      types.flatten.each do |type|
+        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
+        defn =
+          "def self.#{type}_array_to_inptr ary
+            return nil if ary.nil?
+            block = allocate_array_of_type #{ffi_type.inspect}, ary.length
+            block.put_array_of_#{ffi_type} 0, ary
+          end"
+        eval defn
+      end
+    end
+
+    setup_array_to_inptr_handler_for SIMPLE_G_TYPES
+    setup_array_to_inptr_handler_for :pointer
+
     # FIXME: Hideous.
     def self.object_to_inptr obj
       return obj.to_ptr if obj.respond_to? :to_ptr
       return nil if obj.nil?
+      return obj if obj.is_a? FFI::Pointer
       FFI::Pointer.new(obj.object_id)
     end
 
     def self.typed_array_to_inptr type, ary
       return nil if ary.nil?
+      return utf8_array_to_inptr ary if type == :utf8
       block = allocate_array_of_type type, ary.length
       block.send "put_array_of_#{type}", 0, ary
     end
 
-    def self.int32_array_to_inptr ary
-      typed_array_to_inptr :int32, ary
-    end
-
-    def self.int16_array_to_inptr ary
-      typed_array_to_inptr :int16, ary
-    end
-
-    def self.int64_array_to_inptr ary
-      typed_array_to_inptr :int64, ary
-    end
-
-    def self.int8_array_to_inptr ary
-      typed_array_to_inptr :int8, ary
-    end
-
     def self.utf8_to_inptr str
       return nil if str.nil?
       len = str.bytesize
@@ -44,28 +52,17 @@ module GirFFI
       typed_array_to_inptr :pointer, ptr_ary
     end
 
-    def self.gtype_array_to_inptr ary
-      case FFI.type_size(:size_t)
-      when 4
-	int32_array_to_inptr ary
-      when 8
-	int64_array_to_inptr ary
-      else
-	raise RuntimeError, "Unexpected size of :size_t"
-      end
-    end
-
-    def self.gvalue_array_to_inptr ary
+    # FIXME: :interface is too generic. implement only GValueArray?
+    def self.interface_array_to_inptr ary
       return nil if ary.nil?
       raise NotImplementedError
     end
 
-    class << self
-      alias int_array_to_inptr int32_array_to_inptr
-      alias gint8_array_to_inptr int8_array_to_inptr
-      alias gint16_array_to_inptr int16_array_to_inptr
-      alias gint32_array_to_inptr int32_array_to_inptr
-      alias gint64_array_to_inptr int64_array_to_inptr
+    def self.interface_pointer_array_to_inptr ary
+      return nil if ary.nil?
+      ptr_ary = ary.map {|ifc| ifc.to_ptr}
+      ptr_ary << nil
+      pointer_array_to_inptr ptr_ary
     end
 
     def self.cleanup_ptr ptr
@@ -87,8 +84,22 @@ module GirFFI
       LibC.free ptr
     end
 
-    def self.int32_to_inoutptr val
-      int32_pointer.put_int32 0, val
+    def self.setup_type_to_inoutptr_handler_for *types
+      types.flatten.each do |type|
+        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
+        defn =
+          "def self.#{type}_to_inoutptr val
+            #{type}_pointer.put_#{ffi_type} 0, val
+          end"
+        eval defn
+      end
+    end
+
+    setup_type_to_inoutptr_handler_for SIMPLE_G_TYPES
+    setup_type_to_inoutptr_handler_for :pointer
+
+    def self.gboolean_to_inoutptr val
+      gboolean_pointer.put_int 0, (val ? 1 : 0)
     end
 
     def self.utf8_to_inoutptr str
@@ -97,81 +108,81 @@ module GirFFI
     end
 
     def self.int32_array_to_inoutptr ary
-      block = int_array_to_inptr ary
+      block = gint32_array_to_inptr ary
       pointer_pointer.write_pointer block
     end
 
     def self.utf8_array_to_inoutptr ary
       return nil if ary.nil?
-
-      ptrs = ary.map {|str| utf8_to_inptr str}
-
-      block = AllocationHelper.safe_malloc FFI.type_size(:pointer) * ptrs.length
-      block.write_array_of_pointer ptrs
-
-      pointer_pointer.write_pointer block
-    end
-
-    def self.double_to_inoutptr val
-      double_pointer.put_double 0, val
+      pointer_pointer.write_pointer utf8_array_to_inptr(ary)
     end
 
     class << self
-      alias int_to_inoutptr int32_to_inoutptr
-      alias gint32_to_inoutptr int32_to_inoutptr
       alias int_array_to_inoutptr int32_array_to_inoutptr
       alias gint32_array_to_inoutptr int32_array_to_inoutptr
-      alias gdouble_to_inoutptr double_to_inoutptr
     end
 
-    def self.int32_pointer
-      AllocationHelper.safe_malloc FFI.type_size(:int32)
-    end
-
-    def self.double_pointer
-      AllocationHelper.safe_malloc FFI.type_size(:double)
+    def self.setup_pointer_maker_for *types
+      types.flatten.each do |type|
+        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
+        size = FFI.type_size ffi_type
+        defn =
+          "def self.#{type}_pointer
+            AllocationHelper.safe_malloc #{size}
+          end"
+        eval defn
+      end
     end
 
-    def self.pointer_pointer
-      AllocationHelper.safe_malloc FFI.type_size(:pointer)
-    end
+    setup_pointer_maker_for SIMPLE_G_TYPES
+    setup_pointer_maker_for :pointer
 
     class << self
-      alias int_pointer int32_pointer
-      alias gint32_pointer int32_pointer
-      alias gdouble_pointer double_pointer
+      alias gboolean_pointer gint_pointer
     end
 
-    def self.int32_outptr
-      int32_pointer.put_int32 0, 0
+    def self.setup_type_outptr_handler_for *types
+      types.flatten.each do |type|
+        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
+        defn =
+          "def self.#{type}_outptr
+            #{type}_pointer.put_#{ffi_type} 0, 0
+          end"
+        eval defn
+      end
     end
 
-    def self.double_outptr
-      double_pointer.write_double 0.0
+    setup_type_outptr_handler_for SIMPLE_G_TYPES
+
+    def self.gboolean_outptr
+      gboolean_pointer.put_int 0, 0
     end
 
     def self.pointer_outptr
-      pointer_pointer.write_pointer nil
+      pointer_pointer.put_pointer 0, nil
     end
 
     def self.utf8_outptr
       pointer_outptr
     end
 
-    class << self
-      alias int_outptr int32_outptr
-      alias gint32_outptr int32_outptr
-      alias gdouble_outptr double_outptr
+    def self.setup_outptr_to_type_handler_for *types
+      types.flatten.each do |type|
+        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
+        defn =
+          "def self.outptr_to_#{type} ptr
+            ptr.get_#{ffi_type} 0
+          end"
+        eval defn
+      end
     end
 
-    # Converts an outptr to a pointer.
-    def self.outptr_to_pointer ptr
-      ptr.read_pointer
-    end
+    setup_outptr_to_type_handler_for SIMPLE_G_TYPES
+    setup_outptr_to_type_handler_for :pointer
 
-    # Converts an outptr to an int.
-    def self.outptr_to_int32 ptr
-      ptr.get_int32 0
+    # Converts an outptr to a boolean.
+    def self.outptr_to_gboolean ptr
+      (ptr.get_int 0) != 0
     end
 
     # Converts an outptr to a string.
@@ -183,14 +194,7 @@ module GirFFI
     def self.outptr_to_utf8_array ptr, size
       block = ptr.read_pointer
       return nil if block.null?
-      ptrs = block.read_array_of_pointer(size)
-
-      ptrs.map { |ptr| ptr_to_utf8 ptr }
-    end
-
-    # Converts an outptr to a double.
-    def self.outptr_to_double ptr
-      ptr.get_double 0
+      ptr_to_utf8_array block, size
     end
 
     # Converts an outptr to an array of int.
@@ -200,39 +204,144 @@ module GirFFI
       ptr_to_int32_array block, size
     end
 
+    # Converts an outptr to an array of the given class.
+    def self.outptr_to_interface_array klass, ptr, size
+      block = ptr.read_pointer
+      return nil if block.null?
+      ptr_to_interface_array klass, block, size
+    end
+
     class << self
-      alias outptr_to_int outptr_to_int32
       alias outptr_to_int_array outptr_to_int32_array
-      alias outptr_to_gint32 outptr_to_int32
       alias outptr_to_gint32_array outptr_to_int32_array
-      alias outptr_to_gdouble outptr_to_double
+    end
+
+    def self.ptr_to_typed_array type, ptr, size
+      if type == :utf8
+        ptr_to_utf8_array ptr, size
+      else
+        ptr.send "get_array_of_#{type}", 0, size
+      end
     end
 
     def self.ptr_to_int32_array ptr, size
       ptr.get_array_of_int32(0, size)
     end
 
-    def self.ptr_to_utf8 ptr
-      ptr.null? ? nil : ptr.read_string
+    def self.ptr_to_int16_array ptr, size
+      ptr.get_array_of_int16(0, size)
+    end
+
+    def self.ptr_to_utf8_array ptr, size
+      ptrs = ptr.read_array_of_pointer(size)
+
+      ptrs.map { |ptr| ptr_to_utf8 ptr }
+    end
+
+    def self.ptr_to_interface_array klass, ptr, size
+      sz = klass.ffi_structure.size
+      arr = []
+      size.times do
+        arr << klass.wrap(ptr)
+        ptr += sz
+      end
+      arr
+    end
+
+    if RUBY_VERSION < "1.9"
+      def self.ptr_to_utf8 ptr
+        ptr.null? ? nil : ptr.read_string
+      end
+    else
+      def self.ptr_to_utf8 ptr
+        ptr.null? ? nil : ptr.read_string.force_encoding("utf-8")
+      end
+    end
+
+    def self.ptr_to_utf8_length ptr, len
+      ptr.null? ? nil : ptr.read_string(len)
     end
 
     class << self
       alias ptr_to_int_array ptr_to_int32_array
       alias ptr_to_gint32_array ptr_to_int32_array
+      alias ptr_to_gint16_array ptr_to_int16_array
+    end
+
+    # Set up gtype handlers depending on type size.
+    class << self
+      case FFI.type_size(:size_t)
+      when 4
+        alias gtype_array_to_inptr gint32_array_to_inptr
+        alias gtype_outptr gint32_outptr
+        alias gtype_to_inoutptr gint32_to_inoutptr
+        alias outptr_to_gtype outptr_to_gint32
+      when 8
+        alias gtype_array_to_inptr gint64_array_to_inptr
+        alias gtype_outptr gint64_outptr
+        alias gtype_to_inoutptr gint64_to_inoutptr
+        alias outptr_to_gtype outptr_to_gint64
+      else
+        raise RuntimeError, "Unexpected size of :size_t"
+      end
+    end
+
+    def self.outptr_strv_to_utf8_array ptr
+      strv_to_utf8_array ptr.read_pointer
+    end
+
+    def self.strv_to_utf8_array strv
+      return [] if strv.null?
+      arr = []
+      i = 0
+      loop do
+        ptr = strv.get_pointer i * FFI.type_size(:pointer)
+        break if ptr.null?
+        arr << ptr.read_string
+        i += 1
+      end
+      return arr
     end
 
     def self.utf8_array_to_glist arr
       return nil if arr.nil?
-      arr.inject(nil) { |lst, str|
+      arr.inject(GLib.list_new :utf8) { |lst, str|
         GLib.list_append lst, utf8_to_inptr(str) }
     end
 
+    def self.gint32_array_to_glist arr
+      return nil if arr.nil?
+      arr.inject(GLib.list_new :gint32) { |lst, int|
+        GLib.list_append lst, cast_int32_to_pointer(int) }
+    end
+
     def self.utf8_array_to_gslist arr
       return nil if arr.nil?
-      arr.reverse.inject(nil) { |lst, str|
+      arr.reverse.inject(GLib.slist_new :utf8) { |lst, str|
         GLib.slist_prepend lst, utf8_to_inptr(str) }
     end
 
+    def self.gint32_array_to_gslist arr
+      return nil if arr.nil?
+      arr.reverse.inject(GLib.slist_new :gint32) { |lst, int|
+        GLib.slist_prepend lst, cast_int32_to_pointer(int) }
+    end
+
+    def self.hash_to_ghash keytype, valtype, hash
+      return nil if hash.nil?
+      ghash = GLib.hash_table_new keytype, valtype
+      hash.each do |key, val|
+        ghash.insert key, val
+      end
+      ghash
+    end
+
+    def self.void_array_to_gslist ary
+      return nil if ary.nil?
+      return ary if ary.is_a? GLib::SList
+      raise NotImplementedError
+    end
+
     def self.glist_to_utf8_array ptr
       return [] if ptr.null?
       # FIXME: Quasi-circular dependency on generated module
@@ -267,6 +376,7 @@ module GirFFI
 	map_single_callback_arg arg, inf }
     end
 
+    # TODO: Use GirFFI::ReturnValue classes for mapping.
     def self.map_single_callback_arg arg, info
       case info.argument_type.tag
       when :interface
@@ -333,5 +443,32 @@ module GirFFI
     def self.gir
       gir = GirFFI::IRepository.default
     end
+
+    def self.cast_from_pointer type, it
+      case type
+      when :utf8, :filename
+        ptr_to_utf8 it
+      when :gint32
+        cast_pointer_to_int32 it
+      else
+        it.address
+      end
+    end
+
+    def self.cast_uint32_to_int32 val
+      if val >= 0x80000000
+        -(0x100000000-val)
+      else
+        val
+      end
+    end
+
+    def self.cast_pointer_to_int32 ptr
+      cast_uint32_to_int32(ptr.address & 0xffffffff)
+    end
+
+    def self.cast_int32_to_pointer int
+      FFI::Pointer.new(int)
+    end
   end
 end