gir_ffi 0.0.8 → 0.0.9

data/lib/gir_ffi/builder/argument.rb

@@ -46,23 +46,19 @@ module GirFFI::Builder
     end
 
     def type_tag
-      type_info.tag
+      tag = type_info.tag
+      tag == :GType ? :gtype : tag
     end
 
-    def subtype_tag
-      st = type_info.param_type(0)
+    def subtype_tag index=0
+      st = type_info.param_type(index)
       t = st.tag
       case t
       when :GType
         return :gtype
       when :interface
-        raise NotImplementedError if st.pointer?
-        iface = st.interface
-        if iface.name == 'Value' and iface.namespace == 'GObject'
-          return :gvalue
-        else
-          raise NotImplementedError
-        end
+        return :interface_pointer if st.pointer?
+        return :interface
       else
         return t
       end
@@ -70,7 +66,12 @@ module GirFFI::Builder
 
     def argument_class_name
       iface = type_info.interface
-      "::#{iface.namespace}::#{iface.name}"
+      "::#{iface.safe_namespace}::#{iface.name}"
+    end
+
+    def subtype_class_name index=0
+      iface = type_info.param_type(index).interface
+      "::#{iface.safe_namespace}::#{iface.name}"
     end
 
     def array_size
@@ -130,9 +131,15 @@ module GirFFI::Builder
               when :void
                 VoidInArgument
               when :array
-                ArrayInArgument
+                if type.array_type == :c
+                  CArrayInArgument
+                else
+                  RegularInArgument
+                end
               when :glist, :gslist
                 ListInArgument
+              when :ghash
+                HashTableInArgument
               when :utf8
                 Utf8InArgument
               else
@@ -161,7 +168,7 @@ module GirFFI::Builder
   end
 
   # Implements argument processing for array arguments with direction :in.
-  class ArrayInArgument < InArgument
+  class CArrayInArgument < InArgument
     def post
       unless @arginfo.ownership_transfer == :everything
         if subtype_tag == :utf8
@@ -183,13 +190,21 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for gslist arguments with direction :in.
+  # Implements argument processing for glist and gslist arguments with
+  # direction :in.
   class ListInArgument < InArgument
     def pre
       [ "#{@callarg} = GirFFI::ArgHelper.#{subtype_tag}_array_to_#{type_tag} #{@name}" ]
     end
   end
 
+  # Implements argument processing for ghash arguments with direction :in.
+  class HashTableInArgument < InArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.hash_to_ghash #{subtype_tag(0).inspect}, #{subtype_tag(1).inspect}, #{@name}" ]
+    end
+  end
+
   # Implements argument processing for UTF8 string arguments with direction
   # :in.
   class Utf8InArgument < InArgument
@@ -228,13 +243,32 @@ module GirFFI::Builder
     end
 
     def self.build function_builder, arginfo, libmodule
+      type = arginfo.argument_type
       klass = case arginfo.argument_type.tag
               when :interface
-                InterfaceOutArgument
+                case type.interface.info_type
+                when :enum, :flags
+                  EnumOutArgument
+                else
+                  InterfaceOutArgument
+                end
               when :array
-                ArrayOutArgument
+                if type.zero_terminated?
+                  StrvOutArgument
+                else
+                  case type.array_type
+                  when :c
+                    CArrayOutArgument
+                  when :array
+                    ArrayOutArgument
+                  end
+                end
+              when :glist
+                ListOutArgument
               when :gslist
-                GSListOutArgument
+                SListOutArgument
+              when :ghash
+                HashTableOutArgument
               else
                 RegularOutArgument
               end
@@ -242,6 +276,22 @@ module GirFFI::Builder
     end
   end
 
+  # Implements argument processing for arguments with direction
+  # :out that are enums
+  class EnumOutArgument < OutArgument
+    def post
+      pst = [ "#{@retname} = #{argument_class_name}[GirFFI::ArgHelper.outptr_to_gint32 #{@callarg}]" ]
+      if @arginfo.ownership_transfer == :everything
+        pst << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+      end
+      pst
+    end
+
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.gint32_outptr" ]
+    end
+  end
+
   # Implements argument processing for interface arguments with direction
   # :out (structs, objects, etc.).
   class InterfaceOutArgument < OutArgument
@@ -264,7 +314,7 @@ module GirFFI::Builder
 
   # Implements argument processing for array arguments with direction
   # :out.
