gir_ffi 0.0.5 → 0.0.6

data/History.txt

@@ -1,3 +1,11 @@
+== 0.0.6 / 2011-03-01
+
+* Cast returned GObjects to their actual type.
+* Properly cast callback arguments.
+* Handle the case where functions formally return interfaces.
+* Make sure Gtk::Window has the correct number of references after creation.
+* Refactoring and some small fixes.
+
 == 0.0.5 / 2010-12-30
 
 * Don't create instance methods out of functions and vice versa.

data/lib/gir_ffi/arg_helper.rb

@@ -41,7 +41,7 @@ module GirFFI
       AllocationHelper.safe_malloc(len + 1).write_string(str).put_char(len, 0)
     end
 
-    def self.GType_array_to_inptr ary
+    def self.gtype_array_to_inptr ary
       case FFI.type_size(:size_t)
       when 4
 	int32_array_to_inptr ary
@@ -64,8 +64,6 @@ module GirFFI
 
     # Takes an outptr to a pointer array, and frees all pointers.
     def self.cleanup_ptr_array_ptr ptr, size
-      return if ptr.nil?
-
       block = ptr.read_pointer
       LibC.free ptr
 
@@ -74,9 +72,7 @@ module GirFFI
       ptrs = block.read_array_of_pointer(size)
       LibC.free block
 
-      ptrs.map do |p|
-	LibC.free p unless p.null?
-      end
+      ptrs.each { |ptr| LibC.free ptr }
     end
 
     def self.int_to_inoutptr val
@@ -148,22 +144,16 @@ module GirFFI
 
     # Converts an outptr to a string.
     def self.outptr_to_utf8 ptr
-      return nil if ptr.nil?
-      sptr = ptr.read_pointer
-
-      sptr.null? ? nil : sptr.read_string
+      ptr_to_utf8 ptr.read_pointer
     end
 
     # Converts an outptr to a string array.
     def self.outptr_to_utf8_array ptr, size
-      return nil if ptr.nil?
       block = ptr.read_pointer
       return nil if block.null?
       ptrs = block.read_array_of_pointer(size)
 
-      ptrs.map do |p|
-	p.null? ? nil : p.read_string
-      end
+      ptrs.map { |ptr| ptr_to_utf8 ptr }
     end
 
     # Converts an outptr to a double.
@@ -173,7 +163,6 @@ module GirFFI
 
     # Converts an outptr to an array of int.
     def self.outptr_to_int_array ptr, size
-      return nil if ptr.null?
       block = ptr.read_pointer
       return nil if block.null?
       ptr_to_int_array block, size
@@ -183,25 +172,50 @@ module GirFFI
       ptr.read_array_of_int(size)
     end
 
-    def self.mapped_callback_args prc=nil, &block
+    def self.ptr_to_utf8 ptr
+      ptr.null? ? nil : ptr.read_string
+    end
+
+    def self.wrap_in_callback_args_mapper namespace, name, prc
       return prc if FFI::Function === prc
-      if prc.nil?
-	return nil if block.nil?
-	prc = block
-      end
+      return nil if prc.nil?
+      info = gir.find_by_name namespace, name
       return Proc.new do |*args|
-	mapped = args.map {|arg|
-	  if FFI::Pointer === arg
-	    begin
-	      ObjectSpace._id2ref arg.address
-	    rescue RangeError
-	      arg
-	    end
-	  else
+	prc.call(*map_callback_args(args, info))
+      end
+    end
+
+    def self.map_callback_args args, info
+      args.zip(info.args).map { |arg, inf|
+	map_single_callback_arg arg, inf }
+    end
+
+    def self.map_single_callback_arg arg, info
+      type = info.type
+      tag = type.tag
+
+      case tag
+      when :interface
+	iface = type.interface
+	if iface.type == :object
+	  object_pointer_to_object arg
+	else
+	  arg
+	end
+      when :utf8
+	ptr_to_utf8 arg
+      when :void
+	if arg.null?
+	  nil
+	else
+	  begin
+	    ObjectSpace._id2ref arg.address
+	  rescue RangeError
 	    arg
 	  end
-	}
-	prc.call(*mapped)
+	end
+      else
+	arg
       end
     end
 
@@ -210,12 +224,6 @@ module GirFFI
       raise GError.new(errp)[:message] unless errp.null?
     end
 
