gir_ffi 0.6.7 → 0.7.0

data/lib/ffi-gobject/ruby_closure.rb

@@ -37,13 +37,12 @@ module GObject
       return closure
     end
 
-    def self.marshaller(closure, return_value, n_param_values,
-                        param_values, _invocation_hint, _marshal_data)
+    def self.marshaller(closure, return_value, param_values,
+                        _invocation_hint, _marshal_data)
       rclosure = wrap(closure.to_ptr)
+      param_values ||= []
 
-      args = n_param_values.times.map {|idx|
-        Value.wrap(param_values.to_ptr + idx * Value::Struct.size).get_value
-      }
+      args = param_values.map {|value| value.get_value }
 
       result = rclosure.invoke_block(*args)
 

data/lib/ffi-gobject/value.rb

@@ -77,6 +77,8 @@ module GObject
       TYPE_BOXED => :get_boxed,
       TYPE_CHAR => :get_char,
       TYPE_DOUBLE => :get_double,
+      TYPE_ENUM => :get_enum_enhanced,
+      TYPE_FLAGS => :get_flags,
       TYPE_FLOAT => :get_float,
       TYPE_GTYPE => :get_gtype,
       TYPE_INT64 => :get_int64,
@@ -105,11 +107,6 @@ module GObject
       send get_method
     end
 
-    # @deprecated Compatibility function. Remove in 0.7.0.
-    def ruby_value
-      get_value
-    end
-
     class << self
       # TODO: Give more generic name
       def wrap_ruby_value val
@@ -148,6 +145,11 @@ module GObject
       set_instance val
     end
 
+    def get_enum_enhanced
+      value = get_enum
+      GirFFI::Builder.build_by_gtype(current_gtype).wrap(value)
+    end
+
     def check_type_compatibility val
       if !GObject::Value.type_compatible(GObject.type_from_instance(val), current_gtype)
         raise ArgumentError, "#{val.class} is incompatible with #{current_gtype_name}"

data/lib/ffi-gobject_introspection/i_vfunc_info.rb

@@ -1,7 +1,7 @@
 module GObjectIntrospection
   # Wraps a GIVFuncInfo struct.
   # Represents a virtual function.
-  class IVFuncInfo < IBaseInfo
+  class IVFuncInfo < ICallableInfo
     def flags
       Lib.g_vfunc_info_get_flags @gobj
     end

data/lib/gir_ffi-base.rb

@@ -1,8 +1,6 @@
 # This section contains code that is needed by GObjectIntrospection, but
 # belongs in modules that can only be created fully once GObjectIntrospection
 # is fully loaded.
-require 'gir_ffi-base/gir_ffi/library'
-require 'gir_ffi-base/gir_ffi/struct'
 require 'gir_ffi-base/glib/boolean'
 require 'gir_ffi-base/glib/strv'
 require 'gir_ffi-base/gobject'

data/lib/gir_ffi-base/gobject.rb

@@ -1,5 +1,6 @@
 require 'gir_ffi-base/gobject/lib'
 
+# The part of the GObject namespace that is needed by GObjectIntrospection.
 module GObject
   def self.type_init
     Lib::g_type_init

data/lib/gir_ffi-base/gobject/lib.rb

@@ -1,6 +1,6 @@
 module GObject
   module Lib
-    extend GirFFI::Library
+    extend FFI::Library
     ffi_lib "gobject-2.0"
     attach_function :g_type_init, [], :void
   end

data/lib/gir_ffi.rb

@@ -10,8 +10,10 @@ require 'gir_ffi/type_map'
 require 'gir_ffi/info_ext'
 require 'gir_ffi/in_pointer'
 require 'gir_ffi/in_out_pointer'
+require 'gir_ffi/sized_array'
 require 'gir_ffi/zero_terminated'
 require 'gir_ffi/arg_helper'
+require 'gir_ffi/user_defined_type_info'
 require 'gir_ffi/builder'
 
 module GirFFI

