gir_ffi 0.9.5 → 0.10.0.pre1

data/lib/gir_ffi/builders/c_to_ruby_convertor.rb

@@ -4,32 +4,57 @@ module GirFFI
     # Builder that generates code to convert values from C to Ruby. Used by
     # argument builders.
     class CToRubyConvertor
-      def initialize(type_info, argument_name, length_arg)
+      def initialize(type_info, argument, length_arg, ownership_transfer: nil)
         @type_info = type_info
-        @argument_name = argument_name
+        @argument = argument
         @length_arg = length_arg
+        @ownership_transfer = ownership_transfer
       end
 
       def conversion
         case @type_info.flattened_tag
         when :utf8, :filename
-          "#{@argument_name}.to_utf8"
+          if @ownership_transfer == :everything
+            "#{@argument}.tap { |it| it.autorelease = true }.to_utf8"
+          else
+            "#{@argument}.to_utf8"
+          end
+        when :object
+          base = "#{@type_info.argument_class_name}.wrap(#{conversion_argument_list})"
+          @ownership_transfer == :nothing ? "#{base}.tap { |it| it && it.ref }" : base
         else
-          "#{@type_info.argument_class_name}.wrap(#{conversion_argument_list})"
+          "#{argument_class}.#{conversion_method}(#{conversion_argument_list})"
         end
       end
 
       private
 
+      def conversion_method
+        case @type_info.flattened_tag
+        when :struct, :union
+          case @ownership_transfer
+          when :everything
+            'wrap_own'
+          when :nothing
+            'wrap_copy'
+          else
+            'wrap'
+          end
+        else
+          'wrap'
+        end
+      end
+
       def conversion_argument_list
         conversion_arguments.join(', ')
       end
 
       def conversion_arguments
-        if @type_info.flattened_tag == :c
-          [@type_info.element_type.inspect, array_size, @argument_name]
+        case @type_info.flattened_tag
+        when :c
+          [@type_info.element_type.inspect, array_size, @argument]
         else
-          @type_info.extra_conversion_arguments.map(&:inspect).push(@argument_name)
+          @type_info.extra_conversion_arguments.map(&:inspect).push(@argument)
         end
       end
 
@@ -40,6 +65,10 @@ module GirFFI
           @type_info.array_fixed_size
         end
       end
+
+      def argument_class
+        @type_info.argument_class_name
+      end
     end
   end
 end

data/lib/gir_ffi/builders/callback_argument_builder.rb

@@ -3,6 +3,7 @@ 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/null_convertor'
+require 'gir_ffi/builders/pointer_value_convertor'
 
 module GirFFI
   module Builders
@@ -62,11 +63,11 @@ module GirFFI
       def post_conversion
         case direction
         when :out, :inout
-          [outgoing_post_conversion]
+          [value_to_pointer_conversion]
         when :error
           [
             "rescue => #{result_name}",
-            outgoing_post_conversion,
+            value_to_pointer_conversion,
             'end'
           ]
         else
@@ -82,12 +83,25 @@ module GirFFI
 
       def pre_convertor_argument
         if direction == :inout
-          "#{out_parameter_name}.to_value"
+          pointer_to_value_conversion
         else
           method_argument_name
         end
       end
 
+      def pointer_value_convertor
+        @pointer_value_convertor ||= PointerValueConvertor.new(type_spec)
+      end
+
+      def pointer_to_value_conversion
+        pointer_value_convertor.pointer_to_value(out_parameter_name)
+      end
+
+      def value_to_pointer_conversion
+        pointer_value_convertor.value_to_pointer(out_parameter_name,
+                                                 post_convertor.conversion)
+      end
+
       def pre_convertor
         @pre_convertor ||= if closure?
                              ClosureConvertor.new(pre_convertor_argument)
@@ -108,10 +122,6 @@ module GirFFI
         "#{pre_converted_name} = #{pre_convertor.conversion}"
       end
 
-      def outgoing_post_conversion
-        "#{out_parameter_name}.set_value #{post_convertor.conversion}"
-      end
-
       def post_convertor
         @post_convertor ||= if type_info.needs_ruby_to_c_conversion_for_callbacks?
                               RubyToCConvertor.new(type_info, post_convertor_argument)
@@ -129,16 +139,20 @@ module GirFFI
       end
 
       def out_parameter_preparation
-        type_spec = type_info.tag_or_class
         value = if allocated_by_us?
-                  "GirFFI::InOutPointer.new(#{type_spec[1].inspect})" \
+                  ffi_type = TypeMap.type_specification_to_ffi_type type_spec[1]
+                  "GirFFI::AllocationHelper.allocate(#{ffi_type.inspect})" \
                     ".tap { |ptr| #{method_argument_name}.put_pointer 0, ptr }"
                 else
