gir_ffi 0.0.4 → 0.0.5

data/lib/gir_ffi/function_definition_builder.rb

@@ -2,6 +2,23 @@ module GirFFI
   # Implements the creation of a Ruby function definition out of a GIR
   # IFunctionInfo.
   class FunctionDefinitionBuilder
+    ArgData = Struct.new(:arginfo, :inarg, :callarg, :retval, :pre, :post, :postpost,
+			 :name, :retname)
+    class ArgData
+      def initialize arginfo=nil
+	super
+	self.arginfo = arginfo
+	self.inarg = nil
+	self.callarg = nil
+	self.retval = nil
+	self.retname = nil
+	self.name = nil
+	self.pre = []
+	self.post = []
+	self.postpost = []
+      end
+    end
+
     KEYWORDS =  [
       "alias", "and", "begin", "break", "case", "class", "def", "do",
       "else", "elsif", "end", "ensure", "false", "for", "if", "in",
@@ -17,8 +34,10 @@ module GirFFI
 
     def generate
       setup_accumulators
+      @data = @info.args.map {|a| ArgData.new a}
+      @data.each {|data| prepare_arg data }
+      @data.each {|data| process_arg data }
       process_return_value
-      @info.args.each {|a| process_arg a}
       adjust_accumulators
       return filled_out_template
     end
@@ -33,126 +52,236 @@ module GirFFI
       @pre = []
       @post = []
 
+      @data = []
+
       @capture = ""
 
       @varno = 0
     end
 
-    def process_arg arg
+    def prepare_arg data
+      arg = data.arginfo
+      data.name = safe arg.name
+      data.callarg = new_var
+
+      case arg.direction
+      when :inout
+	data.inarg = data.name
+	data.retname = data.retval = new_var
+      when :in
+	data.inarg = data.name
+      when :out
+	data.retname = data.retval = new_var
+      else
+	raise ArgumentError
+      end
+    end
+
+    def process_arg data
+      arg = data.arginfo
       case arg.direction
       when :inout
-	process_inout_arg arg
+	process_inout_arg data
       when :in
-	process_in_arg arg
+	process_in_arg data
       when :out
-	process_out_arg arg
+	process_out_arg data
       else
 	raise ArgumentError
       end
     end
 
-    def process_inout_arg arg
+    def process_inout_arg data
+      arg = data.arginfo
+
       raise NotImplementedError unless arg.ownership_transfer == :everything
 
-      name = safe arg.name
-      prevar = new_var
-      postvar = new_var
+      tag = arg.type.tag
 
-      @inargs << name
-      case arg.type.tag
-      when :int, :int32
-	@pre << "#{prevar} = GirFFI::ArgHelper.int_to_inoutptr #{name}"
-	@post << "#{postvar} = GirFFI::ArgHelper.outptr_to_int #{prevar}"
+      case tag
+      when :interface
+	raise NotImplementedError
       when :array
-	case arg.type.param_type(0).tag
-	when :utf8
-	  @pre << "#{prevar} = GirFFI::ArgHelper.string_array_to_inoutptr #{name}"
-	  @post << "#{postvar} = GirFFI::ArgHelper.outptr_to_string_array #{prevar}, #{name}.nil? ? 0 : #{name}.size"
+	tag = arg.type.param_type(0).tag
+	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_array_to_inoutptr #{data.inarg}"
+	if arg.type.array_length > -1
+	  idx = arg.type.array_length
+	  lendata = @data[idx]
+	  rv = lendata.retval
+	  lendata.retval = nil
+	  lname = lendata.inarg
+	  lendata.inarg = nil
+	  lendata.pre.unshift "#{lname} = #{data.inarg}.length"
+	  data.post << "#{data.retval} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{data.callarg}, #{rv}"
+	  if tag == :utf8
+	    data.post << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{data.callarg}, #{rv}"
+	  else
+	    data.post << "GirFFI::ArgHelper.cleanup_ptr_ptr #{data.callarg}"
+	  end
 	else
 	  raise NotImplementedError
 	end
       else
-	raise NotImplementedError
+	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_to_inoutptr #{data.inarg}"
+	data.post << "#{data.retval} = GirFFI::ArgHelper.outptr_to_#{tag} #{data.callarg}"
+	data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
       end
-      @callargs << prevar
-      @retvals << postvar
+
+      data
     end
 
-    def process_out_arg arg
-      prevar = new_var
-      postvar = new_var
-
-      case arg.type.tag
-      when :int, :int32
-	@pre << "#{prevar} = GirFFI::ArgHelper.int_to_inoutptr 0"
-	@post << "#{postvar} = GirFFI::ArgHelper.outptr_to_int #{prevar}"
-      when :double
-	@pre << "#{prevar} = GirFFI::ArgHelper.double_to_inoutptr 0"
-	@post << "#{postvar} = GirFFI::ArgHelper.outptr_to_double #{prevar}"
+    def process_out_arg data
+      arg = data.arginfo
+      type = arg.type
+      tag = type.tag
+
+      case tag
       when :interface
 	iface = arg.type.interface
-	if iface.type == :struct
-	  @pre << "#{prevar} = #{iface.namespace}::#{iface.name}.new"
-	  @post << "#{postvar} = #{prevar}"
+	if arg.caller_allocates?
+	  data.pre << "#{data.callarg} = #{iface.namespace}::#{iface.name}.allocate"
+	  data.post << "#{data.retval} = #{data.callarg}"
 	else
-	  raise NotImplementedError,
-	    "Don't know what to do with interface type #{iface.type}"
+	  data.pre << "#{data.callarg} = GirFFI::ArgHelper.pointer_outptr"
+	  tmpvar = new_var
+	  data.post << "#{tmpvar} = GirFFI::ArgHelper.outptr_to_pointer #{data.callarg}"
+	  data.post << "#{data.retval} = #{iface.namespace}::#{iface.name}.wrap #{tmpvar}"
+	end
+      when :array
+	data.pre << "#{data.callarg} = GirFFI::ArgHelper.pointer_outptr"
+
+	tag = arg.type.param_type(0).tag
+	size = type.array_fixed_size
+	idx = type.array_length
+
+	if size <= 0
+	  if idx > -1
+	    size = @data[idx].retval
+	    @data[idx].retval = nil
+	  else
+	    raise NotImplementedError
+	  end
+	end
+	data.postpost << "#{data.retval} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{data.callarg}, #{size}"
+	if arg.ownership_transfer == :everything
+	  if tag == :utf8
+	    data.postpost << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{data.callarg}, #{rv}"
+	  else
+	    data.postpost << "GirFFI::ArgHelper.cleanup_ptr_ptr #{data.callarg}"
+	  end
 	end
       else
-	raise NotImplementedError,
-	  "Don't know what to do with argument type #{arg.type.tag}"
+	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_outptr"
+	data.post << "#{data.retname} = GirFFI::ArgHelper.outptr_to_#{tag} #{data.callarg}"
+	if arg.ownership_transfer == :everything
+	  data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
+	end
       end
-      @callargs << prevar
-      @retvals << postvar
+
+      data
     end
 
-    def process_in_arg arg
-      name = safe arg.name
+    def process_in_arg data
+      arg = data.arginfo
+
       type = arg.type
       tag = type.tag
 
-      @inargs << name
-
-      if tag == :interface and type.interface.type == :callback
-	# TODO: Use arg.scope to decide if this is needed.
-	procvar = new_var
-	@pre << "#{procvar} = GirFFI::ArgHelper.mapped_callback_args #{name}"
-	@pre << "::#{@libmodule}::CALLBACKS << #{procvar}"
-	@callargs << procvar
-      elsif tag == :void
+      case tag
+      when :interface
+	if type.interface.type == :callback
+	  data.pre << "#{data.callarg} = GirFFI::ArgHelper.mapped_callback_args #{data.inarg}"
+	  data.pre << "::#{@libmodule}::CALLBACKS << #{data.callarg}"
+	else
+	  data.pre << "#{data.callarg} = #{data.inarg}"
+	end
+      when :void
 	raise NotImplementedError unless arg.type.pointer?
-	prevar = new_var
-	@pre << "#{prevar} = GirFFI::ArgHelper.object_to_inptr #{name}"
-	@callargs << prevar
+	data.pre << "#{data.callarg} = GirFFI::ArgHelper.object_to_inptr #{data.inarg}"
+      when :array
+	if type.array_fixed_size > 0
+	  data.pre << "GirFFI::ArgHelper.check_fixed_array_size #{type.array_fixed_size}, #{data.inarg}, \"#{data.inarg}\""
+	elsif type.array_length > -1
+	  idx = type.array_length
+	  lenvar = @data[idx].inarg
+	  @data[idx].inarg = nil
+	  @data[idx].pre.unshift "#{lenvar} = #{data.inarg}.nil? ? 0 : #{data.inarg}.length"
+	end
+
+	tag = arg.type.param_type(0).tag
+	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_array_to_inptr #{data.inarg}"
+	unless arg.ownership_transfer == :everything
+	  if tag == :utf8
+	    data.post << "GirFFI::ArgHelper.cleanup_ptr_ptr #{data.callarg}"
+	  else
+	    data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
+	  end
+	end
+      when :utf8
+	data.pre << "#{data.callarg} = GirFFI::ArgHelper.utf8_to_inptr #{data.name}"
+	# TODO:
+	#data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
       else
-	@callargs << name
+	data.pre << "#{data.callarg} = #{data.name}"
       end
+
+      data
     end
 
     def process_return_value
+      @rvdata = ArgData.new
       type = @info.return_type
       tag = type.tag
       return if tag == :void
       cvar = new_var
       @capture = "#{cvar} = "
 
-      if tag == :interface
+      case tag
+      when :interface
 	interface = type.interface
 	namespace = interface.namespace
 	name = interface.name
 	GirFFI::Builder.build_class namespace, name
 	retval = new_var
-	@post << "#{retval} = ::#{namespace}::#{name}._real_new(#{cvar})"
+	@rvdata.post << "#{retval} = ::#{namespace}::#{name}.wrap(#{cvar})"
 	if interface.type == :object
-	  @post << "GirFFI::ArgHelper.sink_if_floating(#{retval})"
+	  @rvdata.post << "GirFFI::ArgHelper.sink_if_floating(#{retval})"
 	end
-	@retvals << retval
+	@rvdata.retval = retval
+      when :array
+	tag = type.param_type(0).tag
+	size = type.array_fixed_size
+	idx = type.array_length
+
+	retval = new_var
+	if size > 0
+	  @rvdata.post << "#{retval} = GirFFI::ArgHelper.ptr_to_#{tag}_array #{cvar}, #{size}"
+	elsif idx > -1
+	  lendata = @data[idx]
+	  rv = lendata.retval
+	  lendata.retval = nil
+	  @rvdata.post << "#{retval} = GirFFI::ArgHelper.ptr_to_#{tag}_array #{cvar}, #{rv}"
+	end
+	@rvdata.retval = retval
       else
-	@retvals << cvar
+	@rvdata.retval = cvar
       end
     end
 
     def adjust_accumulators
+      @retvals << @rvdata.retval
+      @data.each do |data|
+	@inargs << data.inarg
+	@callargs << data.callarg
+	@retvals << data.retval
+	@pre += data.pre
+	@post += data.post
+      end
+      @data.each do |data|
+	@post += data.postpost
+      end
+      @post += @rvdata.post
+
       if @info.throws?
 	errvar = new_var
 	@pre << "#{errvar} = FFI::MemoryPointer.new(:pointer).write_pointer nil"
@@ -160,7 +289,8 @@ module GirFFI
 	@callargs << errvar
       end
 
-      @post << "return #{@retvals.join(', ')}" unless @retvals.empty?
+      @retvals = @retvals.compact
+      @post << "return #{@retvals.compact.join(', ')}" unless @retvals.empty?
 
       if @info.method?
 	@callargs.unshift "self"
@@ -169,9 +299,9 @@ module GirFFI
 
     def filled_out_template
       return <<-CODE
-	def #{@info.name} #{@inargs.join(', ')}
+	def #{@info.name} #{@inargs.compact.join(', ')}
 	  #{@pre.join("\n")}
-	  #{@capture}::#{@libmodule}.#{@info.symbol} #{@callargs.join(', ')}
+	  #{@capture}::#{@libmodule}.#{@info.symbol} #{@callargs.compact.join(', ')}
 	  #{@post.join("\n")}
 	end
       CODE

data/lib/gir_ffi/i_arg_info.rb

@@ -12,6 +12,9 @@ module GirFFI
     def optional?
       Lib.g_arg_info_is_optional @gobj
     end
+    def caller_allocates?
+      Lib.g_arg_info_is_caller_allocates @gobj
+    end
     def may_be_null?
       Lib.g_arg_info_may_be_null @gobj
     end

data/lib/gir_ffi/i_callback_info.rb

@@ -1,5 +1,5 @@
 module GirFFI
-  # Wraps a GICallbackInfo struct. Has no methods in addition to the onese
+  # Wraps a GICallbackInfo struct. Has no methods in addition to the ones
   # inherited from ICallableInfo.
   class ICallbackInfo < ICallableInfo
   end

data/lib/gir_ffi/i_interface_info.rb

@@ -1,7 +1,72 @@
 module GirFFI
-  # Wraps a GIInterfaceInfo struct.
+  # Wraps a IInterfaceInfo struct.
   # Represents an interface.
-  # Not implemented yet.
   class IInterfaceInfo < IRegisteredTypeInfo
+    def n_prerequisites
+      Lib.g_interface_info_get_n_prerequisites @gobj
+    end
+    def prerequisite index
+      IBaseInfo.wrap(Lib.g_interface_info_get_prerequisite @gobj, index)
+    end
+    ##
+    build_array_method :prerequisites
+
+    def n_properties
+      Lib.g_interface_info_get_n_properties @gobj
+    end
+    def property index
+      IPropertyInfo.wrap(Lib.g_interface_info_get_property @gobj, index)
+    end
+    ##
+    build_array_method :properties, :property
+
+    def n_methods
+      Lib.g_interface_info_get_n_methods @gobj
+    end
+    def method index
+      IFunctionInfo.wrap(Lib.g_interface_info_get_method @gobj, index)
+    end
+    ##
+    build_array_method :methods
+
+    def find_method name
+      IFunctionInfo.wrap(Lib.g_interface_info_find_method @gobj, name)
+    end
+
+    def n_signals
+      Lib.g_interface_info_get_n_signals @gobj
+    end
+    def signal index
+      ISignalInfo.wrap(Lib.g_interface_info_get_signal @gobj, index)
+    end
+    ##
+    build_array_method :signals
+
+    def n_vfuncs
+      Lib.g_interface_info_get_n_vfuncs @gobj
+    end
+    def vfunc index
+      IVFuncInfo.wrap(Lib.g_interface_info_get_vfunc @gobj, index)
+    end
+    ##
+    build_array_method :vfuncs
+
+    def find_vfunc name
+      IVFuncInfo.wrap(Lib.g_interface_info_find_vfunc @gobj, name)
+    end
+
+    def n_constants
+      Lib.g_interface_info_get_n_constants @gobj
+    end
+    def constant index
+      IConstantInfo.wrap(Lib.g_interface_info_get_constant @gobj, index)
+    end
+    ##
+    build_array_method :constants
+
+    def iface_struct
+      IStructInfo.wrap(Lib.g_interface_info_get_iface_struct @gobj)
+    end
+
   end
 end

data/lib/gir_ffi/i_repository.rb

@@ -96,6 +96,11 @@ module GirFFI
       return wrap ptr
     end
 
+    def find_by_gtype gtype
+      ptr = Lib.g_irepository_find_by_gtype @gobj, gtype
+      return wrap ptr
+    end
+
     def shared_library namespace
       Lib.g_irepository_get_shared_library @gobj, namespace
     end

data/lib/gir_ffi/lib.rb

@@ -17,6 +17,8 @@ module GirFFI
       [:pointer, :string, :int], :pointer
     attach_function :g_irepository_find_by_name,
       [:pointer, :string, :string], :pointer
+    attach_function :g_irepository_find_by_gtype, [:pointer, :size_t], :pointer
+
     attach_function :g_irepository_get_shared_library,
       [:pointer, :string], :string
 
@@ -85,6 +87,7 @@ module GirFFI
     attach_function :g_arg_info_get_direction, [:pointer], :IDirection
     attach_function :g_arg_info_is_return_value, [:pointer], :bool
     attach_function :g_arg_info_is_optional, [:pointer], :bool
+    attach_function :g_arg_info_is_caller_allocates, [:pointer], :bool
     attach_function :g_arg_info_may_be_null, [:pointer], :bool
     attach_function :g_arg_info_get_ownership_transfer, [:pointer], :ITransfer
     attach_function :g_arg_info_get_scope, [:pointer], :IScopeType
@@ -150,7 +153,7 @@ module GirFFI
     # IRegisteredTypeInfo
     attach_function :g_registered_type_info_get_type_name, [:pointer], :string
     attach_function :g_registered_type_info_get_type_init, [:pointer], :string
-    attach_function :g_registered_type_info_get_g_type, [:pointer], :int
+    attach_function :g_registered_type_info_get_g_type, [:pointer], :size_t
 
     # IEnumInfo
     attach_function :g_enum_info_get_storage_type, [:pointer], :ITypeTag
@@ -192,5 +195,23 @@ module GirFFI
     attach_function :g_vfunc_info_get_offset, [:pointer], :int
     attach_function :g_vfunc_info_get_signal, [:pointer], :pointer
     attach_function :g_vfunc_info_get_invoker, [:pointer], :pointer
+
+    # IInterfaceInfo
+    attach_function :g_interface_info_get_n_prerequisites, [:pointer], :int
+    attach_function :g_interface_info_get_prerequisite, [:pointer, :int], :pointer
+    attach_function :g_interface_info_get_n_properties, [:pointer], :int
+    attach_function :g_interface_info_get_property, [:pointer, :int], :pointer
+    attach_function :g_interface_info_get_n_methods, [:pointer], :int
+    attach_function :g_interface_info_get_method, [:pointer, :int], :pointer
+    attach_function :g_interface_info_find_method, [:pointer, :string], :pointer
+    attach_function :g_interface_info_get_n_signals, [:pointer], :int
+    attach_function :g_interface_info_get_signal, [:pointer, :int], :pointer
+    attach_function :g_interface_info_get_n_vfuncs, [:pointer], :int
+    attach_function :g_interface_info_get_vfunc, [:pointer, :int], :pointer
+    attach_function :g_interface_info_find_vfunc, [:pointer, :string], :pointer
+    attach_function :g_interface_info_get_n_constants, [:pointer], :int
+    attach_function :g_interface_info_get_constant, [:pointer, :int], :pointer
+    attach_function :g_interface_info_get_iface_struct, [:pointer], :pointer
+    
   end
 end

data/lib/gir_ffi/module_builder.rb

@@ -70,6 +70,7 @@ 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)
       end
 

