gir_ffi 0.2.2 → 0.2.3

data/lib/ffi-gobject_introspection/i_struct_info.rb

@@ -23,18 +23,28 @@ module GObjectIntrospection
     build_array_method :get_methods
 
     def find_method(name)
-      @methods_hash ||= get_methods.inject({}) {|h,m| h[m.name] = m; h}
+      @methods_hash ||= make_method_hash
       @methods_hash[name]
     end
 
     def size
       Lib.g_struct_info_get_size @gobj
     end
+
     def alignment
       Lib.g_struct_info_get_alignment @gobj
     end
+
     def gtype_struct?
       Lib.g_struct_info_is_gtype_struct @gobj
     end
+
+    private
+
+    def make_method_hash
+      Hash.new.tap do |hash|
+        get_methods.each {|mth| hash[mth.name] = mth }
+      end
+    end
   end
 end

data/lib/ffi-gobject_introspection/lib.rb

@@ -239,6 +239,8 @@ module GObjectIntrospection
     attach_function :g_interface_info_get_iface_struct, [:pointer], :pointer
 
     class GIArgument < FFI::Union
+      signed_size_t = "int#{FFI.type_size(:size_t) * 8}".to_sym
+
       layout :v_boolean, :int,
         :v_int8, :int8,
         :v_uint8, :uint8,
@@ -256,7 +258,7 @@ module GObjectIntrospection
         :v_uint, :uint,
         :v_long, :long,
         :v_ulong, :ulong,
-        :v_ssize, :size_t, # FIXME: Needs to be signed.
+        :v_ssize, signed_size_t,
         :v_size, :size_t,
         :v_string, :string,
         :v_pointer, :pointer

data/lib/gir_ffi/arg_helper.rb

@@ -90,25 +90,9 @@ module GirFFI
       alias_method :ptr_to_gtype_array, "ptr_to_#{type}_array"
     end
 
-    def self.outptr_strv_to_utf8_array ptr
-      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
-      until (ptr = strv.get_pointer offset).null? do
-        arr << ptr.read_string
-        offset += POINTER_SIZE
-      end
-      return arr
-    end
-
     def self.check_error errpp
-      errp = errpp.read_pointer
-      # FIXME: Do not depend on GError from GObjectIntrospection namespace.
-      raise GObjectIntrospection::GError.new(errp)[:message] unless errp.null?
+      err = GLib::Error.wrap(errpp.read_pointer)
+      raise err.message unless err.nil?
     end
 
     def self.check_fixed_array_size size, arr, name
@@ -121,7 +105,6 @@ module GirFFI
       AllocationHelper.safe_malloc FFI.type_size(type) * length
     end
 
-    # 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

data/lib/gir_ffi/builder/argument.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require 'gir_ffi/in_pointer'
 require 'gir_ffi/in_out_pointer'
 
@@ -5,8 +7,6 @@ require 'gir_ffi/builder/argument/base'
 require 'gir_ffi/builder/argument/in_base'
 require 'gir_ffi/builder/argument/out_base'
 require 'gir_ffi/builder/argument/in_out_base'
-require 'gir_ffi/builder/argument/list_base'
-require 'gir_ffi/builder/argument/hash_table_base'
 
 module GirFFI::Builder
   module Argument
@@ -22,47 +22,61 @@ module GirFFI::Builder
   module InArgument
     def self.build var_gen, arginfo, libmodule
       type = arginfo.argument_type
-      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
+      builder_for var_gen, arginfo.name, type, libmodule
+    end
+
+    def self.builder_for var_gen, name, type, libmodule
+      klass = case type.tag
+              when :interface
+                case type.interface.info_type
+                when :callback
+                  return CallbackInArgument.new var_gen, name, type, libmodule
+                when :object, :struct
+                  ObjectInArgument
+                else
+                  RegularInArgument
+                end
+              when :void
+                VoidInArgument
+              when :array
+                if type.array_type == :c
+                  CArrayInArgument
+                else
+                  RegularInArgument
+                end
+              when :glist, :gslist
+                it = Argument::InBase.new var_gen, name, type
+                it.extend ContainerClassName
+                it.extend ListElementTypeProvider
+                it.extend WithTypedContainerPreMethod
+                return it
+              when :ghash
+                it = Argument::InBase.new var_gen, name, type
+                it.extend ContainerClassName
+                it.extend HashTableElementTypeProvider
+                it.extend WithTypedContainerPreMethod
+                return it
+              when :utf8
+                Utf8InArgument
+              else
+                RegularInArgument
+              end
+      return klass.new var_gen, name, type
     end
   end
 
   # Implements argument processing for callback arguments with direction
   # :in.
   class CallbackInArgument < Argument::InBase
