gir_ffi 0.4.3 → 0.5.0

data/History.txt

@@ -1,3 +1,11 @@
+== 0.5.0 / 2013-01-19
+
+* Update ffi dependency
+* Add finalizer to release memory for IBaseInfo and descendents
+* Remove deprecated methods
+* Remove pretty-printing functionality
+* Refactor argument handling
+
 == 0.4.3 / 2012-11-02
 
 * Remove gobject-introspection version check

data/README.md

@@ -72,7 +72,7 @@ If you want to send pull requests or patches, please:
 
 ## License
 
-Copyright © 2009–2012 [Matijs van Zuijlen](http://www.matijs.net)
+Copyright © 2009–2013 [Matijs van Zuijlen](http://www.matijs.net)
 
 GirFFI is free software, distributed under the terms of the GNU Lesser
 General Public License, version 2.1 or later. See the file COPYING.LIB for

data/TODO.rdoc

@@ -1,10 +1,18 @@
 = TODO
 
-== Fix helper method names
+== Memory managment
 
-GirFFI adds some methods to all generated modules. For some of these, it
-avoids name clashes by prefixing an underscore. This is ugly and must be
-changed.
+GirFFI does not attempt to free any memory at the moment, or lower the
+reference count of any objects it gets from GObject. This task therefore involves two parts:
+
+- Free non-GObject pointers as needed (at garbage-collection time)
+- Lower reference count of GObjects (at garbage-collection time)
+
+== Persistent Ruby GObject identity
+
+GirFFI should make sure that if it gets a pointer to a GObject for which a Ruby
+object already exists, the existing object is returned. This involves the use
+of WeakRef, no doubt.
 
 == Remove code for passing generic pointers
 

data/lib/ffi-glib.rb

@@ -12,11 +12,6 @@ require 'ffi-glib/ptr_array'
 require 'ffi-glib/strv'
 
 module GLib
-  # @deprecated Compatibility function. Remove in version 0.5.0.
-  def self.main_loop_new context, is_running
-    GLib::MainLoop.new context, is_running
-  end
-
   load_class :HFunc
   load_class :HashFunc
   load_class :EqualFunc

data/lib/ffi-glib/list.rb

@@ -13,7 +13,7 @@ module GLib
 
     def self.new type
       _real_new.tap do |it|
-        struct = ffi_structure.new(FFI::Pointer.new(0))
+        struct = self::Struct.new(FFI::Pointer.new(0))
         it.instance_variable_set :@struct, struct
         it.element_type = type
       end

data/lib/ffi-glib/s_list.rb

@@ -13,7 +13,7 @@ module GLib
 
     def self.new type
       _real_new.tap do |it|
-        struct = ffi_structure.new(FFI::Pointer.new(0))
+        struct = self::Struct.new(FFI::Pointer.new(0))
         it.instance_variable_set :@struct, struct
         it.element_type = type
       end

data/lib/ffi-gobject.rb

@@ -54,7 +54,7 @@ module GObject
     ObjectClass.wrap klsptr
   end
 
-  _setup_method :signal_emitv
+  setup_method :signal_emitv
 
   def self.signal_lookup_from_instance signal, object
     signal_lookup signal, type_from_instance(object)
@@ -72,10 +72,9 @@ module GObject
 
   def self.signal_connect object, signal, data=nil, &block
     callback = Helper.signal_callback object.class, signal, &block
+    GirFFI::CallbackHelper.store_callback callback
     data_ptr = GirFFI::ArgHelper.object_to_inptr data
 
-    Lib::CALLBACKS << callback
-
     Lib.g_signal_connect_data object, signal, callback, data_ptr, nil, 0
   end
 

data/lib/ffi-gobject/closure.rb

@@ -4,9 +4,10 @@ module GObject
   # Overrides for GClosure, GObject's base class for closure objects.
   class Closure
     def set_marshal marshal
-      callback = GirFFI::CallbackHelper.wrap_in_callback_args_mapper(
-        "GObject", "ClosureMarshal", marshal)
-      Lib::CALLBACKS << callback
+      callback = GirFFI::CallbackHelper.wrap_in_callback_args_mapper("GObject",
+                                                                     "ClosureMarshal",
+                                                                     marshal)
+      GirFFI::CallbackHelper.store_callback callback
       Lib.g_closure_set_marshal self, callback
     end
   end

data/lib/ffi-gobject_introspection/i_base_info.rb

@@ -2,8 +2,18 @@ module GObjectIntrospection
   # Wraps GIBaseInfo struct, the base \type for all info types.
   # Decendant types will be implemented as needed.
   class IBaseInfo
-    def initialize ptr
+    def initialize ptr, lib=Lib
+      raise ArgumentError, "ptr must not be nil" if ptr.nil?
+      raise ArgumentError, "ptr must not be null" if ptr.null?
+
+      ObjectSpace.define_finalizer self, self.class.make_finalizer(lib, ptr)
+
       @gobj = ptr
+      @lib = lib
+    end
+
+    def self.make_finalizer lib, ptr
+      proc { lib.g_base_info_unref ptr }
     end
 
     def to_ptr
@@ -31,23 +41,10 @@ module GObjectIntrospection
       CODE
     end
 
-    private_class_method :new
-
     def name
       Lib.g_base_info_get_name @gobj
     end
 
-    def safe_name
-      name.gsub(/^./) do |char|
-        case char
-        when "_"
-          "Private___"
-        else
-          char.upcase
-        end
-      end
-    end
-
     def info_type
       Lib.g_base_info_get_type @gobj
     end

data/lib/ffi-gobject_introspection/i_constant_info.rb

@@ -1,5 +1,5 @@
 module GObjectIntrospection
-  # Wraps a GIConstantInfo struct; represents an constant.
+  # Wraps a GIConstantInfo struct; represents a constant.
   class IConstantInfo < IBaseInfo
     TYPE_TAG_TO_UNION_MEMBER = {
       :gint8 => :v_int8,

data/lib/ffi-gobject_introspection/i_function_info.rb

@@ -28,11 +28,5 @@ module GObjectIntrospection
     def throws?
       flags & 32 != 0
     end
-
-    def safe_name
-      name = self.name
-      return "_" if name.empty?
-      name
-    end
   end
 end

data/lib/ffi-gobject_introspection/lib.rb

@@ -49,6 +49,7 @@ module GObjectIntrospection
       :unresolved
     ]
 
+    attach_function :g_base_info_unref, [:pointer], :void
     attach_function :g_base_info_get_type, [:pointer], :IInfoType
     attach_function :g_base_info_get_name, [:pointer], :string
     attach_function :g_base_info_get_namespace, [:pointer], :string
@@ -104,8 +105,13 @@ module GObjectIntrospection
     # retrieve the correct values before declaring the ITypeTag enum.
     attach_function :tmp_type_tag_to_string, :g_type_tag_to_string, [:int], :string
     type_tag_map = (0..31).map { |id|
-      [tmp_type_tag_to_string(id).to_sym, id]
-    }.flatten
+      sym = tmp_type_tag_to_string(id).to_sym
+      if sym == :unknown
+        nil
+      else
+        [sym, id]
+      end
+    }.compact.flatten
     enum :ITypeTag, type_tag_map
 
     # Now, attach g_type_tag_to_string again under its own name with an

data/lib/gir_ffi.rb

@@ -4,8 +4,13 @@ require 'gir_ffi/class_base'
 require 'gir_ffi/type_map'
 
 require 'ffi-gobject_introspection'
+require 'gir_ffi/info_ext'
 
+require 'gir_ffi/in_pointer'
+require 'gir_ffi/in_out_pointer'
 require 'gir_ffi/arg_helper'
+require 'gir_ffi/callback'
+require 'gir_ffi/callback_helper'
 require 'gir_ffi/builder'
 
 module GirFFI

data/lib/gir_ffi/arg_helper.rb

@@ -59,7 +59,7 @@ module GirFFI
 
     def self.ptr_to_interface_array klass, ptr, size
       return [] if ptr.nil? or ptr.null?
-      struct_size = klass.ffi_structure.size
+      struct_size = klass::Struct.size
       size.times.map do |idx|
         klass.wrap(ptr + struct_size * idx)
       end

data/lib/gir_ffi/argument_builder.rb

@@ -0,0 +1,161 @@
+require 'gir_ffi/base_argument_builder'
+
+module GirFFI
+  # 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
+      if has_input_value?
+        @array_arg.nil? ? @name : nil
+      end
+    end
+
+    def retname
+      if has_output_value?
+        @retname ||= @var_gen.new_var
+      end
+    end
+
+    def pre
+      pr = []
+      if has_input_value?
+        pr << fixed_array_size_check if needs_size_check?
+        pr << array_length_assignment if is_array_length_parameter?
+      end
+      pr << set_function_call_argument
+      pr
+    end
+
+    def post
+      result = []
+      if has_output_value?
+        value = if is_caller_allocated_object?
+                  callarg
+                elsif needs_outgoing_parameter_conversion?
+                  case specialized_type_tag
+                  when :enum, :flags
+                    "#{argument_class_name}[#{output_conversion_arguments}]"
+                  else
+                    "#{argument_class_name}.wrap(#{output_conversion_arguments})"
+                  end
+                elsif is_fixed_length_array?
+                  "#{callarg}.to_sized_array_value #{array_size}"
+                else
+                  "#{callarg}.to_value"
+                end
+        result << "#{retname} = #{value}"
+      end
+      result
+    end
+
+    private
+
+    def is_array_length_parameter?
+      @array_arg
+    end
+
+    def needs_size_check?
+      specialized_type_tag == :c && type_info.array_fixed_size > -1
+    end
+
+    def is_fixed_length_array?
+      specialized_type_tag == :c
+    end
+
+    def fixed_array_size_check
+      size = type_info.array_fixed_size
+      "GirFFI::ArgHelper.check_fixed_array_size #{size}, #{@name}, \"#{@name}\""
+    end
+
+    def has_output_value?
+      @direction == :inout || @direction == :out
+    end
+
+    def has_input_value?
+      @direction == :inout || @direction == :in
+    end
+
+    def array_length_assignment
+      arrname = @array_arg.name
+      "#{@name} = #{arrname}.nil? ? 0 : #{arrname}.length"
+    end
+
+    def set_function_call_argument
+      value = if @direction == :out
+                if is_caller_allocated_object?
+                  "#{argument_class_name}.allocate"
+                else
+                  "GirFFI::InOutPointer.for #{type_specification}"
+                end
+              else
+                if needs_ingoing_parameter_conversion?
+                  ingoing_parameter_conversion
+                else
+                  @name
+                end
+              end
+      "#{callarg} = #{value}"
+    end
+
+    def is_caller_allocated_object?
+      [:object, :struct].include?(specialized_type_tag) &&
+        @arginfo.caller_allocates?
+    end
+
+    def needs_outgoing_parameter_conversion?
+      [ :array, :enum, :flags, :ghash, :glist, :gslist, :object, :struct,
+        :strv ].include?(specialized_type_tag)
+    end
+
+    def needs_ingoing_parameter_conversion?
+      @direction == :inout ||
+        [ :object, :struct, :callback, :utf8, :void, :glist, :gslist, :ghash,
+          :array, :c, :zero_terminated, :strv ].include?(specialized_type_tag)
+    end
+
+    def ingoing_parameter_conversion
+      case specialized_type_tag
+      when :enum, :flags
+        base = "#{argument_class_name}[#{parameter_conversion_arguments}]"
+        "GirFFI::InOutPointer.from #{specialized_type_tag.inspect}, #{base}"
+      when :object, :struct, :void, :glist, :gslist, :ghash, :array,
+        :zero_terminated, :strv, :callback
+        base = "#{argument_class_name}.from(#{parameter_conversion_arguments})"
+        if has_output_value?
+          if specialized_type_tag == :strv
+            "GirFFI::InOutPointer.from #{type_specification}, #{base}"
+          else
+            "GirFFI::InOutPointer.from :pointer, #{base}"
+          end
+        else
+          base
+        end
+      when :c, :utf8
+        if has_output_value?
+          "GirFFI::InOutPointer.from #{parameter_conversion_arguments}"
+        else
+          "GirFFI::InPointer.from(#{parameter_conversion_arguments})"
+        end
+      else
+        base = "#{parameter_conversion_arguments}"
+        "GirFFI::InOutPointer.from #{specialized_type_tag.inspect}, #{base}"
+      end
+    end
+
+    def output_conversion_arguments
+      conversion_arguments "#{callarg}.to_value"
+    end
+
+    def parameter_conversion_arguments
+      conversion_arguments @name
+    end
+
+    def self_t
+      type_tag.inspect
+    end
+  end
+end

data/lib/gir_ffi/base_argument_builder.rb

@@ -0,0 +1,146 @@
+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
+
+    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
+    end
+
+    def type_info
+      @typeinfo
+    end
+
+    def type_tag
+      type_info.tag
+    end
+
+    def specialized_type_tag
+      type_info.flattened_tag
+    end
+
+    def type_specification
+      type_info.type_specification
+    end
+
+    TAG_TO_WRAPPER_CLASS_MAP = {
+      :glist => 'GLib::List',
+      :gslist => 'GLib::SList',
+      :ghash => 'GLib::HashTable',
+      :array => 'GLib::Array',
+      :utf8 => 'GirFFI::InPointer',
+      :void => 'GirFFI::InPointer'
+    }
+
+    def argument_class_name
+      case (tag = type_info.flattened_tag)
+      when :struct, :union, :object, :interface, :enum, :flags
+        type_info.interface_type_name
+      when :callback
+        'GirFFI::Callback'
+      when :byte_array
+        'GLib::ByteArray'
+      when :array
+        'GLib::Array'
+      when :ptr_array
+        'GLib::PtrArray'
+      when :strv
+        'GLib::Strv'
+      when :c, :zero_terminated
+        'GirFFI::InPointer'
+      else
+        TAG_TO_WRAPPER_CLASS_MAP[tag]
+      end
+    end
+
+    def subtype_tag_or_class_name
+      type_info.subtype_tag_or_class_name
+    end
+
+    def elm_t
+      type_info.element_type.inspect
+    end
+
+    def array_size
+      if @length_arg
+        @length_arg.retname
+      else
+        type_info.array_fixed_size
+      end
+    end
+
+    def safe name
+      if KEYWORDS.include? name
+        "#{name}_"
+      else
+        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 cleanup
+      []
+    end
+
+    private
+
+    def conversion_arguments name
+      case specialized_type_tag
+      when :utf8, :void
+        "#{self_t}, #{name}"
+      when :glist, :gslist, :ghash, :array
+        "#{elm_t}, #{name}"
+      when :c, :zero_terminated
+        "#{type_specification}, #{name}"
+      when :callback
+        iface = type_info.interface
+        "\"#{iface.namespace}\", \"#{iface.name}\", #{name}"
+      else
+        "#{name}"
+      end
+    end
+  end
+end
+
+