gir_ffi 0.6.7 → 0.7.0

data/lib/gir_ffi/builders/registered_type_builder.rb

@@ -18,7 +18,7 @@ module GirFFI
       def setup_gtype_getter
         gtype = target_gtype
         return if gtype.nil?
-        @klass.instance_eval "
+        klass.instance_eval "
           def self.get_gtype
             #{gtype}
           end
@@ -29,7 +29,7 @@ module GirFFI
       def provide_constructor
         return if info.find_method 'new'
 
-        (class << @klass; self; end).class_eval {
+        (class << klass; self; end).class_eval {
           alias_method :new, :_allocate
         }
       end

data/lib/gir_ffi/builders/return_value_builder.rb

@@ -1,63 +1,72 @@
 require 'gir_ffi/builders/base_argument_builder'
+require 'gir_ffi/builders/c_to_ruby_convertor'
+require 'gir_ffi/builders/closure_convertor'
+require 'gir_ffi/builders/constructor_result_convertor'
 
 module GirFFI
   module Builders
     # Implements building post-processing statements for return values.
     class ReturnValueBuilder < BaseArgumentBuilder
-      def initialize var_gen, type_info, is_constructor = false, skip = false
-        super var_gen, nil, type_info, :return
+      def initialize var_gen, arginfo, is_constructor = false
+        super var_gen, arginfo
         @is_constructor = is_constructor
-        @skip = skip
       end
 
-      def post
-        if has_conversion?
-          [ "#{retname} = #{post_conversion}" ]
-        else
-          []
-        end
+      def is_relevant?
+        !is_void_return_value? && !arginfo.skip?
       end
 
-      def inarg
-        nil
+      def capture_variable_name
+        @capture_variable_name ||= new_variable
       end
 
-      def retval
-        if has_conversion?
-          super
-        elsif is_relevant?
-          callarg
-        else
-          nil
+      def post_converted_name
+        @post_converted_name ||= if has_post_conversion?
+                                   new_variable
+                                 else
+                                   capture_variable_name
+                                 end
+      end
+
+      def return_value_name
+        if is_relevant?
+          post_converted_name unless array_arg
         end
       end
 
-      def is_relevant?
-        !is_void_return_value? && !@skip
+      def post_conversion
+        if has_post_conversion?
+          [ "#{post_converted_name} = #{post_convertor.conversion}" ]
+        else
+          []
+        end
       end
 
       private
 
-      def has_conversion?
-        is_closure || needs_outgoing_parameter_conversion? || needs_constructor_wrap?
+      def has_post_conversion?
+        is_closure || needs_constructor_wrap? ||
+          type_info.needs_conversion_for_functions?
       end
 
-      def post_conversion
-        if is_closure
-          "GirFFI::ArgHelper::OBJECT_STORE[#{callarg}.address]"
-        elsif needs_constructor_wrap?
-          "self.constructor_wrap(#{callarg})"
-        else
-          outgoing_conversion callarg
-        end
+      def post_convertor
+        @post_convertor ||= if is_closure
+                              ClosureConvertor.new(capture_variable_name)
+                            elsif needs_constructor_wrap?
+                              ConstructorResultConvertor.new(capture_variable_name)
+                            else
+                              CToRubyConvertor.new(type_info,
+                                                   capture_variable_name,
+                                                   length_argument_name)
+                            end
       end
 
-      def retname
-        @retname ||= @var_gen.new_var
+      def length_argument_name
+        length_arg && length_arg.post_converted_name
       end
 
       def needs_constructor_wrap?
-        @is_constructor && [ :interface, :object ].include?(specialized_type_tag)
+        @is_constructor && specialized_type_tag == :object
       end
 
       def is_void_return_value?

data/lib/gir_ffi/builders/ruby_to_c_convertor.rb

@@ -0,0 +1,15 @@
+class GirFFI::Builders::RubyToCConvertor
+  def initialize type_info, argument_name
+    @type_info = type_info
+    @argument_name = argument_name
+  end
+
+  def conversion
+    args = conversion_arguments @argument_name
+    "#{@type_info.argument_class_name}.from(#{args})"
+  end
+
+  def conversion_arguments name
+    @type_info.extra_conversion_arguments.map(&:inspect).push(name).join(", ")
+  end
+end

data/lib/gir_ffi/builders/signal_builder.rb

@@ -1,82 +1,42 @@
 require 'gir_ffi/builders/base_type_builder'
 require 'gir_ffi/builders/mapping_method_builder'
+require 'gir_ffi/receiver_type_info'
+require 'gir_ffi/receiver_argument_info'
 require 'gir_ffi/signal_base'
+require 'gir_ffi/user_data_type_info'
+require 'gir_ffi/user_data_argument_info'
 
 module GirFFI
   module Builders
     # Implements the creation of a signal module for handling a particular
     # signal. The type will be attached to the appropriate class.
     class SignalBuilder < BaseTypeBuilder
-      class SignalReceiverTypeInfo
-        include InfoExt::ITypeInfo
-
-        def initialize interface_info
-          @interface_info = interface_info
-        end
-
-        def interface
-          @interface_info
-        end
-
-        def tag
-          :interface
-        end
-      end
-
-      class SignalReceiverArgumentInfo
-        attr_reader :argument_type
-
-        def initialize type
-          @argument_type = type
-        end
-
-        def closure
-          -1
-        end
-      end
-
-      class UserDataTypeInfo
-        include InfoExt::ITypeInfo
-
-        def tag
-          :void
-        end
-
-        def pointer?
-          true
-        end
-      end
-
-      class UserDataArgumentInfo
-        attr_reader :argument_type
-        attr_reader :closure
-        def initialize type, position
-          @argument_type = type
-          @closure = position
-        end
-      end
-
       def instantiate_class
-        @klass ||= get_or_define_module container_class, @classname
         unless already_set_up
-          @klass.extend SignalBase
+          klass.extend SignalBase
           setup_constants
-          @klass.class_eval mapping_method_definition
+          klass.class_eval mapping_method_definition
         end
-        @klass
+        klass
+      end
+
+      def klass
+        @klass ||= get_or_define_module container_class, @classname
       end
 
       def mapping_method_definition
         arg_infos = info.args
 
-        container_type_info = SignalReceiverTypeInfo.new(container_info)
-        arg_infos.unshift SignalReceiverArgumentInfo.new(container_type_info)
+        container_type_info = ReceiverTypeInfo.new(container_info)
+        receiver_info = ReceiverArgumentInfo.new(container_type_info)
 
         user_data_type_info = UserDataTypeInfo.new
-        user_data_argument_info = UserDataArgumentInfo.new(user_data_type_info, arg_infos.length)
-        arg_infos.push user_data_argument_info
+        user_data_argument_info = UserDataArgumentInfo.new(user_data_type_info)
 
-        MappingMethodBuilder.new(arg_infos, info.return_type).method_definition
+        MappingMethodBuilder.for_signal(receiver_info,
+                                        arg_infos,
+                                        user_data_argument_info,
+                                        info.return_type).method_definition
       end
 
       def container_class

data/lib/gir_ffi/builders/struct_builder.rb

@@ -23,8 +23,7 @@ module GirFFI
 
       # FIXME: Private method only in subclass
       def layout_superclass
-        # FIXME: Is this needed now that StructBase is a DataConverter?
-        GirFFI::Struct
+        FFI::Struct
       end
 
       def superclass

data/lib/gir_ffi/builders/type_builder.rb

@@ -7,6 +7,7 @@ require 'gir_ffi/builders/struct_builder'
 require 'gir_ffi/builders/signal_builder'
 require 'gir_ffi/builders/unintrospectable_builder'
 require 'gir_ffi/builders/union_builder'
+require 'gir_ffi/builders/vfunc_builder'
 
 module GirFFI
   module Builders

data/lib/gir_ffi/builders/unintrospectable_builder.rb

@@ -7,13 +7,13 @@ module GirFFI
     # cast objects returned by a function that returns an interface.
     class UnintrospectableBuilder < ObjectBuilder
       def instantiate_class
-        gtype = target_gtype
-        TypeBuilder::CACHE[gtype] ||= Class.new(superclass)
-        @klass = TypeBuilder::CACHE[gtype]
-        @structklass = get_or_define_class @klass, :Struct, layout_superclass
         setup_class unless already_set_up
       end
 
+      def klass
+        @klass ||= TypeBuilder::CACHE[target_gtype] ||= Class.new(superclass)
+      end
+
       def setup_class
         setup_constants
         setup_layout

data/lib/gir_ffi/builders/user_defined_builder.rb

@@ -1,4 +1,5 @@
 require 'gir_ffi/builders/object_builder'
+require 'gir_ffi/g_type'
 
 module GirFFI
   module Builders
@@ -9,25 +10,19 @@ module GirFFI
       end
 
       def instantiate_class
-        @klass = @info.described_class
-
-        parent_type = @klass.get_gtype
-        @parent = gir.find_by_gtype(parent_type)
-
-        query_result = GObject.type_query parent_type
-        type_info = GObject::TypeInfo.new
-        type_info.class_size = query_result.class_size
-        type_info.instance_size = query_result.instance_size
-        properties.each do
-          type_info.instance_size += FFI.type_size(:int32)
+        if already_set_up
+          @gtype = klass.get_gtype
+        else
+          @gtype = GObject.type_register_static(parent_gtype.to_i,
+                                                info.g_name,
+                                                gobject_type_info, 0)
+          included_interfaces.each do |interface|
+            ifinfo = gobject_interface_info interface
+            GObject.type_add_interface_static @gtype, interface.get_gtype, ifinfo
+          end
+          setup_class
+          TypeBuilder::CACHE[@gtype] = klass
         end
-
-        @gtype = GObject.type_register_static(parent_type, @klass.name,
-                                              type_info, 0)
-
-        @structklass = get_or_define_class @klass, :Struct, layout_superclass
-        setup_class unless already_set_up
-        TypeBuilder::CACHE[@gtype] = @klass
       end
 
       def setup_class
@@ -41,14 +36,143 @@ module GirFFI
         setup_constructor
       end
 
+      def gtype
+        @gtype
+      end
+
       private
 
+      # FIXME: Is this really used?
       def target_gtype
         @gtype
       end
 
       def parent
-        @parent
+        @parent ||= gir.find_by_gtype(parent_gtype.to_i)
+      end
+
+      def parent_gtype
+        @parent_gtype ||= GType.new(klass.superclass.get_gtype)
+      end
+
+      def interface_gtypes
+        included_interfaces.map {|interface| GType.new(interface.get_gtype) }
+      end
+
+      def included_interfaces
+        klass.included_modules - Object.included_modules
+      end
+
+      def klass
+        @klass ||= @info.described_class
+      end
+
+      def gobject_type_info
+        GObject::TypeInfo.new.tap do |type_info|
+          type_info.class_size = class_size
+          type_info.instance_size = instance_size
+          type_info.class_init = class_init_proc
+        end
+      end
+
+      def gobject_interface_info interface
+        GObject::InterfaceInfo.new.tap do |interface_info|
+          interface_info.interface_init = interface_init_proc(interface)
+        end
+      end
+
+      def class_init_proc
+        proc do |object_class_ptr, data|
+          setup_properties object_class_ptr
+          setup_vfuncs object_class_ptr
+        end
+      end
+
+      def interface_init_proc interface
+        proc do |interface_ptr, data|
+          setup_interface_vfuncs interface, interface_ptr
+        end
+      end
+
+      def instance_size
+        size = parent_gtype.instance_size
+        properties.each do
+          size += FFI.type_size(:int32)
+        end
+        return size
+      end
+
+      def class_size
+        parent_gtype.class_size + interface_gtypes.map(&:class_size).inject(0, :+)
+      end
+
+      def setup_properties object_class_ptr
+        object_class = GObject::ObjectClass.wrap object_class_ptr
+
+        object_class.get_property = property_getter
+        object_class.set_property = property_setter
+
+        properties.each_with_index do |property, index|
+          object_class.install_property index + 1, property.param_spec
+        end
+      end
+
+      def property_getter
+        proc do |object, property_id, value, pspec|
+          value.set_value object.send(pspec.get_name)
+        end
+      end
+
+      def property_setter
+        proc do |object, property_id, value, pspec|
+          object.send("#{pspec.get_name}=", value.get_value)
+        end
+      end
+
+      def setup_vfuncs object_class_ptr
+        super_class_struct = superclass.gir_ffi_builder.object_class_struct::Struct.new(object_class_ptr)
+
+        info.vfunc_implementations.each do |impl|
+          setup_vfunc super_class_struct, impl
+        end
+      end
+
+      def setup_interface_vfuncs interface, interface_ptr
+        interface_builder = interface.gir_ffi_builder
+
+        interface_struct = interface_builder.interface_struct::Struct.new(interface_ptr)
+        interface_info = interface_builder.info
+
+        info.vfunc_implementations.each do |impl|
+          setup_interface_vfunc interface_info, interface_struct, impl
+        end
+      end
+
+      def setup_vfunc super_class_struct, impl
+        vfunc_name = impl.name
+        vfunc_info = parent.find_vfunc vfunc_name.to_s
+
+        if vfunc_info
+          install_vfunc super_class_struct, vfunc_name, vfunc_info, impl.implementation
+        end
+      end
+
+      def setup_interface_vfunc interface_info, interface_struct, impl
+        vfunc_name = impl.name
+        vfunc_info = interface_info.find_vfunc vfunc_name.to_s
+
+        if vfunc_info
+          install_vfunc interface_struct, vfunc_name, vfunc_info, impl.implementation
+        end
+      end
+
+      def install_vfunc container_struct, vfunc_name, vfunc_info, implementation
+        vfunc = VFuncBuilder.new(vfunc_info).build_class
+        # NOTE: This assigns a VFuncBase to a CallbackBase.
+        # This suggests that the two should be combined, but it seems
+        # CallbackBase will not cast the first argument correctly if used
+        # to map the implementation proc arguments.
+        container_struct[vfunc_name] = vfunc.from implementation
       end
 
       def properties
@@ -73,19 +197,20 @@ module GirFFI
       end
 
       def setup_accessors_for_param_info pinfo
+        field_name = pinfo.name
         code = <<-CODE
-        def #{pinfo.name}
-          @struct[:#{pinfo.name}]
+        def #{field_name}
+          @struct[:#{field_name}]
         end
-        def #{pinfo.name}= val
-          @struct[:#{pinfo.name}] = val
+        def #{field_name}= val
+          @struct[:#{field_name}] = val
         end
         CODE
 
-        @klass.class_eval code
+        klass.class_eval code
       end
 
-      def method_introspection_data method
+      def method_introspection_data _method
         nil
       end
 
@@ -96,7 +221,7 @@ module GirFFI
           self.wrap(gptr)
         end
         CODE
-        @klass.class_eval code
+        klass.class_eval code
       end
     end
   end