-    def self.sink_if_floating gobject
-      if GirFFI::GObject.object_is_floating(gobject)
-	GirFFI::GObject.object_ref_sink(gobject)
-      end
-    end
-
     def self.check_fixed_array_size size, arr, name
       unless arr.size == size
 	raise ArgumentError, "#{name} should have size #{size}"
@@ -228,11 +236,21 @@ module GirFFI
 
     # FIXME: Quasi-circular dependency on generated module
     def self.object_pointer_to_object optr
+      return nil if optr.null?
       tp = ::GObject.type_from_instance_pointer optr
-      gir = GirFFI::IRepository.default
       info = gir.find_by_gtype tp
+
+      if info.nil?
+	tpname = ::GObject.type_name tp
+	raise RuntimeError, "Unable to find info for type '#{tpname}' (#{tp})"
+      end
+
       klass = GirFFI::Builder.build_class info.namespace, info.name
       klass.wrap optr
     end
+
+    def self.gir
+      gir = GirFFI::IRepository.default
+    end
   end
 end

data/lib/gir_ffi/argument_builder.rb

@@ -0,0 +1,382 @@
+module GirFFI
+  # Abstract parent class of the argument building classes. These classes
+  # are used by FunctionDefinitionBuilder to create the code that processes
+  # each argument before and after the actual function call.
+  class ArgumentBuilder
+    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, :callarg, :pre, :post, :postpost
+
+    attr_accessor :length_arg, :inarg, :retval
+
+    def initialize function_builder, arginfo=nil, libmodule=nil
+      @arginfo = arginfo
+      @inarg = nil
+      @callarg = nil
+      @retval = nil
+      @retname = nil
+      @name = nil
+      @pre = []
+      @post = []
+      @postpost = []
+      @function_builder = function_builder
+      @libmodule = libmodule
+    end
+
+    def self.build function_builder, arginfo, libmodule
+      klass = case arginfo.direction
+              when :inout
+                InOutArgumentBuilder
+              when :in
+                InArgumentBuilder
+              when :out
+                OutArgumentBuilder
+              else
+                raise ArgumentError
+              end
+      klass.new function_builder, arginfo, libmodule
+    end
+
+    def type
+      @arginfo.type
+    end
+
+    private
+
+    def safe name
+      if KEYWORDS.include? name
+	"#{name}_"
+      else
+	name
+      end
+    end
+  end
+
+  # Implements argument processing for arguments with direction :in
+  class InArgumentBuilder < ArgumentBuilder
+    def prepare
+      @name = safe(@arginfo.name)
+      @callarg = @function_builder.new_var
+      @inarg = @name
+    end
+
+    def process
+      case @arginfo.type.tag
+      when :interface
+	process_interface_in_arg
+      when :void
+	process_void_in_arg
+      when :array
+	process_array_in_arg
+      when :utf8
+	process_utf8_in_arg
+      else
+	process_other_in_arg
+      end
+    end
+
+    private
+
+
+    def process_interface_in_arg
+      arg = @arginfo
+      type = arg.type
+
+      iface = type.interface
+      if iface.type == :callback
+	@pre << "#{@callarg} = GirFFI::ArgHelper.wrap_in_callback_args_mapper \"#{iface.namespace}\", \"#{iface.name}\", #{@inarg}"
+	@pre << "::#{@libmodule}::CALLBACKS << #{@callarg}"
+      else
+	@pre << "#{@callarg} = #{@inarg}"
+      end
+    end
+
+    def process_void_in_arg
+      @pre << "#{@callarg} = GirFFI::ArgHelper.object_to_inptr #{@inarg}"
+    end
+
+    def process_utf8_in_arg
+      @pre << "#{@callarg} = GirFFI::ArgHelper.utf8_to_inptr #{@name}"
+      # TODO:
+      #@post << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+    end
+
+    def process_array_in_arg
+      arg = @arginfo
+      type = arg.type
+
+      if type.array_fixed_size > 0
+	@pre << "GirFFI::ArgHelper.check_fixed_array_size #{type.array_fixed_size}, #{@inarg}, \"#{@inarg}\""
+      elsif type.array_length > -1
+	idx = type.array_length
+	lenvar = @length_arg.inarg
+	@length_arg.inarg = nil
+	@length_arg.pre.unshift "#{lenvar} = #{@inarg}.nil? ? 0 : #{@inarg}.length"
+      end
+
+      tag = arg.type.param_type(0).tag.to_s.downcase
+      @pre << "#{@callarg} = GirFFI::ArgHelper.#{tag}_array_to_inptr #{@inarg}"
+      unless arg.ownership_transfer == :everything
+	if tag == :utf8
+	  @post << "GirFFI::ArgHelper.cleanup_ptr_ptr #{@callarg}"
+	else
+	  @post << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+	end
+      end
+    end
+
+    def process_other_in_arg
+      @pre << "#{@callarg} = #{@name}"
+    end
+  end
+
+  # Implements argument processing for arguments with direction :out
+  class OutArgumentBuilder < ArgumentBuilder
+    def prepare
+      @name = safe(@arginfo.name)
+      @callarg = @function_builder.new_var
+      @retname = @retval = @function_builder.new_var
+    end
+
+    def process
+      case @arginfo.type.tag
+      when :interface
+	process_interface_out_arg
+      when :array
+	process_array_out_arg
+      else
+	process_other_out_arg
+      end
+    end
+
+    private
+
+    def process_interface_out_arg
+      iface = @arginfo.type.interface
+      klass = "#{iface.namespace}::#{iface.name}"
+
+      if @arginfo.caller_allocates?
+	@pre << "#{@callarg} = #{klass}.allocate"
+	@post << "#{@retval} = #{@callarg}"
+      else
+	@pre << "#{@callarg} = GirFFI::ArgHelper.pointer_outptr"
+	@post << "#{@retval} = #{klass}.wrap GirFFI::ArgHelper.outptr_to_pointer(#{@callarg})"
+      end
+    end
+
+    def process_array_out_arg
+      @pre << "#{@callarg} = GirFFI::ArgHelper.pointer_outptr"
+
+      arg = @arginfo
+      type = arg.type
+      tag = type.param_type(0).tag
+      size = type.array_fixed_size
+      idx = type.array_length
+
+      if size <= 0
+	if idx > -1
+	  size = @length_arg.retval
+	  @length_arg.retval = nil
+	else
+	  raise NotImplementedError
+	end
+      end
+
+      @postpost << "#{@retval} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{@callarg}, #{size}"
+
+      if arg.ownership_transfer == :everything
+	if tag == :utf8
+	  @postpost << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{@callarg}, #{rv}"
+	else
+	  @postpost << "GirFFI::ArgHelper.cleanup_ptr_ptr #{@callarg}"
+	end
+      end
+    end
+
+    def process_other_out_arg
+      tag = @arginfo.type.tag
+      @pre << "#{@callarg} = GirFFI::ArgHelper.#{tag}_outptr"
+      @post << "#{@retname} = GirFFI::ArgHelper.outptr_to_#{tag} #{@callarg}"
+      if @arginfo.ownership_transfer == :everything
+	@post << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+      end
+    end
+
+  end
+
+  # Implements argument processing for arguments with direction :inout
+  class InOutArgumentBuilder < ArgumentBuilder
+    def prepare
+      @name = safe(@arginfo.name)
+      @callarg = @function_builder.new_var
+      @inarg = @name
+      @retname = @retval = @function_builder.new_var
+    end
+
+    def process
+      raise NotImplementedError unless @arginfo.ownership_transfer == :everything
+
+      case @arginfo.type.tag
+      when :interface
+	process_interface_inout_arg
+      when :array
+	process_array_inout_arg
+      else
+	process_other_inout_arg
+      end
+    end
+
+    private
+
+    def process_interface_inout_arg
+      raise NotImplementedError
+    end
+
+    def process_array_inout_arg
+      arg = @arginfo
+      tag = arg.type.param_type(0).tag
+      @pre << "#{@callarg} = GirFFI::ArgHelper.#{tag}_array_to_inoutptr #{@inarg}"
+      if arg.type.array_length > -1
+	idx = arg.type.array_length
+	rv = @length_arg.retval
+	@length_arg.retval = nil
+	lname = @length_arg.inarg
+	@length_arg.inarg = nil
+	@length_arg.pre.unshift "#{lname} = #{@inarg}.length"
+	@post << "#{@retval} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{@callarg}, #{rv}"
+	if tag == :utf8
+	  @post << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{@callarg}, #{rv}"
+	else
+	  @post << "GirFFI::ArgHelper.cleanup_ptr_ptr #{@callarg}"
+	end
+      else
+	raise NotImplementedError
+      end
+    end
+
+    def process_other_inout_arg
+      tag = @arginfo.type.tag
+      @pre << "#{@callarg} = GirFFI::ArgHelper.#{tag}_to_inoutptr #{@inarg}"
+      @post << "#{@retval} = GirFFI::ArgHelper.outptr_to_#{tag} #{@callarg}"
+      @post << "GirFFI::ArgHelper.cleanup_ptr #{@callarg}"
+    end
+  end
+
+  # Implements argument processing for return values.
+  class ReturnValueBuilder < ArgumentBuilder
+    attr_reader :cvar
+
+    def prepare
+      return if tag == :void
+      @cvar = @function_builder.new_var
+      @retval = @function_builder.new_var
+    end
+
+    def process
+      return if tag == :void
+
+      type = @arginfo.return_type
+
+      case tag
+      when :interface
+	process_interface_return_value type, @cvar
+      when :array
+	process_array_return_value type, @cvar
+      else
+	process_other_return_value
+      end
+    end
+
+    def type
+      @arginfo.return_type
+    end
+
+    private
+
+    def process_interface_return_value type, cvar
+      interface = type.interface
+      namespace = interface.namespace
+      name = interface.name
+
+      case interface.type
+      when :interface
+	GirFFI::Builder.build_class namespace, name
+	@post << "#{@retval} = ::#{namespace}::#{name}.wrap(#{cvar})"
+      when :object
+	if @arginfo.constructor?
+	  GirFFI::Builder.build_class namespace, name
+	  @post << "#{@retval} = ::#{namespace}::#{name}.wrap(#{cvar})"
+          if is_subclass_of_initially_unowned interface
+            @post << "GirFFI::GObject.object_ref_sink(#{@retval})"
+          end
+	else
+	  @post << "#{@retval} = GirFFI::ArgHelper.object_pointer_to_object(#{cvar})"
+	end
+      when :struct
+	GirFFI::Builder.build_class namespace, name
+	@post << "#{@retval} = ::#{namespace}::#{name}.wrap(#{cvar})"
+      else
+	@post << "#{@retval} = #{cvar}"
+      end
+    end
+
+    def process_array_return_value type, cvar
+      tag = type.param_type(0).tag
+      size = type.array_fixed_size
+      idx = type.array_length
+
+      if size > 0
+	@post << "#{@retval} = GirFFI::ArgHelper.ptr_to_#{tag}_array #{cvar}, #{size}"
+      elsif idx > -1
+	lendata = @length_arg #@data[idx]
+	rv = lendata.retval
+	lendata.retval = nil
+	@post << "#{@retval} = GirFFI::ArgHelper.ptr_to_#{tag}_array #{cvar}, #{rv}"
+      end
+    end
+
+    def process_other_return_value
+      @retval = @cvar
+    end
+
+    def tag
+      type.tag
+    end
+
+    def is_subclass_of_initially_unowned interface
+      if interface.namespace == "GObject" and interface.name == "InitiallyUnowned"
+        true
+      elsif interface.parent
+        is_subclass_of_initially_unowned interface.parent
+      else
+        false
+      end
+    end
+  end
+
+  # Implements argument processing for error handling arguments. These
+  # arguments are not part of the introspected signature, but their
+  # presence is indicated by the 'throws' attribute of the function.
+  class ErrorHandlerBuilder < ArgumentBuilder
+    def prepare
+      @callarg = @function_builder.new_var
+    end
+
+    def process
+      @pre << "#{@callarg} = FFI::MemoryPointer.new(:pointer).write_pointer nil"
+      @post << "GirFFI::ArgHelper.check_error(#{@callarg})"
+    end
+  end
+
+  # Argument builder that does nothing. Implements Null Object pattern.
+  class NullArgumentBuilder < ArgumentBuilder
+    def prepare; end
+    def process; end
+  end
+end