-  class ArrayOutArgument < OutArgument
+  class CArrayOutArgument < OutArgument
     def pre
       [ "#{@callarg} = GirFFI::ArgHelper.pointer_outptr" ]
     end
@@ -273,11 +323,20 @@ module GirFFI::Builder
       size = array_size
       tag = subtype_tag
 
-      pp = [ "#{@retname} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{@callarg}, #{size}" ]
+      pp = []
+
+      if tag == :interface or tag == :interface_pointer
+        pp << "#{@retname} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{subtype_class_name}, #{@callarg}, #{size}"
+      else
+        pp << "#{@retname} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{@callarg}, #{size}"
+      end
 
       if @arginfo.ownership_transfer == :everything
-	if tag == :utf8
+        case tag
+        when :utf8
 	  pp << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{@callarg}, #{size}"
+        when :interface
+	  pp << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
 	else
 	  pp << "GirFFI::ArgHelper.cleanup_ptr_ptr #{@callarg}"
 	end
@@ -287,17 +346,82 @@ module GirFFI::Builder
     end
   end
 
+  # Implements argument processing for strv arguments with direction
+  # :out.
+  class StrvOutArgument < OutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_outptr" ]
+    end
+
+    def postpost
+      [ "#{@retname} = GirFFI::ArgHelper.outptr_strv_to_utf8_array #{@callarg}" ]
+    end
+  end
+
+  # Implements argument processing for GArray arguments with direction
+  # :out.
+  class ArrayOutArgument < OutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_outptr" ]
+    end
+
+    def post
+      tag = subtype_tag
+      etype = GirFFI::Builder::TAG_TYPE_MAP[tag] || tag
+
+      pp = []
+
+      pp << "#{@retname} = GLib::Array.wrap(GirFFI::ArgHelper.outptr_to_pointer #{@callarg})"
+      pp << "#{@retname}.element_type = #{etype.inspect}"
+
+      if @arginfo.ownership_transfer == :everything
+        pp << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+      end
+
+      pp
+    end
+  end
+
+  # Implements argument processing for glist arguments with direction
+  # :out.
+  class ListOutArgument < OutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_outptr" ]
+    end
+
+    def post
+      elm_t = subtype_tag.inspect
+      [ "#{@retname} = GLib::List.wrap #{elm_t}, GirFFI::ArgHelper.outptr_to_pointer(#{@callarg})" ]
+    end
+  end
+
   # Implements argument processing for gslist arguments with direction
   # :out.
-  class GSListOutArgument < OutArgument
+  class SListOutArgument < OutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_outptr" ]
+    end
+
+    def post
+      elm_t = subtype_tag.inspect
+      [ "#{@retname} = GLib::SList.wrap #{elm_t}, GirFFI::ArgHelper.outptr_to_pointer(#{@callarg})" ]
+    end
+  end
+
+  # Implements argument processing for ghash arguments with direction
+  # :out.
+  class HashTableOutArgument < OutArgument
     def pre
       [ "#{@callarg} = GirFFI::ArgHelper.pointer_outptr" ]
     end
 
     def postpost
-      [ "#{@retname} = GirFFI::ArgHelper.outgslist_to_#{subtype_tag}_array #{@callarg}" ]
+      key_t = subtype_tag(0).inspect
+      val_t = subtype_tag(1).inspect
+      [ "#{@retname} = GLib::HashTable.wrap #{key_t}, #{val_t}, GirFFI::ArgHelper.outptr_to_pointer(#{@callarg})" ]
     end
   end
+
   # Implements argument processing for arguments with direction
   # :out that are neither arrays nor 'interfaces'.
   class RegularOutArgument < OutArgument
@@ -324,13 +448,32 @@ module GirFFI::Builder
     end
 
     def self.build function_builder, arginfo, libmodule
-      raise NotImplementedError unless arginfo.ownership_transfer == :everything
-
-      klass = case arginfo.argument_type.tag
+      type = arginfo.argument_type
+      klass = case type.tag
               when :interface
-                raise NotImplementedError
+                case type.interface.info_type
+                when :enum, :flags
+                  EnumInOutArgument
+                else
+                  InterfaceInOutArgument
+                end
               when :array