data/lib/gir_ffi/overrides/gobject.rb

@@ -7,9 +7,10 @@ module GirFFI
       end
 
       module ClassMethods
+	# FIXME: These four helper methods belong elsewhere.
 	def type_from_instance_pointer inst_ptr
-	  base = ::GObject::TypeInstance.new inst_ptr
-	  kls = ::GObject::TypeClass.new(base[:g_class])
+	  base = ::GObject::TypeInstance.wrap inst_ptr
+	  kls = ::GObject::TypeClass.wrap(base[:g_class])
 	  kls[:g_type]
 	end
 
@@ -38,14 +39,6 @@ module GirFFI
 	  end
 	end
 
-	# FIXME: This is a private helper function. Move elsewhere?
-	def signal_callback_args sig, klass, &block
-	  return Proc.new do |*args|
-	    mapped = Helper.cast_back_signal_arguments sig, klass, *args
-	    block.call(*mapped)
-	  end
-	end
-
 	def signal_emit object, signal, *args
 	  type = type_from_instance object
 
@@ -80,19 +73,29 @@ module GirFFI
 	  if sig.nil?
 	    raise "Signal #{signal} is invalid for #{object}"
 	  end
+	  if block.nil?
+	    raise ArgumentError, "Block needed"
+	  end
 
 	  rettype = GirFFI::Builder.itypeinfo_to_ffitype sig.return_type
 
 	  argtypes = [:pointer] + sig.args.map {|a| :pointer} + [:pointer]
 
 	  callback = FFI::Function.new rettype, argtypes,
