gir_ffi 0.1.0 → 0.2.0

data/lib/gir_ffi/arg_helper.rb

@@ -109,6 +109,7 @@ module GirFFI
       strv_to_utf8_array ptr.read_pointer
     end
 
+    # FIXME: Make GLib::Strv a class.
     def self.strv_to_utf8_array strv
       return [] if strv.null?
       arr, offset = [], 0
@@ -119,45 +120,6 @@ module GirFFI
       return arr
     end
 
-    def self.utf8_array_to_glist arr
-      return nil if arr.nil?
-      arr.inject(GLib.list_new :utf8) { |lst, str|
-        GLib.list_append lst, InPointer.from(:utf8, 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(GLib.slist_new :utf8) { |lst, str|
-        GLib.slist_prepend lst, InPointer.from(:utf8, 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.check_error errpp
       errp = errpp.read_pointer
       # FIXME: Do not depend on GError from GObjectIntrospection namespace.
@@ -176,9 +138,13 @@ module GirFFI
 
     # FIXME: Quasi-circular dependency on generated module
     def self.object_pointer_to_object optr
+      gtype = GObject.type_from_instance_pointer optr
+      wrap_object_pointer_by_gtype optr, gtype
+    end
+
+    def self.wrap_object_pointer_by_gtype optr, gtype
       return nil if optr.null?
-      gtype = ::GObject.type_from_instance_pointer optr
-      klass = GirFFI::Builder.build_by_gtype gtype
+      klass = Builder.build_by_gtype gtype
       klass.wrap optr
     end
 
@@ -204,9 +170,5 @@ module GirFFI
     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

data/lib/gir_ffi/builder.rb

@@ -34,6 +34,7 @@ module GirFFI
     # TODO: Move elsewhere, perhaps to Builder::Function.
     def self.attach_ffi_function lib, info
       sym = info.symbol
+      return if lib.method_defined? sym
       argtypes = ffi_function_argument_types info
       rt = ffi_function_return_type info
 
@@ -60,7 +61,6 @@ module GirFFI
 
     def self.ffi_function_return_type info
       rt = info.return_type
-      return :string if rt.tag == :utf8
       itypeinfo_to_ffitype rt
     end
 

data/lib/gir_ffi/builder/argument.rb

@@ -10,43 +10,49 @@ require 'gir_ffi/builder/argument/hash_table_base'
 
 module GirFFI::Builder
   module Argument
-    def self.build function_builder, arginfo, libmodule
+    def self.build var_gen, arginfo, libmodule
       {
         :inout => InOutArgument,
         :in => InArgument,
         :out => OutArgument
-      }[arginfo.direction].build function_builder, arginfo, libmodule
+      }[arginfo.direction].build var_gen, arginfo, libmodule
     end
   end
 
   module InArgument
-    def self.build function_builder, arginfo, libmodule
+    def self.build var_gen, arginfo, libmodule
       type = arginfo.argument_type
-      klass = case type.tag
-              when :interface
-                if type.interface.info_type == :callback
-                  CallbackInArgument
-                else
-                  RegularInArgument
-                end
-              when :void
-                VoidInArgument
-              when :array
-                if type.array_type == :c
-                  CArrayInArgument
-                else
-                  RegularInArgument
-                end
-              when :glist, :gslist
-                ListInArgument
-              when :ghash
-                HashTableInArgument
-              when :utf8
-                Utf8InArgument
-              else
-                RegularInArgument
-              end
-      klass.new function_builder, arginfo, libmodule
+      klass = builder_for type
+      klass.new var_gen, arginfo.name, type, libmodule
+    end
+
+    def self.builder_for type
+      case type.tag
+      when :interface
+        if type.interface.info_type == :callback
+          CallbackInArgument
+        else
+          RegularInArgument
+        end
+      when :void
+        VoidInArgument
+      when :array
+        if type.array_type == :c
+          CArrayInArgument
+        else
+          RegularInArgument
+        end
+      when :glist
+        ListInArgument
+      when :gslist
+        SListInArgument
+      when :ghash
+        HashTableInArgument
+      when :utf8
+        Utf8InArgument
+      else
+        RegularInArgument
+      end
     end
   end
 
@@ -81,18 +87,25 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for glist and gslist arguments with
+  # Implements argument processing for glist arguments with
   # direction :in.
   class ListInArgument < Argument::InBase
     def pre
-      [ "#{callarg} = GirFFI::ArgHelper.#{subtype_tag}_array_to_#{type_tag} #{@name}" ]
+      [ "#{callarg} = GLib::List.from_array #{subtype_tag.inspect}, #{@name}" ]
+    end
+  end
+
+  # Implements argument processing for gslist arguments with direction :in.
+  class SListInArgument < Argument::InBase
+    def pre
+      [ "#{callarg} = GLib::SList.from_array #{subtype_tag.inspect}, #{@name}" ]
     end
   end
 
   # Implements argument processing for ghash arguments with direction :in.
   class HashTableInArgument < Argument::InBase
     def pre
-      [ "#{callarg} = GirFFI::ArgHelper.hash_to_ghash #{subtype_tag(0).inspect}, #{subtype_tag(1).inspect}, #{@name}" ]
+      [ "#{callarg} = GLib::HashTable.from_hash #{subtype_tag(0).inspect}, #{subtype_tag(1).inspect}, #{@name}" ]
     end
   end
 
@@ -121,7 +134,7 @@ module GirFFI::Builder
 
   # Implements argument processing for arguments with direction :out.
   module OutArgument
-    def self.build function_builder, arginfo, libmodule
+    def self.build var_gen, arginfo, libmodule
       type = arginfo.argument_type
       klass = case type.tag
               when :interface
@@ -129,7 +142,11 @@ module GirFFI::Builder
                 when :enum, :flags
                   EnumOutArgument
                 else
-                  InterfaceOutArgument
+                  if arginfo.caller_allocates?
+                    AllocatedInterfaceOutArgument
+                  else
+                    InterfaceOutArgument
+                  end
                 end
               when :array
                 if type.zero_terminated?
@@ -151,7 +168,7 @@ module GirFFI::Builder
               else
                 RegularOutArgument
               end
-      klass.new function_builder, arginfo, libmodule
+      klass.new var_gen, arginfo.name, type, libmodule
     end
   end
 
@@ -183,23 +200,27 @@ module GirFFI::Builder
     end
   end
 
+  # Implements argument processing for interface arguments with direction
+  # :out (structs, objects, etc.), allocated by the caller.
+  class AllocatedInterfaceOutArgument < Argument::OutBase
+    def pre
+      [ "#{callarg} = #{argument_class_name}.allocate" ]
+    end
+
+    def post
+      [ "#{retname} = #{callarg}" ]
+    end
+  end
+
   # Implements argument processing for interface arguments with direction
   # :out (structs, objects, etc.).
   class InterfaceOutArgument < Argument::OutBase
     def pre
-      if @arginfo.caller_allocates?
-	[ "#{callarg} = #{argument_class_name}.allocate" ]
-      else
-	[ "#{callarg} = GirFFI::InOutPointer.for :pointer" ]
-      end
+      [ "#{callarg} = GirFFI::InOutPointer.for :pointer" ]
     end
 
     def post
-      if @arginfo.caller_allocates?
-	[ "#{retname} = #{callarg}" ]
-      else
-	[ "#{retname} = #{argument_class_name}.wrap #{callarg}.to_value" ]
-      end
+      [ "#{retname} = #{argument_class_name}.wrap #{callarg}.to_value" ]
     end
   end
 
@@ -282,7 +303,7 @@ module GirFFI::Builder
 
   # Implements argument processing for arguments with direction :inout.
   module InOutArgument
-    def self.build function_builder, arginfo, libmodule
+    def self.build var_gen, arginfo, libmodule
       type = arginfo.argument_type
       klass = case type.tag
               when :interface
@@ -313,7 +334,7 @@ module GirFFI::Builder
                 RegularInOutArgument
               end
 
-      klass.new function_builder, arginfo, libmodule
+      klass.new var_gen, arginfo.name, type, libmodule
     end
   end
 
@@ -394,7 +415,7 @@ module GirFFI::Builder
     include Argument::ListBase
 
     def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GirFFI::ArgHelper.#{subtype_tag}_array_to_#{type_tag}(#{@name})" ]
+      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GLib::List.from_array(#{subtype_tag.inspect}, #{@name})" ]
     end
 
     def post
@@ -404,12 +425,11 @@ module GirFFI::Builder
 
   # Implements argument processing for gslist arguments with direction
   # :inout.
-  # FIXME: Merge code with ListInOutArgument somehow.
   class SListInOutArgument < Argument::InOutBase
     include Argument::ListBase
 
     def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GirFFI::ArgHelper.#{subtype_tag}_array_to_#{type_tag}(#{@name})" ]
+      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GLib::SList.from_array(#{subtype_tag.inspect}, #{@name})" ]
     end
 
     def post
@@ -423,7 +443,7 @@ module GirFFI::Builder
     include Argument::HashTableBase
 
     def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GirFFI::ArgHelper.hash_to_ghash(#{key_t}, #{val_t}, #{@name})" ]
+      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GLib::HashTable.from_hash(#{key_t}, #{val_t}, #{@name})" ]
     end
 
     def post
@@ -451,58 +471,73 @@ module GirFFI::Builder
   # Implements argument processing for return values.
   class ReturnValue < Argument::Base
     def cvar
-      @cvar ||= @function_builder.new_var
+      @cvar ||= @var_gen.new_var
     end
 
     def retname
-      @retname ||= @function_builder.new_var
+      @retname ||= @var_gen.new_var
     end
 
-    def type_info
-      @arginfo.return_type
+    def self.build var_gen, arginfo
+      type = arginfo.return_type
+      klass = builder_for(type, arginfo.constructor?)
+      klass.new var_gen, arginfo.name, type, nil
     end
 
-    def self.build function_builder, arginfo
-      type = arginfo.return_type
-      klass = case type.tag
-              when :void
-                VoidReturnValue
-              when :interface
-                case type.interface.info_type
-                when :struct, :union
-                  InterfaceReturnValue
-                when :interface, :object
-                  if arginfo.constructor?
-                    ConstructorReturnValue
-                  else
-                    ObjectReturnValue
-                  end
-                else
-                  RegularReturnValue
-                end
-              when :array
-                if type.zero_terminated?
-                  StrvReturnValue
-                else
-                  case type.array_type
-                  when :c
-                    CArrayReturnValue
-                  when :array
-                    ArrayReturnValue
-                  when :byte_array
-                    ByteArrayReturnValue
-                  end
-                end
-              when :glist
-                ListReturnValue
-              when :gslist
-                SListReturnValue
-              when :ghash
-                HashTableReturnValue
-              else
-                RegularReturnValue
-              end
-      klass.new function_builder, arginfo, nil
+    def self.builder_for type, is_constructor
+      if type.tag == :interface and
+        [:interface, :object].include? type.interface.info_type
+        if is_constructor
+          ConstructorReturnValue
+        else
+          ObjectReturnValue
+        end
+      else
+        builder_for_field_getter type
+      end
+    end
+
+    def self.builder_for_field_getter type
+      case type.tag
+      when :void
+        if type.pointer?
+          RegularReturnValue
+        else
+          VoidReturnValue
+        end
+      when :interface
+        case type.interface.info_type
+        when :struct, :union, :interface, :object
+          InterfaceReturnValue
+        else
+          RegularReturnValue
+        end
+      when :array
+        if type.zero_terminated?
+          StrvReturnValue
+        else
+          case type.array_type
+          when :c
+            CArrayReturnValue
+          when :array
+            ArrayReturnValue
+          when :byte_array
+            ByteArrayReturnValue
+          else
+            PtrArrayReturnValue
+          end
+        end
+      when :glist
+        ListReturnValue
+      when :gslist
+        SListReturnValue
+      when :ghash
+        HashTableReturnValue
+      when :utf8
+        Utf8ReturnValue
+      else
+        RegularReturnValue
+      end
     end
 
     def inarg
@@ -555,6 +590,13 @@ module GirFFI::Builder
     end
   end
 
+  # Implements argument processing for UTF8 string return values.
+  class Utf8ReturnValue < ReturnValue
+    def post
+      [ "#{retname} = GirFFI::ArgHelper.ptr_to_utf8 #{@cvar}" ]
+    end
+  end
+
   # Implements argument processing for GList return values.
   class ListReturnValue < ReturnValue
     include Argument::ListBase
@@ -582,14 +624,14 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for GHashTable return values.
+  # Implements argument processing for GByteArray return values.
   class ByteArrayReturnValue < ReturnValue
     def post
       [ "#{retname} = GLib::ByteArray.wrap(#{cvar})" ]
     end
   end
 
-  # Implements argument processing for GHashTable return values.
+  # Implements argument processing for GArray return values.
   class ArrayReturnValue < ReturnValue
     include Argument::ListBase
 
@@ -599,18 +641,17 @@ module GirFFI::Builder
     end
   end
 
+  # Implements argument processing for GPtrArray return values.
+  class PtrArrayReturnValue < ReturnValue
+    def post
+      [ "#{retname} = GLib::PtrArray.wrap(#{cvar})" ]
+    end
+  end
+
   # Implements argument processing for other return values.
   class RegularReturnValue < ReturnValue
     def retval
-      if RUBY_VERSION < "1.9"
-        @cvar
-      else
-        if type_tag == :utf8
-          "#{cvar}.force_encoding('utf-8')"
-        else
-          @cvar
-        end
-      end
+      @cvar
     end
   end
 
@@ -619,7 +660,7 @@ module GirFFI::Builder
   # presence is indicated by the 'throws' attribute of the function.
   class ErrorArgument < Argument::Base
     def callarg
-      @callarg ||= @function_builder.new_var
+      @callarg ||= @var_gen.new_var
     end
 
     def pre