-                ArrayInOutArgument
+                if type.zero_terminated?
+                  StrvInOutArgument
+                else
+                  case type.array_type
+                  when :c
+                    CArrayInOutArgument
+                  when :array
+                    ArrayInOutArgument
+                  end
+                end
+              when :glist
+                ListInOutArgument
+              when :gslist
+                SListInOutArgument
+              when :ghash
+                HashTableInOutArgument
               else
                 RegularInOutArgument
               end
@@ -339,34 +482,147 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for array arguments with direction
+  # Implements argument processing for arguments with direction
+  # :inout that are enums.
+  class EnumInOutArgument < InOutArgument
+    def pre
+      pr = []
+      pr << "#{@callarg} = GirFFI::ArgHelper.gint32_to_inoutptr #{argument_class_name}[#{@name}]"
+      pr
+    end
+
+    def post
+      [ "#{@retname} = #{argument_class_name}[GirFFI::ArgHelper.outptr_to_gint32 #{@callarg}]",
+        "GirFFI::ArgHelper.cleanup_ptr #{@callarg}" ]
+    end
+  end
+
+  # Implements argument processing for interface arguments with direction
+  # :inout (structs, objects, etc.).
+  class InterfaceInOutArgument < InOutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_to_inoutptr #{@name}.to_ptr" ]
+    end
+
+    def post
+      [ "#{@retname} = #{argument_class_name}.wrap(GirFFI::ArgHelper.outptr_to_pointer #{@callarg})",
+        "GirFFI::ArgHelper.cleanup_ptr #{@callarg}" ]
+    end
+  end
+
+  # Implements argument processing for strv arguments with direction
   # :inout.
-  class ArrayInOutArgument < InOutArgument
+  class StrvInOutArgument < InOutArgument
     def pre
       [ "#{@callarg} = GirFFI::ArgHelper.#{subtype_tag}_array_to_inoutptr #{@name}" ]
     end
 
     def post
+      [ "#{@retname} = GirFFI::ArgHelper.outptr_strv_to_utf8_array #{@callarg}" ]
+    end
+  end
+
+  # Implements argument processing for array arguments with direction
+  # :inout.
+  class CArrayInOutArgument < InOutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.#{subtype_tag}_array_to_inoutptr #{@name}" ]
+    end
+
+    def postpost
       tag = subtype_tag
-      size = @length_arg.retname
+      size = array_size
       pst = [ "#{@retname} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{@callarg}, #{size}" ]
-      if tag == :utf8
-        pst << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{@callarg}, #{size}"
+      if @arginfo.ownership_transfer == :nothing
+        pst << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
       else
-        pst << "GirFFI::ArgHelper.cleanup_ptr_ptr #{@callarg}"
+        if tag == :utf8
+          pst << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{@callarg}, #{size}"
+        else
+          pst << "GirFFI::ArgHelper.cleanup_ptr_ptr #{@callarg}"
+        end
       end
       pst
     end
   end
 
-  # Implements argument processing for arguments with direction
-  # :inout that are neither arrays nor 'interfaces'.
-  class RegularInOutArgument < InOutArgument
+  # Implements argument processing for GArray arguments with direction
+  # :out.
+  class ArrayInOutArgument < InOutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_to_inoutptr #{@name}" ]
+    end
+
     def post
-      [ "#{@retname} = GirFFI::ArgHelper.outptr_to_#{type_tag} #{@callarg}",
-        "GirFFI::ArgHelper.cleanup_ptr #{@callarg}" ]
+      tag = subtype_tag
+      etype = GirFFI::Builder::TAG_TYPE_MAP[tag] || tag
+
+      pp = []
+
+      pp << "#{@retname} = GLib::Array.wrap(GirFFI::ArgHelper.outptr_to_pointer #{@callarg})"
+      pp << "#{@retname}.element_type = #{etype.inspect}"
+      pp << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+
+      pp
     end
+  end
 