+    def initialize var_gen, name, type, libmodule
+      super var_gen, name, type
+      @libmodule = libmodule
+    end
+
     def pre
       iface = type_info.interface
       [ "#{callarg} = GirFFI::CallbackHelper.wrap_in_callback_args_mapper \"#{iface.namespace}\", \"#{iface.name}\", #{@name}",
-        "::#{@libmodule}::CALLBACKS << #{callarg}" ]
+        "#{@libmodule}::CALLBACKS << #{callarg}" ]
     end
   end
 
@@ -74,38 +88,48 @@ module GirFFI::Builder
     end
   end
 
+  module ContainerClassName
+    TAG_TO_CONTAINER_CLASS_MAP = {
+      :glist => 'GLib::List',
+      :gslist => 'GLib::SList',
+      :ghash => 'GLib::HashTable',
+      :array => 'GLib::Array'
+    }
+
+    def class_name
+      TAG_TO_CONTAINER_CLASS_MAP[type_info.tag]
+    end
+  end
+
+  module ListElementTypeProvider
+    def elm_t
+      subtype_tag.inspect
+    end
+  end
+
+  module HashTableElementTypeProvider
+    def elm_t
+      [subtype_tag(0), subtype_tag(1)].inspect
+    end
+  end
+
   # Implements argument processing for array arguments with direction :in.
   class CArrayInArgument < Argument::InBase
+    include ListElementTypeProvider
     def pre
       pr = []
       size = type_info.array_fixed_size
       if size > -1
         pr << "GirFFI::ArgHelper.check_fixed_array_size #{size}, #{@name}, \"#{@name}\""
       end
-      pr << "#{callarg} = GirFFI::InPointer.from_array #{subtype_tag.inspect}, #{@name}"
+      pr << "#{callarg} = GirFFI::InPointer.from_array #{elm_t}, #{@name}"
       pr
     end
   end
 