-                  "GirFFI::InOutPointer.new(#{type_spec.inspect}, #{method_argument_name})"
+                  method_argument_name
                 end
         "#{out_parameter_name} = #{value}"
       end
 
+      def type_spec
+        type_info.tag_or_class
+      end
+
       # Check if an out argument needs to be allocated by us, the callee. Since
       # caller_allocates is false by default, we must also check that the type
       # is a pointer. For example, an out parameter of type gint8* will always

data/lib/gir_ffi/builders/closure_to_pointer_convertor.rb

@@ -10,7 +10,7 @@ module GirFFI
       end
 
       def conversion
-        "GirFFI::InPointer.from_closure_data(#{callback_argument_name})"
+        "GirFFI::ArgHelper.store(#{callback_argument_name})"
       end
 
       private

data/lib/gir_ffi/builders/field_builder.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 require 'gir_ffi/builders/argument_builder'
+require 'gir_ffi/builders/base_argument_builder'
+require 'gir_ffi/builders/null_argument_builder'
+require 'gir_ffi/builders/pointer_value_convertor'
 require 'gir_ffi/variable_name_generator'
 require 'gir_ffi/field_argument_info'
 
@@ -23,8 +26,7 @@ module GirFFI
         def pre_conversion
           [
             "#{field_ptr} = @struct.to_ptr + #{field_offset}",
-            "#{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag}, #{field_ptr})",
-            "#{bare_value} = #{typed_ptr}.to_value"
+            "#{bare_value} = #{pointer_to_value_conversion}"
           ]
         end
 
@@ -54,6 +56,10 @@ module GirFFI
 
         private
 
+        def pointer_to_value_conversion
+          PointerValueConvertor.new(field_type_tag).pointer_to_value(field_ptr)
+        end
+
         def field_offset
           @field_info.offset
         end
@@ -71,7 +77,7 @@ module GirFFI
         end
 
         def field_type_tag
-          @field_type_tag ||= @field_info.field_type.tag_or_class.inspect
+          @field_type_tag ||= @field_info.field_type.tag_or_class
         end
 
         def field_type
@@ -112,7 +118,7 @@ module GirFFI
         end
 
         def ownership_transfer
-          :everything
+          :nothing
         end
 
         def caller_allocates?
@@ -233,7 +239,9 @@ module GirFFI
       end
 
       def setup_getter
-        container_class.class_eval getter_def unless container_defines_getter_method?
+        return if container_defines_getter_method?
+        return if hidden_struct_type?
+        container_class.class_eval getter_def
       end
 
       def container_defines_getter_method?
@@ -241,7 +249,9 @@ module GirFFI
       end
 
       def setup_setter
-        container_class.class_eval setter_def if info.writable?
+        return unless info.writable?
+        return if hidden_struct_type?
+        container_class.class_eval setter_def
       end
 
       def getter_def
@@ -254,22 +264,25 @@ module GirFFI
         builder = setter_builder
 
         field_ptr = builder.new_variable
-        typed_ptr = builder.new_variable
 
         <<-CODE.reset_indentation
         def #{info.name}= #{builder.method_argument_name}
           #{field_ptr} = @struct.to_ptr + #{info.offset}
-          #{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag}, #{field_ptr})
           #{builder.pre_conversion.join("\n          ")}
-          #{typed_ptr}.set_value #{builder.call_argument_name}
+          #{value_storage(field_ptr, builder)}
         end
         CODE
       end
 
       private
 
+      def value_storage(typed_ptr, builder)
+        PointerValueConvertor.new(field_type_tag).
+          value_to_pointer(typed_ptr, builder.call_argument_name)
+      end
+
       def field_type_tag
-        @field_type_tag ||= info.field_type.tag_or_class.inspect
+        @field_type_tag ||= field_type.tag_or_class
       end
 
       def container_class
@@ -296,6 +309,11 @@ module GirFFI
         @setter_builder ||= ArgumentBuilder.new(VariableNameGenerator.new,
                                                 field_argument_info)
       end
+
+      # rubocop:disable Style/ZeroLengthPredicate
+      def hidden_struct_type?
+        field_type.flattened_tag == :struct && field_type.interface.size == 0
+      end
     end
   end
 end

data/lib/gir_ffi/builders/full_c_to_ruby_convertor.rb

@@ -7,11 +7,10 @@ module GirFFI
     # GValue unpacking. Used by argument builders.
     class FullCToRubyConvertor < CToRubyConvertor
       def conversion
-        base = super
         if @type_info.gvalue?
-          "#{base}.get_value"
+          "GObject::Value.wrap(#{@argument}).get_value"
         else
-          base
+          super
         end
       end
     end

data/lib/gir_ffi/builders/initializer_return_value_builder.rb

@@ -6,7 +6,11 @@ module GirFFI
     # Implements post-conversion for initializer functions
     class InitializerReturnValueBuilder < BaseReturnValueBuilder
       def post_conversion