+  # Implements argument processing for glist arguments with direction
+  # :inout.
+  class ListInOutArgument < InOutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_to_inoutptr(GirFFI::ArgHelper.#{subtype_tag}_array_to_#{type_tag} #{@name})" ]
+    end
+
+    def post
+      elm_t = subtype_tag.inspect
+      pp = []
+      pp << "#{@retname} = GLib::List.wrap #{elm_t}, GirFFI::ArgHelper.outptr_to_pointer(#{@callarg})"
+      pp << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+      pp
+    end
+  end
+
+  # Implements argument processing for gslist arguments with direction
+  # :inout.
+  # FIXME: Merge code with ListInOutArgument somehow.
+  class SListInOutArgument < InOutArgument
+    def pre
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_to_inoutptr(GirFFI::ArgHelper.#{subtype_tag}_array_to_#{type_tag} #{@name})" ]
+    end
+
+    def post
+      elm_t = subtype_tag.inspect
+      pp = []
+      pp << "#{@retname} = GLib::SList.wrap #{elm_t}, GirFFI::ArgHelper.outptr_to_pointer(#{@callarg})"
+      pp << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+      pp
+    end
+  end
+
+  # Implements argument processing for ghash arguments with direction
+  # :inout.
+  class HashTableInOutArgument < InOutArgument
+    def pre
+      key_t = subtype_tag(0).inspect
+      val_t = subtype_tag(1).inspect
+      [ "#{@callarg} = GirFFI::ArgHelper.pointer_to_inoutptr(GirFFI::ArgHelper.hash_to_ghash(#{key_t}, #{val_t}, #{@name}))" ]
+    end
+
+    def postpost
+      pp = []
+
+      key_t = subtype_tag(0).inspect
+      val_t = subtype_tag(1).inspect
+      pp << "#{@retname} = GLib::HashTable.wrap #{key_t}, #{val_t}, GirFFI::ArgHelper.outptr_to_pointer(#{@callarg})"
+      pp << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+      pp
+    end
+  end
+
+  # Implements argument processing for arguments with direction
+  # :inout that are neither arrays nor 'interfaces'.
+  class RegularInOutArgument < InOutArgument
     def pre
       pr = []
       if @array_arg
@@ -375,6 +631,11 @@ module GirFFI::Builder
       pr << "#{@callarg} = GirFFI::ArgHelper.#{type_tag}_to_inoutptr #{@name}"
       pr
     end
+
+    def post
+      [ "#{@retname} = GirFFI::ArgHelper.outptr_to_#{type_tag} #{@callarg}",
+        "GirFFI::ArgHelper.cleanup_ptr #{@callarg}" ]
+    end
   end
 
   # Implements argument processing for return values.
@@ -397,7 +658,7 @@ module GirFFI::Builder
                 VoidReturnValue
               when :interface
                 case type.interface.info_type
-                when :interface, :struct
+                when :interface, :struct, :union
                   InterfaceReturnValue
                 when :object
                   if arginfo.constructor?
@@ -409,9 +670,24 @@ module GirFFI::Builder
                   RegularReturnValue
                 end
               when :array
-                ArrayReturnValue
-              when :glist, :gslist
+                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
@@ -452,12 +728,12 @@ module GirFFI::Builder
     end
 
     def post
-      [ "#{@retname} = #{defining_class_name}.constructor_wrap(#{@cvar})" ]
+      [ "#{@retname} = self.constructor_wrap(#{@cvar})" ]
     end
   end
 
   # Implements argument processing for array return values.
-  class ArrayReturnValue < ReturnValue
+  class CArrayReturnValue < ReturnValue
     def post
       size = array_size
 
@@ -465,17 +741,67 @@ module GirFFI::Builder
     end
   end
 
-  # Implements argument processing for GSList return values.
+  # Implements argument processing for NULL-terminated string array return values.
+  class StrvReturnValue < ReturnValue
+    def post
+      [ "#{@retname} = GirFFI::ArgHelper.strv_to_utf8_array #{@cvar}" ]
+    end
+  end
+
+  # Implements argument processing for GList return values.
   class ListReturnValue < ReturnValue
     def post
-      [ "#{@retname} = GirFFI::ArgHelper.#{type_tag}_to_#{subtype_tag}_array #{@cvar}" ]
+      elm_t = subtype_tag.inspect
+      [ "#{@retname} = GLib::List.wrap(#{elm_t}, #{@cvar})" ]
+    end
+  end
+
+  # Implements argument processing for GSList return values.
+  class SListReturnValue < ReturnValue
+    def post
+      elm_t = subtype_tag.inspect
+      [ "#{@retname} = GLib::SList.wrap(#{elm_t}, #{@cvar})" ]
+    end
+  end
+
+  # Implements argument processing for GHashTable return values.
+  class HashTableReturnValue < ReturnValue
+    def post
+      key_t = subtype_tag(0).inspect
+      val_t = subtype_tag(1).inspect
+      [ "#{@retname} = GLib::HashTable.wrap(#{key_t}, #{val_t}, #{@cvar})" ]
+    end
+  end
+
+  # Implements argument processing for GHashTable return values.
+  class ByteArrayReturnValue < ReturnValue
+    def post
+      [ "#{@retname} = GLib::ByteArray.wrap(#{@cvar})" ]
+    end
+  end
+
+  # Implements argument processing for GHashTable return values.
+  class ArrayReturnValue < ReturnValue
+    def post
+      tag = subtype_tag
+      etype = GirFFI::Builder::TAG_TYPE_MAP[tag] || tag
+      [ "#{@retname} = GLib::Array.wrap(#{@cvar})",
+        "#{@retname}.element_type = #{etype.inspect}" ]
     end
   end
 
   # Implements argument processing for other return values.
   class RegularReturnValue < ReturnValue
     def retval
-      @cvar
+      if RUBY_VERSION < "1.9"
+        @cvar
+      else
+        if type_tag == :utf8
+          "#{@cvar}.force_encoding('utf-8')"
+        else
+          @cvar
+        end
+      end
     end
   end
 

data/lib/gir_ffi/builder/module.rb

@@ -1,5 +1,6 @@
 require 'gir_ffi/builder_helper'
 require 'gir_ffi/module_base'
+require 'gir_ffi/builder/function'
 
 module GirFFI
   # Builds a module based on information found in the introspection
@@ -38,9 +39,15 @@ module GirFFI
       Builder.build_class info
     end
 
-    private
-
     def build_module
+      unless defined? @module
+        build_dependencies
+        build_module_non_recursive
+      end
+      @module
+    end
+
+    def build_module_non_recursive
       unless defined? @module
         instantiate_module
         setup_lib_for_ffi
@@ -49,6 +56,16 @@ module GirFFI
       @module
     end
 
+    private
+
+    def build_dependencies
+      deps = gir.dependencies @namespace
+      deps.each {|dep|
+        name, version = dep.split '-'
+        Builder.build_module_non_recursive name, version
+      }
+    end
+
     def instantiate_module
       @module = get_or_define_module ::Object, @safe_namespace
     end
@@ -72,9 +89,11 @@ module GirFFI
 
       unless (class << @lib; self.include? FFI::Library; end)
         @lib.extend FFI::Library
-        libs = gir.shared_library(@namespace).split(/,/)
         @lib.ffi_lib_flags :global, :lazy
-        @lib.ffi_lib(*libs)
+        libspec = gir.shared_library(@namespace)
+        unless libspec.nil?
+          @lib.ffi_lib(*libspec.split(/,/))
+        end
       end
 
       optionally_define_constant(@lib, :CALLBACKS) { [] }
@@ -82,12 +101,8 @@ module GirFFI
 
     def function_introspection_data function
       info = gir.find_by_name @namespace, function.to_s
-
-      if info.info_type == :function
-        info
-      else
-        nil
-      end
+      return nil if info.nil?
+      info.info_type == :function ? info : nil
     end
 
     def function_definition info, libmodule

data/lib/gir_ffi/builder/type/constant.rb

@@ -0,0 +1,39 @@
+require 'gir_ffi/builder/type/base'
+module GirFFI
+  module Builder
+    module Type
+
+      # Implements the creation of a constant. Though semantically not a
+      # type, its build method is like that of the types, in that it is
+      # triggered by a missing constant in the parent namespace.  The
+      # constant will be attached to the appropriate namespace module.
+      class Constant < Base
+        TYPE_TAG_TO_UNION_MEMBER = {
+          :gint32 => :v_int32,
+          :gdouble => :v_double,
+          :utf8 => :v_string
+        }
+
+        def build_class
+          unless defined? @klass
+            instantiate_class
+          end
+          @klass
+        end
+
+        def instantiate_class
+          @klass = optionally_define_constant namespace_module, @classname do
+            tag = info.constant_type.tag
+            val = info.value[TYPE_TAG_TO_UNION_MEMBER[tag]]
+            if RUBY_VERSION >= "1.9" and tag == :utf8
+              val.force_encoding("utf-8")
+            else
+              val
+            end
+          end
+        end
+      end
+    end
+  end
+end
+