data/lib/gir_ffi/arg_helper.rb

@@ -5,11 +5,6 @@ module GirFFI
   module ArgHelper
     OBJECT_STORE = {}
 
-    # @deprecated Compatibility function. Remove in 0.7.0.
-    def self.ptr_to_utf8 ptr
-      ptr.to_utf8
-    end
-
     def self.ptr_to_utf8_length ptr, len
       ptr.null? ? nil : ptr.read_string(len)
     end
@@ -29,11 +24,26 @@ module GirFFI
       case type
       when :utf8, :filename
         it.to_utf8
-      when :gint32
+      when :gint32, :gint8
         cast_pointer_to_int32 it
-      else
-        # FIXME: Only handles symbolic types.
+      when Class
+        type.wrap it
+      when :guint32
         it.address
+      when Array
+        main_type, subtype = *type
+        raise "Unexpected main type #{main_type}" if main_type != :pointer
+        case subtype
+        when Array
+          container_type, *element_type = *subtype
+          raise "Unexpected container type #{container_type}" if container_type != :ghash
+          GLib::HashTable.wrap(element_type, it)
+        else
+          raise "Unexpected subtype #{subtype}"
+        end
+
+      else
+        raise "Don't know how to cast #{type}"
       end
     end
 

data/lib/gir_ffi/builders/argument_builder.rb

@@ -1,40 +1,55 @@
 require 'gir_ffi/builders/base_argument_builder'
+require 'gir_ffi/builders/closure_to_pointer_convertor'
+require 'gir_ffi/builders/c_to_ruby_convertor'
+require 'gir_ffi/builders/ruby_to_c_convertor'
+require 'gir_ffi/builders/null_convertor'
 
 module GirFFI
   module Builders
     # Implements building pre- and post-processing statements for arguments.
     class ArgumentBuilder < BaseArgumentBuilder
-      def initialize var_gen, arginfo
-        super var_gen, arginfo.name, arginfo.argument_type, arginfo.direction
-        @arginfo = arginfo
-      end
-
-      def inarg
+      def method_argument_name
         if has_input_value? && !is_array_length_parameter?
-          @name
+          name
         end
       end
 
-      def retname
+      def post_converted_name
+        @post_converted_name ||= if has_post_conversion?
+                                   new_variable
+                                 else
+                                   callarg
+                                 end
+      end
+
+      def return_value_name
         if has_output_value?
-          @retname ||= @var_gen.new_var
+          post_converted_name unless is_array_length_parameter?
         end
       end
 
-      def pre
+      def pre_conversion
         pr = []
-        if has_input_value?
+        case direction
+        when :in
           pr << fixed_array_size_check if needs_size_check?
           pr << array_length_assignment if is_array_length_parameter?
+          pr << "#{callarg} = #{ingoing_convertor.conversion}"
+        when :inout
+          pr << fixed_array_size_check if needs_size_check?
+          pr << array_length_assignment if is_array_length_parameter?
+          pr << out_parameter_preparation
+          pr << "#{callarg}.set_value #{ingoing_convertor.conversion}"
+        when :out
+          pr << out_parameter_preparation
         end
-        pr << set_function_call_argument
         pr
       end
 
-      def post
-        if has_output_value?
+      def post_conversion
+        if has_post_conversion?
           value = output_value
-          ["#{retname} = #{value}"]
+          ["#{post_converted_name} = #{value}"]
         else
           []
         end
@@ -42,19 +57,23 @@ module GirFFI
 
       private
 
+      def has_post_conversion?
+        has_output_value? && !is_caller_allocated_object?
+      end
+
       def output_value
-        if is_caller_allocated_object?
-          callarg
+        base = "#{callarg}.to_value"
+        if @type_info.needs_conversion_for_functions?
+          CToRubyConvertor.new(@type_info, base, length_argument_name).conversion
         else