-        ["store_pointer(#{capture_variable_name})"]
+        result = []
+        if specialized_type_tag == :struct
+          result << "#{capture_variable_name}.autorelease = true"
+        end
+        result << "store_pointer(#{capture_variable_name})"
       end
     end
   end

data/lib/gir_ffi/builders/null_argument_builder.rb

@@ -33,18 +33,6 @@ module GirFFI
       nil
     end
 
-    def closure_idx
-      -1
-    end
-
-    def destroy_idx
-      -1
-    end
-
-    def block_argument?
-      false
-    end
-
     def post_converted_name
       nil
     end

data/lib/gir_ffi/builders/pointer_value_convertor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module GirFFI
+  module Builders
+    # Encapsulates knowledge about how to store values in pointers, and how to
+    # fetch values from pointers.
+    class PointerValueConvertor
+      def initialize(type_spec)
+        @type_spec = type_spec
+      end
+
+      def pointer_to_value(ptr_exp)
+        case ffi_type_spec
+        when Module
+          "#{ffi_type_spec}.get_value_from_pointer(#{ptr_exp}, 0)"
+        when Symbol
+          "#{ptr_exp}.get_#{ffi_type_spec}(0)"
+        end
+      end
+
+      def value_to_pointer(ptr_exp, value_exp)
+        case ffi_type_spec
+        when Module
+          "#{ffi_type_spec}.copy_value_to_pointer(#{value_exp}, #{ptr_exp})"
+        when Symbol
+          "#{ptr_exp}.put_#{ffi_type_spec} 0, #{value_exp}"
+        end
+      end
+
+      private
+
+      attr_reader :type_spec
+
+      def ffi_type_spec
+        TypeMap.type_specification_to_ffi_type type_spec
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/return_value_builder.rb

@@ -8,11 +8,11 @@ module GirFFI
     # Implements building post-processing statements for return values.
     class ReturnValueBuilder < BaseReturnValueBuilder
       def post_conversion
+        result = []
         if has_post_conversion?
-          ["#{post_converted_name} = #{post_convertor.conversion}"]
-        else
-          []
+          result << "#{post_converted_name} = #{post_convertor.conversion}"
         end
+        result
       end
 
       def has_post_conversion?
@@ -26,13 +26,15 @@ module GirFFI
       private
 
       def post_convertor
-        @post_convertor ||= if closure?
-                              ClosureConvertor.new(capture_variable_name)
-                            else
-                              FullCToRubyConvertor.new(type_info,
-                                                       capture_variable_name,
-                                                       length_argument_name)
-                            end
+        @post_convertor ||=
+          if closure?
+            ClosureConvertor.new(capture_variable_name)
+          else
+            FullCToRubyConvertor.new(type_info,
+                                     capture_variable_name,
+                                     length_argument_name,
+                                     ownership_transfer: arginfo.ownership_transfer)
+          end
       end
 
       def length_argument_name

data/lib/gir_ffi/builders/ruby_to_c_convertor.rb

@@ -4,19 +4,38 @@ module GirFFI
     # Builder that generates code to convert values from Ruby to C. Used by
     # argument builders.
     class RubyToCConvertor
-      def initialize(type_info, argument_name)
+      def initialize(type_info, argument_name, ownership_transfer: nil)
         @type_info = type_info
         @argument_name = argument_name
+        @ownership_transfer = ownership_transfer
       end
 
       def conversion
         args = conversion_arguments @argument_name
-        "#{@type_info.argument_class_name}.from(#{args})"
+        "#{@type_info.argument_class_name}.#{conversion_method}(#{args})"
       end
 
       def conversion_arguments(name)
         @type_info.extra_conversion_arguments.map(&:inspect).push(name).join(', ')
       end
+
+      private
+
+      def conversion_method
+        case @type_info.flattened_tag
+        when :utf8
+          'from_utf8'
+        when :struct, :c
+          case @ownership_transfer
+          when :everything
+            'copy_from'
+          else
+            'from'
+          end
+        else
+          'from'
+        end
+      end
     end
   end
 end

data/lib/gir_ffi/builders/struct_builder.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
-require 'gir_ffi/builders/boxed_builder'
+require 'gir_ffi/builders/registered_type_builder'
+require 'gir_ffi/builders/struct_like'
 require 'gir_ffi/struct_base'
 
 module GirFFI
   module Builders
     # Implements the creation of a class representing a Struct.
-    class StructBuilder < BoxedBuilder
+    class StructBuilder < RegisteredTypeBuilder
+      include StructLike
+
       def layout_superclass
         FFI::Struct
       end
@@ -21,6 +24,10 @@ module GirFFI
           end
         end
 
+        if GObject.type_fundamental(info.gtype) == GObject::TYPE_BOXED
+          return BoxedBase
+        end
+
         StructBase
       end
     end