-  # Implements argument processing for glist arguments with
-  # direction :in.
-  class ListInArgument < Argument::InBase
-    def pre
-      [ "#{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
+  module WithTypedContainerPreMethod
     def pre
-      [ "#{callarg} = GLib::HashTable.from_hash #{subtype_tag(0).inspect}, #{subtype_tag(1).inspect}, #{@name}" ]
+      [ "#{callarg} = #{class_name}.from #{elm_t}, #{@name}" ]
     end
   end
 
@@ -117,6 +141,14 @@ module GirFFI::Builder
     end
   end
 
+  # Implements argument processing for arguments with direction :in that
+  # are GObjects.
+  class ObjectInArgument < Argument::InBase
+    def pre
+      [ "#{callarg} = #{argument_class_name}.from #{@name}" ]
+    end
+  end
+
   # Implements argument processing for arguments with direction :in whose
   # type-specific processing is left to FFI (e.g., ints and floats, and
   # objects that implement to_ptr.).
@@ -156,47 +188,53 @@ module GirFFI::Builder
                   when :c
                     CArrayOutArgument
                   when :array
-                    ArrayOutArgument
+                    it = PointerLikeOutArgument.new var_gen, arginfo.name, type
+                    it.extend ContainerClassName
+                    it.extend ListElementTypeProvider
+                    it.extend WithTypedContainerPostMethod
+                    return it
                   end
                 end
-              when :glist
-                ListOutArgument
-              when :gslist
-                SListOutArgument
+              when :glist, :gslist
+                it = PointerLikeOutArgument.new var_gen, arginfo.name, type
+                it.extend ContainerClassName
+                it.extend ListElementTypeProvider
+                it.extend WithTypedContainerPostMethod
+                return it
               when :ghash
-                HashTableOutArgument
+                it = PointerLikeOutArgument.new var_gen, arginfo.name, type
+                it.extend ContainerClassName
+                it.extend HashTableElementTypeProvider
+                it.extend WithTypedContainerPostMethod
+                return it
               else
                 RegularOutArgument
               end
-      klass.new var_gen, arginfo.name, type, libmodule
+      klass.new var_gen, arginfo.name, type
     end
   end
 
   # Implements argument processing for arguments with direction
   # :out that are neither arrays nor 'interfaces'.
   class RegularOutArgument < Argument::OutBase
-    def post
-      [ "#{retname} = #{callarg}.to_value" ]
+    def pre
+      [ "#{callarg} = GirFFI::InOutPointer.for #{type_tag.inspect}" ]
     end
 
-    private
-
-    def base_type
-      type_tag
+    def post
+      [ "#{retname} = #{callarg}.to_value" ]
     end
   end
 
   # Implements argument processing for arguments with direction
   # :out that are enums
-  class EnumOutArgument < RegularOutArgument
-    def post
-      [ "#{retname} = #{argument_class_name}[#{callarg}.to_value]" ]
+  class EnumOutArgument < Argument::OutBase
+    def pre
+      [ "#{callarg} = GirFFI::InOutPointer.for :gint32" ]
     end
 
-    private
-
-    def base_type
-      :gint32
+    def post
+      [ "#{retname} = #{argument_class_name}[#{callarg}.to_value]" ]
     end
   end
 
@@ -212,32 +250,9 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for interface arguments with direction
-  # :out (structs, objects, etc.).
-  class InterfaceOutArgument < Argument::OutBase
-    def pre
-      [ "#{callarg} = GirFFI::InOutPointer.for :pointer" ]
-    end
-
-    def post
-      [ "#{retname} = #{argument_class_name}.wrap #{callarg}.to_value" ]
-    end
-  end
-
-  # Base class for arguments with direction :out for which the base type is
-  # a pointer: For these, a pointer to a pointer needs to be passed to the
-  # C function.
-  class PointerLikeOutArgument < Argument::OutBase
-    private
-
-    def base_type
-      :pointer
-    end
-  end
-
   # Implements argument processing for array arguments with direction
   # :out.
-  class CArrayOutArgument < PointerLikeOutArgument
+  class CArrayOutArgument < Argument::OutBase
     def pre
       [ "#{callarg} = GirFFI::InOutPointer.for_array #{subtype_tag_or_class_name}" ]
     end
@@ -247,54 +262,34 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for strv arguments with direction
-  # :out.
-  class StrvOutArgument < PointerLikeOutArgument
-    def post
-      [ "#{retname} = GirFFI::ArgHelper.outptr_strv_to_utf8_array #{callarg}" ]
-    end
-  end
-
-  # Implements argument processing for GArray arguments with direction
-  # :out.
-  class ArrayOutArgument < PointerLikeOutArgument
-    include Argument::ListBase
-
-    def post
-      pp = []
-      pp << "#{retname} = GLib::Array.wrap #{callarg}.to_value"
-      pp << "#{retname}.element_type = #{elm_t}"
-      pp
+  # Base class for arguments with direction :out for which the base type is
+  # a pointer: For these, a pointer to a pointer needs to be passed to the
+  # C function.
+  class PointerLikeOutArgument < Argument::OutBase
+    def pre
+      [ "#{callarg} = GirFFI::InOutPointer.for :pointer" ]
     end
   end
 
-  # Implements argument processing for glist arguments with direction
-  # :out.
-  class ListOutArgument < PointerLikeOutArgument
-    include Argument::ListBase
-
+  # Implements argument processing for interface arguments with direction
+  # :out (structs, objects, etc.).
+  class InterfaceOutArgument < PointerLikeOutArgument
     def post
-      [ "#{retname} = GLib::List.wrap #{elm_t}, #{callarg}.to_value" ]
+      [ "#{retname} = #{argument_class_name}.wrap #{callarg}.to_value" ]
     end
   end
 
-  # Implements argument processing for gslist arguments with direction
+  # Implements argument processing for strv arguments with direction
   # :out.
-  class SListOutArgument < PointerLikeOutArgument
-    include Argument::ListBase
-
+  class StrvOutArgument < PointerLikeOutArgument
     def post
-      [ "#{retname} = GLib::SList.wrap #{elm_t}, #{callarg}.to_value" ]
+      [ "#{retname} = GLib::Strv.wrap #{callarg}.to_value" ]
     end
   end
 
-  # Implements argument processing for ghash arguments with direction
-  # :out.
-  class HashTableOutArgument < PointerLikeOutArgument
-    include Argument::HashTableBase
-
+  module WithTypedContainerPostMethod
     def post
-      [ "#{retname} = GLib::HashTable.wrap #{key_t}, #{val_t}, #{callarg}.to_value" ]
+      [ "#{retname} = #{class_name}.wrap #{elm_t}, #{callarg}.to_value" ]
     end
   end
 
@@ -318,20 +313,33 @@ module GirFFI::Builder
                   when :c
                     CArrayInOutArgument
                   when :array
-                    ArrayInOutArgument
+                    it = Argument::InOutBase.new var_gen, arginfo.name, type
+                    it.extend ContainerClassName
+                    it.extend ListElementTypeProvider
+                    it.extend WithTypedContainerInOutPreMethod
+                    it.extend WithTypedContainerPostMethod
+                    return it
                   end
                 end
-              when :glist
-                ListInOutArgument
-              when :gslist
-                SListInOutArgument
+              when :glist, :gslist
+                it = Argument::InOutBase.new var_gen, arginfo.name, type
+                it.extend ContainerClassName
+                it.extend ListElementTypeProvider
+                it.extend WithTypedContainerInOutPreMethod
+                it.extend WithTypedContainerPostMethod
+                return it
               when :ghash
-                HashTableInOutArgument
+                it = Argument::InOutBase.new var_gen, arginfo.name, type
+                it.extend ContainerClassName
+                it.extend HashTableElementTypeProvider
+                it.extend WithTypedContainerInOutPreMethod
+                it.extend WithTypedContainerPostMethod
+                return it
               else
                 RegularInOutArgument
               end
 
-      klass.new var_gen, arginfo.name, type, libmodule
+      klass.new var_gen, arginfo.name, type
     end
   end
 
@@ -353,7 +361,7 @@ module GirFFI::Builder
   # :inout (structs, objects, etc.).
   class InterfaceInOutArgument < Argument::InOutBase
     def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, #{@name}.to_ptr" ]
+      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, #{argument_class_name}.from(#{@name}).to_ptr" ]
     end
 
     def post
@@ -364,20 +372,22 @@ module GirFFI::Builder
   # Implements argument processing for strv arguments with direction
   # :inout.
   class StrvInOutArgument < Argument::InOutBase
+    include ListElementTypeProvider
     def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from_array #{subtype_tag.inspect}, #{@name}" ]
+      [ "#{callarg} = GirFFI::InOutPointer.from_array #{elm_t}, #{@name}" ]
     end
 
     def post
-      [ "#{retname} = GirFFI::ArgHelper.outptr_strv_to_utf8_array #{callarg}" ]
+      [ "#{retname} = GLib::Strv.wrap(#{callarg}.to_value)" ]
     end
   end
 
   # Implements argument processing for array arguments with direction
   # :inout.
   class CArrayInOutArgument < Argument::InOutBase
+    include ListElementTypeProvider
     def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from_array #{subtype_tag.inspect}, #{@name}" ]
+      [ "#{callarg} = GirFFI::InOutPointer.from_array #{elm_t}, #{@name}" ]
     end
 
     def postpost
@@ -385,65 +395,11 @@ module GirFFI::Builder
       pst = [ "#{retname} = #{callarg}.to_sized_array_value #{size}" ]
       pst
     end
-
   end
 
-  # Implements argument processing for GArray arguments with direction
-  # :inout.
-  class ArrayInOutArgument < Argument::InOutBase
-    include Argument::ListBase
-
+  module WithTypedContainerInOutPreMethod
     def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, #{@name}" ]
-    end
-
-    def post
-      pp = []
-      pp << "#{retname} = GLib::Array.wrap(#{callarg}.to_value)"
-      pp << "#{retname}.element_type = #{elm_t}"
-      pp
-    end
-  end
-
-  # Implements argument processing for glist arguments with direction
-  # :inout.
-  class ListInOutArgument < Argument::InOutBase
-    include Argument::ListBase
-
-    def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GLib::List.from_array(#{subtype_tag.inspect}, #{@name})" ]
-    end
-
-    def post
-      [ "#{retname} = GLib::List.wrap #{elm_t}, #{callarg}.to_value" ]
-    end
-  end
-
-  # Implements argument processing for gslist arguments with direction
-  # :inout.
-  class SListInOutArgument < Argument::InOutBase
-    include Argument::ListBase
-
-    def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GLib::SList.from_array(#{subtype_tag.inspect}, #{@name})" ]
-    end
-
-    def post
-      [ "#{retname} = GLib::SList.wrap #{elm_t}, #{callarg}.to_value" ]
-    end
-  end
-
-  # Implements argument processing for ghash arguments with direction
-  # :inout.
-  class HashTableInOutArgument < Argument::InOutBase
-    include Argument::HashTableBase
-
-    def pre
-      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, GLib::HashTable.from_hash(#{key_t}, #{val_t}, #{@name})" ]
-    end
-
-    def post
-      [ "#{retname} = GLib::HashTable.wrap #{key_t}, #{val_t}, #{callarg}.to_value" ]
+      [ "#{callarg} = GirFFI::InOutPointer.from :pointer, #{class_name}.from(#{elm_t}, #{@name})" ]
     end
   end
 
@@ -464,76 +420,91 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for return values.
-  class ReturnValue < Argument::Base
-    def cvar
-      @cvar ||= @var_gen.new_var
-    end
-
-    def retname
-      @retname ||= @var_gen.new_var
-    end
-
+  module ReturnValueFactory
     def self.build var_gen, arginfo
-      type = arginfo.return_type
-      klass = builder_for(type, arginfo.constructor?)
-      klass.new var_gen, arginfo.name, type, nil
+      builder_for(var_gen,
+                  arginfo.name,
+                  arginfo.return_type,
+                  arginfo.constructor?)
     end
 
-    def self.builder_for type, is_constructor
+    def self.builder_for var_gen, name, type, is_constructor
       if type.tag == :interface and
         [:interface, :object].include? type.interface.info_type
-        if is_constructor
-          ConstructorReturnValue
-        else
-          ObjectReturnValue
-        end
+        klass = if is_constructor
+                  ConstructorReturnValue
+                else
+                  ObjectReturnValue
+                end
+        klass.new var_gen, name, type
       else
-        builder_for_field_getter type
+        builder_for_field_getter var_gen, name, 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
+    def self.builder_for_field_getter var_gen, name, type
+      klass = 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
+                    it = ReturnValue.new var_gen, name, type
+                    it.extend ContainerClassName
+                    it.extend ListElementTypeProvider
+                    it.extend WithTypedContainerPostMethod
+                    return it
+                  when :byte_array
+                    ByteArrayReturnValue
+                  else
+                    PtrArrayReturnValue
+                  end
+                end
+              when :glist, :gslist
+                it = ReturnValue.new var_gen, name, type
+                it.extend ContainerClassName
+                it.extend ListElementTypeProvider
+                it.extend WithTypedContainerPostMethod
+                return it
+              when :ghash
+                it = ReturnValue.new var_gen, name, type
+                it.extend ContainerClassName
+                it.extend HashTableElementTypeProvider
+                it.extend WithTypedContainerPostMethod
+                return it
+              when :utf8
+                Utf8ReturnValue
+              else
+                RegularReturnValue
+              end
+      klass.new var_gen, name, type
+    end
+  end
+
+  # Implements argument processing for return values.
+  class ReturnValue < Argument::Base
+    def cvar
+      callarg
+    end
+
+    def retname
+      @retname ||= @var_gen.new_var
     end
 
     def inarg
@@ -582,41 +553,14 @@ module GirFFI::Builder
   # Implements argument processing for NULL-terminated string array return values.
   class StrvReturnValue < ReturnValue
     def post
-      [ "#{retname} = GirFFI::ArgHelper.strv_to_utf8_array #{cvar}" ]
+      [ "#{retname} = GLib::Strv.wrap(#{cvar})" ]
     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
-
-    def post
-      [ "#{retname} = GLib::List.wrap(#{elm_t}, #{cvar})" ]
-    end
-  end
-
-  # Implements argument processing for GSList return values.
-  class SListReturnValue < ReturnValue
-    include Argument::ListBase
-
-    def post
-      [ "#{retname} = GLib::SList.wrap(#{elm_t}, #{cvar})" ]
-    end
-  end
-
-  # Implements argument processing for GHashTable return values.
-  class HashTableReturnValue < ReturnValue
-    include Argument::HashTableBase
-
-    def post
-      [ "#{retname} = GLib::HashTable.wrap(#{key_t}, #{val_t}, #{cvar})" ]
+      [ "#{retname} = GirFFI::ArgHelper.ptr_to_utf8 #{cvar}" ]
     end
   end
 
@@ -627,16 +571,6 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for GArray return values.
-  class ArrayReturnValue < ReturnValue
-    include Argument::ListBase
-
-    def post
-      [ "#{retname} = GLib::Array.wrap(#{cvar})",
-        "#{retname}.element_type = #{elm_t}" ]
-    end
-  end
-
   # Implements argument processing for GPtrArray return values.
   class PtrArrayReturnValue < ReturnValue
     def post
@@ -647,7 +581,7 @@ module GirFFI::Builder
   # Implements argument processing for other return values.
   class RegularReturnValue < ReturnValue
     def retval
-      @cvar
+      @callarg
     end
   end
 
@@ -655,10 +589,6 @@ module GirFFI::Builder
   # arguments are not part of the introspected signature, but their
   # presence is indicated by the 'throws' attribute of the function.
   class ErrorArgument < Argument::Base
-    def callarg
-      @callarg ||= @var_gen.new_var
-    end
-
     def pre
       [ "#{callarg} = FFI::MemoryPointer.new(:pointer).write_pointer nil" ]
     end
@@ -669,6 +599,10 @@ module GirFFI::Builder
   end
 
   # Argument builder that does nothing. Implements Null Object pattern.
-  class NullArgument < Argument::Base
+  class NullArgument
+    def initialize *args; end
+    def pre; []; end
+    def post; []; end
+    def callarg; end
   end
 end