-          base = "#{callarg}.to_value"
-          if needs_outgoing_parameter_conversion?
-            outgoing_conversion base
-          else
-            base
-          end
+          base
         end
       end
 
+      def length_argument_name
+        length_arg && length_arg.post_converted_name
+      end
+
       def is_array_length_parameter?
         @array_arg
       end
@@ -65,7 +84,7 @@ module GirFFI
 
       def fixed_array_size_check
         size = type_info.array_fixed_size
-        "GirFFI::ArgHelper.check_fixed_array_size #{size}, #{@name}, \"#{@name}\""
+        "GirFFI::ArgHelper.check_fixed_array_size #{size}, #{name}, \"#{name}\""
       end
 
       def skipped?
@@ -74,33 +93,27 @@ module GirFFI
       end
 
       def has_output_value?
-        (@direction == :inout || @direction == :out) && !skipped?
+        (direction == :inout || direction == :out) && !skipped?
       end
 
       def has_input_value?
-        (@direction == :inout || @direction == :in) && !skipped?
+        (direction == :inout || direction == :in) && !skipped?
       end
 
       def array_length_assignment
         arrname = @array_arg.name
-        "#{@name} = #{arrname}.nil? ? 0 : #{arrname}.length"
-      end
-
-      def set_function_call_argument
-        value = if skipped?
-                  @direction == :in ? "0" : "nil"
-                elsif !has_input_value?
-                  if is_caller_allocated_object?
-                    if specialized_type_tag == :array
-                      "#{argument_class_name}.new #{type_info.element_type.inspect}"
-                    else
-                      "#{argument_class_name}.new"
-                    end
+        "#{name} = #{arrname}.nil? ? 0 : #{arrname}.length"
+      end
+
+      def out_parameter_preparation
+        value = if is_caller_allocated_object?
+                  if specialized_type_tag == :array
+                    "#{argument_class_name}.new #{type_info.element_type.inspect}"
                   else
-                    "GirFFI::InOutPointer.for #{type_info.tag_or_class.inspect}"
+                    "#{argument_class_name}.new"
                   end
                 else
-                  ingoing_parameter_conversion
+                  "GirFFI::InOutPointer.for #{type_info.tag_or_class.inspect}"
                 end
         "#{callarg} = #{value}"
       end
@@ -110,21 +123,15 @@ module GirFFI
           @arginfo.caller_allocates?
       end
 
-      def ingoing_parameter_conversion
-        args = conversion_arguments @name
-
-        base = case specialized_type_tag
-               when :array, :c, :callback, :ghash, :glist, :gslist, :object, :ptr_array,
-                 :struct, :strv, :utf8, :void, :zero_terminated
-                 "#{argument_class_name}.from(#{args})"
-               else
-                 args
-               end
-
-        if has_output_value?
-          "GirFFI::InOutPointer.from #{type_info.tag_or_class.inspect}, #{base}"
+      def ingoing_convertor
+        if skipped?
+          NullConvertor.new("0")
+        elsif is_closure
+          ClosureToPointerConvertor.new(name)
+        elsif @type_info.needs_ruby_to_c_conversion_for_functions?
+          RubyToCConvertor.new(@type_info, name)
         else
-          base
+          NullConvertor.new(name)
         end
       end
     end

data/lib/gir_ffi/builders/base_argument_builder.rb

@@ -1,123 +1,69 @@
 module GirFFI