data/lib/gir_ffi/builder.rb

@@ -30,8 +30,8 @@ module GirFFI
     # All methods below will be made private at the end.
 
     def self.ffi_function_argument_types info
-      types = info.args.map do |a|
-	tp = iarginfo_to_ffitype a
+      types = info.args.map do |arg|
+	tp = iarginfo_to_ffitype arg
 	tp == :string ? :pointer : tp
       end
       if info.type == :function
@@ -93,8 +93,8 @@ module GirFFI
     end
 
     # Set up method access.
-    (self.public_methods - Module.public_methods).each do |m|
-      private_class_method m.to_sym
+    (self.public_methods - Module.public_methods).each do |method|
+      private_class_method method.to_sym
     end
     public_class_method :build_module, :build_class
     public_class_method :itypeinfo_to_ffitype

data/lib/gir_ffi/class_builder.rb

@@ -37,15 +37,10 @@ module GirFFI
     end
 
     def find_signal signal_name
-      info.signals.each do |s|
-	return s if s.name == signal_name
-      end
-      if info.type == :object
-	info.interfaces.each do |i|
-	  i.signals.each do |s|
-	    return s if s.name == signal_name
-	  end
-	end
+      signal_definers.each do |inf|
+        inf.signals.each do |sig|
+          return sig if sig.name == signal_name
+        end
       end
       if info.parent
 	return superclass.gir_ffi_builder.find_signal signal_name