-	    &(signal_callback_args(sig, object.class, &block))
+	    &(Helper.signal_callback_args(sig, object.class, &block))
 
 	  signal_connect_data object, signal, callback, data, nil, 0
 	end
       end
 
       module Helper
+	def self.signal_callback_args sig, klass, &block
+	  return Proc.new do |*args|
+	    mapped = cast_back_signal_arguments sig, klass, *args
+	    block.call(*mapped)
+	  end
+	end
+
 	def self.signal_arguments_to_gvalue_array signal, instance, *rest
 	  sig = instance.class.gir_ffi_builder.find_signal signal
 
@@ -137,7 +140,7 @@ module GirFFI
 
 	  # Instance
 	  instptr = args.shift
-	  instance = klass.send :_real_new, instptr
+	  instance = klass.wrap instptr
 	  result << instance
 
 	  # Extra arguments
@@ -146,7 +149,7 @@ module GirFFI
 	    if info.type.tag == :interface
 	      iface = info.type.interface
 	      kls = GirFFI::Builder.build_class(iface.namespace, iface.name)
-	      result << kls.send(:_real_new, arg)
+	      result << kls.wrap(arg)
 	    else
 	      result << arg
 	    end

data/lib/gir_ffi/overrides/gtk.rb

@@ -18,7 +18,7 @@ module GirFFI
       module ClassMethods
 
 	def init_with_auto_argv
-	  (my_len, my_args) = init_without_auto_argv ARGV.length + 1, [$0, *ARGV]
+	  my_args = init_without_auto_argv [$0, *ARGV]
 	  my_args.shift
 	  ARGV.replace my_args
 	end