-  # Abstract parent class of the argument building classes. These
-  # classes are used by FunctionBuilder to create the code that
-  # processes each argument before and after the actual function call.
-  class BaseArgumentBuilder
-    KEYWORDS = [
-      "alias", "and", "begin", "break", "case", "class", "def", "do",
-      "else", "elsif", "end", "ensure", "false", "for", "if", "in",
-      "module", "next", "nil", "not", "or", "redo", "rescue", "retry",
-      "return", "self", "super", "then", "true", "undef", "unless",
-      "until", "when", "while", "yield"
-    ]
-
-    attr_reader :name, :retname
-
-    attr_accessor :length_arg, :array_arg
-
-    attr_accessor :is_closure
-
-    def initialize var_gen, name, typeinfo, direction
-      @var_gen = var_gen
-
-      @typeinfo = typeinfo
-      @direction = direction
-      @name = safe(name)
-
-      @inarg = nil
-      @retname = nil
-
-      @length_arg = nil
-      @array_arg = nil
-
-      @is_closure = false
-    end
-
-    def type_info
-      @typeinfo
-    end
-
-    def specialized_type_tag
-      type_info.flattened_tag
-    end
-
-    # TODO: Use class rather than class name
-    def argument_class_name
-      type_info.argument_class_name
-    end
-
-    def array_size
-      if @length_arg
-        @length_arg.retname
-      else
-        type_info.array_fixed_size
+  module Builders
+    # Abstract parent class of the argument building classes. These
+    # classes are used by FunctionBuilder to create the code that
+    # processes each argument before and after the actual function call.
+    class BaseArgumentBuilder
+      KEYWORDS = [
+        "alias", "and", "begin", "break", "case", "class", "def", "do",
+        "else", "elsif", "end", "ensure", "false", "for", "if", "in",
+        "module", "next", "nil", "not", "or", "redo", "rescue", "retry",
+        "return", "self", "super", "then", "true", "undef", "unless",
+        "until", "when", "while", "yield"
+      ]
+
+      attr_reader :arginfo
+      attr_accessor :length_arg, :array_arg
+      attr_accessor :is_closure
+
+      def initialize var_gen, arginfo
+        @var_gen = var_gen
+        @arginfo = arginfo
+        @length_arg = nil
+        @array_arg = nil
+        @is_closure = false
       end
-    end
 
-    def safe name
-      if KEYWORDS.include? name
-        "#{name}_"
-      else
-        name
+      def name
+        @name ||= safe(arginfo.name)
       end
-    end
-
-    def inarg
-      @array_arg.nil? ? @inarg : nil
-    end
-
-    def retval
-      @array_arg.nil? ? retname : nil
-    end
-
-    def callarg
-      @callarg ||= @var_gen.new_var
-    end
 
-    def pre
-      []
-    end
-
-    def post
-      []
-    end
+      def direction
+        @direction ||= arginfo.direction
+      end
 
-    def cleanup
-      []
-    end
+      def type_info
+        @type_info ||= arginfo.argument_type
+      end
 
-    def new_variable
-      @var_gen.new_var
-    end
+      def specialized_type_tag
+        type_info.flattened_tag
+      end
 
-    private
+      # TODO: Use class rather than class name
+      def argument_class_name
+        type_info.argument_class_name
+      end
 
-    def needs_outgoing_parameter_conversion?
-      [ :array, :byte_array, :c, :error, :filename, :ghash, :glist,
-        :gslist, :interface, :object, :ptr_array, :struct, :strv, :union,
-        :utf8, :zero_terminated ].include?(specialized_type_tag)
-    end
+      def array_length_idx
+        type_info.array_length
+      end
 
-    def outgoing_conversion base
-      args = output_conversion_arguments base
-      case specialized_type_tag
-      when :utf8, :filename
-        "#{base}.to_utf8"
-      else
-        "#{argument_class_name}.wrap(#{args})"
+      def safe name
+        if KEYWORDS.include? name
+          "#{name}_"
+        else
+          name
+        end
       end
-    end
 
-    def output_conversion_arguments arg
-      if specialized_type_tag == :c
-        "#{type_info.subtype_tag_or_class.inspect}, #{array_size}, #{arg}"
-      else
-        conversion_arguments arg
+      def callarg
+        @callarg ||= new_variable
       end
-    end
 
-    def conversion_arguments name
-      type_info.extra_conversion_arguments.map(&:inspect).push(name).join(", ")
+      def new_variable
+        @var_gen.new_var
+      end
     end
   end
 end