@@ -57,14 +52,14 @@ module GirFFI
     def build_class
       unless defined? @klass
 	case info.type
-	  when :object, :struct
-	    instantiate_struct_class
-	  when :union
-	    instantiate_union_class
-	  when :enum, :flags
-	    instantiate_enum_class
-	  else
-	    raise NotImplementedError, "Cannot build classes of type #{info.type}"
+	when :object, :struct, :interface
+	  instantiate_struct_class
+	when :union
+	  instantiate_union_class
+	when :enum, :flags
+	  instantiate_enum_class
+	else
+	  raise NotImplementedError, "Cannot build classes of type #{info.type}"
 	end
       end
       @klass
@@ -118,7 +113,7 @@ module GirFFI
 
     def instantiate_enum_class
       @klass = optionally_define_constant namespace_module, @classname do
-	vals = info.values.map {|v| [v.name.to_sym, v.value]}.flatten
+	vals = info.values.map {|vinfo| [vinfo.name.to_sym, vinfo.value]}.flatten
 	lib.enum(@classname.to_sym, vals)
       end
     end
@@ -139,7 +134,11 @@ module GirFFI
     end
 
     def layout_specification
-      fields = info.fields
+      fields = if info.type == :interface
+		 []
+	       else
+		 info.fields
+	       end
 
       if fields.empty?
 	if parent
@@ -149,10 +148,10 @@ module GirFFI
 	end
       end
 
-      fields.map do |f|
-	[ f.name.to_sym,
-	  itypeinfo_to_ffitype_for_struct(f.type),
-	  f.offset ]
+      fields.map do |finfo|
+	[ finfo.name.to_sym,
+	  itypeinfo_to_ffitype_for_struct(finfo.type),
+	  finfo.offset ]
       end.flatten
     end
 
@@ -168,14 +167,14 @@ module GirFFI
     end
 
     def stub_methods
-      info.methods.each do |m|
-	@klass.class_eval method_stub(m.method? ? m.name : "self.#{m.name}", m.name)
+      info.methods.each do |minfo|
+	@klass.class_eval method_stub(minfo.name, minfo.method?)
       end
     end
 
-    def method_stub name, symbol
+    def method_stub symbol, is_instance_method
       "
-	def #{name} *args, &block
+	def #{is_instance_method ? '' : 'self.'}#{symbol} *args, &block
 	  setup_and_call :#{symbol}, *args, &block
 	end
       "
@@ -193,13 +192,13 @@ module GirFFI
     end
 
     def setup_vfunc_invokers
-      info.vfuncs.each do |v|
-	invoker = v.invoker
+      info.vfuncs.each do |vfinfo|
+	invoker = vfinfo.invoker
 	next if invoker.nil?
-	next if invoker.name == v.name
+	next if invoker.name == vfinfo.name
 
 	@klass.class_eval "
-	  def #{v.name} *args, &block
+	  def #{vfinfo.name} *args, &block
 	    #{invoker.name}(*args, &block)
 	  end
 	"
@@ -228,8 +227,8 @@ module GirFFI
     end
 
     def instance_method_introspection_data method
-      m = method_introspection_data method
-      return !m.nil? && m.method? ? m : nil
+      data = method_introspection_data method
+      return !data.nil? && data.method? ? data : nil
     end
 
     def function_definition go
@@ -257,5 +256,9 @@ module GirFFI
 	Class.new parent
       }
     end
+
+    def signal_definers
+      [info] + (info.type == :object ? info.interfaces : [])
+    end
   end
 end