gir_ffi 0.6.6 → 0.6.7

data/lib/gir_ffi/builder_helper.rb

@@ -16,5 +16,12 @@ module GirFFI
       end
     end
 
+    def get_or_define_class namespace, name, parent
+      optionally_define_constant(namespace, name) { Class.new parent }
+    end
+
+    def get_or_define_module parent, name
+      optionally_define_constant(parent, name) { Module.new }
+    end
   end
 end

data/lib/gir_ffi/builders/argument_builder.rb

@@ -0,0 +1,132 @@
+require 'gir_ffi/builders/base_argument_builder'
+
+module GirFFI
+  module Builders
+    # 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? && !is_array_length_parameter?
+          @name
+        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
+        if has_output_value?
+          value = output_value
+          ["#{retname} = #{value}"]
+        else
+          []
+        end
+      end
+
+      private
+
+      def output_value
+        if is_caller_allocated_object?
+          callarg
+        else
+          base = "#{callarg}.to_value"
+          if needs_outgoing_parameter_conversion?
+            outgoing_conversion base
+          else
+            base
+          end
+        end
+      end
+
+      def is_array_length_parameter?
+        @array_arg
+      end
+
+      def needs_size_check?
+        specialized_type_tag == :c && type_info.array_fixed_size > -1
+      end
+
+      def fixed_array_size_check
+        size = type_info.array_fixed_size
+        "GirFFI::ArgHelper.check_fixed_array_size #{size}, #{@name}, \"#{@name}\""
+      end
+
+      def skipped?
+        @arginfo.skip? ||
+          @array_arg && @array_arg.specialized_type_tag == :strv
+      end
+
+      def has_output_value?
+        (@direction == :inout || @direction == :out) && !skipped?
+      end
+
+      def has_input_value?
+        (@direction == :inout || @direction == :in) && !skipped?
+      end
+
+      def array_length_assignment
+        arrname = @array_arg.name
+        "#{@name} = #{arrname}.nil? ? 0 : #{arrname}.length"
+      end
+
+      def set_function_call_argument
+        value = if skipped?
+                  @direction == :in ? "0" : "nil"
+                elsif !has_input_value?
+                  if is_caller_allocated_object?
+                    if specialized_type_tag == :array
+                      "#{argument_class_name}.new #{type_info.element_type.inspect}"
+                    else
+                      "#{argument_class_name}.new"
+                    end
+                  else
+                    "GirFFI::InOutPointer.for #{type_info.tag_or_class.inspect}"
+                  end
+                else
+                  ingoing_parameter_conversion
+                end
+        "#{callarg} = #{value}"
+      end
+
+      def is_caller_allocated_object?
+        [ :struct, :array ].include?(specialized_type_tag) &&
+          @arginfo.caller_allocates?
+      end
+
+      def ingoing_parameter_conversion
+        args = conversion_arguments @name
+
+        base = case specialized_type_tag
+               when :array, :c, :callback, :ghash, :glist, :gslist, :object, :ptr_array,
+                 :struct, :strv, :utf8, :void, :zero_terminated
+                 "#{argument_class_name}.from(#{args})"
+               else
+                 args
+               end
+
+        if has_output_value?
+          "GirFFI::InOutPointer.from #{type_info.tag_or_class.inspect}, #{base}"
+        else
+          base
+        end
+      end
+    end
+  end
+end

data/lib/gir_ffi/{base_argument_builder.rb → builders/base_argument_builder.rb}

@@ -15,6 +15,8 @@ module GirFFI
 
     attr_accessor :length_arg, :array_arg
 
+    attr_accessor :is_closure
+
     def initialize var_gen, name, typeinfo, direction
       @var_gen = var_gen
 
@@ -27,6 +29,8 @@ module GirFFI
 
       @length_arg = nil
       @array_arg = nil
+
+      @is_closure = false
     end
 
     def type_info
@@ -37,38 +41,9 @@ module GirFFI
       type_info.flattened_tag
     end
 
-    TAG_TO_WRAPPER_CLASS_MAP = {
-      :array => 'GLib::Array',
-      :byte_array => 'GLib::ByteArray',
-      :c => 'GLib::SizedArray',
-      :callback => 'GirFFI::Callback',
-      :error => 'GLib::Error',
-      :ghash => 'GLib::HashTable',
-      :glist => 'GLib::List',
-      :gslist => 'GLib::SList',
-      :ptr_array => 'GLib::PtrArray',
-      :strv => 'GLib::Strv',
-      :utf8 => 'GirFFI::InPointer',
-      :void => 'GirFFI::InPointer',
-      :zero_terminated => 'GirFFI::ZeroTerminated'
-    }
-
     # TODO: Use class rather than class name
     def argument_class_name
-      case (tag = type_info.flattened_tag)
-      when :struct, :union, :object, :interface, :enum, :flags
-        type_info.interface_type_name
-      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
+      type_info.argument_class_name
     end
 
     def array_size
@@ -111,22 +86,38 @@ module GirFFI
       []
     end
 
+    def new_variable
+      @var_gen.new_var
+    end
+
     private
 
-    def conversion_arguments name
+    def needs_outgoing_parameter_conversion?
+      [ :array, :byte_array, :c, :error, :filename, :ghash, :glist,
+        :gslist, :interface, :object, :ptr_array, :struct, :strv, :union,
+        :utf8, :zero_terminated ].include?(specialized_type_tag)
+    end
+
+    def outgoing_conversion base
+      args = output_conversion_arguments base
       case specialized_type_tag
-      when :utf8, :void
-        "#{specialized_type_tag.inspect}, #{name}"
-      when :c
-        "#{subtype_tag_or_class_name}, #{type_info.array_fixed_size}, #{name}"
-      when :array, :ghash, :glist, :gslist, :ptr_array, :zero_terminated
-        "#{elm_t}, #{name}"
-      when :callback
-        iface = type_info.interface
-        "\"#{iface.namespace}\", \"#{iface.name}\", #{name}"
+      when :utf8, :filename
+        "#{base}.to_utf8"
+      else
+        "#{argument_class_name}.wrap(#{args})"
+      end
+    end
+
+    def output_conversion_arguments arg
+      if specialized_type_tag == :c
+        "#{type_info.subtype_tag_or_class.inspect}, #{array_size}, #{arg}"
       else
-        "#{name}"
+        conversion_arguments arg
       end
     end
+
+    def conversion_arguments name
+      type_info.extra_conversion_arguments.map(&:inspect).push(name).join(", ")
+    end
   end
 end

data/lib/gir_ffi/builders/base_type_builder.rb

@@ -0,0 +1,47 @@
+require 'gir_ffi/builder_helper'
+
+module GirFFI
+
+  # Base class for type builders.
+  class BaseTypeBuilder
+    include BuilderHelper
+
+    def initialize info
+      @info = info
+      @namespace = @info.namespace
+      @classname = @info.safe_name
+    end
+
+    def build_class
+      unless defined? @klass
+        instantiate_class
+      end
+      @klass
+    end
+
+    attr_reader :info
+
+    private
+
+    def namespace_module
+      @namespace_module ||= Builder.build_module @namespace
+    end
+
+    def lib
+      @lib ||= namespace_module.const_get :Lib
+    end
+
+    def setup_constants
+      @klass.const_set :GIR_INFO, info
+      @klass.const_set :GIR_FFI_BUILDER, self
+    end
+
+    def already_set_up
+      const_defined_for @klass, :GIR_FFI_BUILDER
+    end
+
+    def gir
+      @gir ||= GObjectIntrospection::IRepository.default
+    end
+  end
+end

data/lib/gir_ffi/builders/callback_builder.rb

@@ -0,0 +1,38 @@
+require 'gir_ffi/builders/base_type_builder'
+require 'gir_ffi/builders/mapping_method_builder'
+require 'gir_ffi/callback_base'
+
+module GirFFI
+  module Builders
+    # Implements the creation of a callback type. The type will be
+    # attached to the appropriate namespace module, and will be defined
+    # as a callback for FFI.
+    class CallbackBuilder < BaseTypeBuilder
+      def instantiate_class
+        @klass ||= optionally_define_constant namespace_module, @classname do
+          cb = lib.callback callback_sym, argument_types, return_type
+          cb.instance_eval mapping_method_definition
+          cb.extend CallbackBase
+          cb
+        end
+        @klass
+      end
+
+      def mapping_method_definition
+        MappingMethodBuilder.new(info.args, info.return_type).method_definition
+      end
+
+      def callback_sym
+        @classname.to_sym
+      end
+
+      def argument_types
+        @info.argument_ffi_types
+      end
+
+      def return_type
+        @info.return_ffi_type
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/constant_builder.rb

@@ -0,0 +1,18 @@
+require 'gir_ffi/builders/base_type_builder'
+module GirFFI
+  module Builders
+    # Implements the creation of a constant. Though semantically not a
+    # type, its build method is like that of the types, in that it is
+    # triggered by a missing constant in the parent namespace.  The
+    # constant will be attached to the appropriate namespace module.
+    class ConstantBuilder < BaseTypeBuilder
+      private
+
+      def instantiate_class
+        @klass = optionally_define_constant namespace_module, @classname do
+          info.value
+        end
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/enum_builder.rb

@@ -0,0 +1,62 @@
+require 'gir_ffi/builders/registered_type_builder'
+require 'gir_ffi/builders/with_methods'
+require 'gir_ffi/enum_base'
+
+module GirFFI
+  module Builders
+    # Implements the creation of an enum or flags type. The type will be
+    # attached to the appropriate namespace module, and will be defined
+    # as an enum for FFI.
+    class EnumBuilder < RegisteredTypeBuilder
+      include WithMethods
+
+      private
+
+      def enum_sym
+        @classname.to_sym
+      end
+
+      def value_spec
+        return info.values.map {|vinfo|
+          val = GirFFI::ArgHelper.cast_uint32_to_int32(vinfo.value)
+          [vinfo.name.to_sym, val]
+        }.flatten
+      end
+
+      def instantiate_class
+        @klass = get_or_define_module namespace_module, @classname
+        @enum = optionally_define_constant @klass, :Enum do
+          lib.enum(enum_sym, value_spec)
+        end
+        unless already_set_up
+          @klass.extend superclass
+          setup_constants
+          setup_gtype_getter
+          stub_methods
+          setup_inspect
+        end
+      end
+
+      def setup_inspect
+        @klass.instance_eval <<-EOS
+          def self.inspect
+            "#{@namespace}::#{@classname}"
+          end
+        EOS
+      end
+
+      def already_set_up
+        @klass.respond_to? :get_gtype
+      end
+
+      def superclass
+        @superclass ||= EnumBase
+      end
+
+      # FIXME: Remove duplication with ModuleBuilder
+      def get_or_define_module parent, name
+        optionally_define_constant(parent, name) { ::Module.new }
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/error_argument_builder.rb

@@ -0,0 +1,18 @@
+require 'gir_ffi/builders/base_argument_builder'
+
+module GirFFI
+  module Builders
+    # 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 ErrorArgumentBuilder < BaseArgumentBuilder
+      def pre
+        [ "#{callarg} = FFI::MemoryPointer.new(:pointer).write_pointer nil" ]
+      end
+
+      def post
+        [ "GirFFI::ArgHelper.check_error(#{callarg})" ]
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/field_builder.rb

@@ -0,0 +1,94 @@
+require 'gir_ffi/builders/argument_builder'
+require 'gir_ffi/builders/return_value_builder'
+require 'gir_ffi/variable_name_generator'
+require 'gir_ffi/setter_argument_info'
+
+module GirFFI
+  module Builders
+    # Creates field getter and setter code for a given IFieldInfo.
+    class FieldBuilder
+      attr_reader :info
+
+      def initialize field_info
+        @info = field_info
+      end
+
+      def build
+        unless container_info.find_instance_method info.name
+          container_class.class_eval getter_def
+        end
+        container_class.class_eval setter_def if info.writable?
+      end
+
+      def getter_def
+        builder = return_value_builder
+
+        field_ptr = builder.new_variable
+        typed_ptr = builder.new_variable
+
+        return <<-CODE.reset_indentation
+        def #{info.name}
+          #{field_ptr} = @struct.to_ptr + #{info.offset}
+          #{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag_or_class.inspect}, #{field_ptr})
+          #{builder.callarg} = #{typed_ptr}.to_value
+          #{builder.post.join("\n")}
+          #{builder.retval}
+        end
+        CODE
+      end
+
+      def setter_def
+        builder = setter_builder
+
+        field_ptr = builder.new_variable
+        typed_ptr = builder.new_variable
+
+        return <<-CODE.reset_indentation
+        def #{info.name}= #{builder.inarg}
+          #{field_ptr} = @struct.to_ptr + #{info.offset}
+          #{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag_or_class.inspect}, #{field_ptr})
+          #{builder.pre.join("\n          ")}
+          #{typed_ptr}.set_value #{builder.callarg}
+        end
+        CODE
+      end
+
+      private
+
+      def struct_class
+        container_class::Struct
+      end
+
+      def field_type_tag_or_class
+        @field_type_tag_or_class ||= info.field_type.tag_or_class
+      end
+
+      def container_class
+        @container_class ||= container_module.const_get(container_info.safe_name)
+      end
+
+      def container_module
+        @container_module ||= Object.const_get(container_info.safe_namespace)
+      end
+
+      def container_info
+        @container_info ||= info.container
+      end
+
+      def field_symbol
+        @info.name.to_sym
+      end
+
+      def return_value_builder
+        vargen = VariableNameGenerator.new
+        @rv_builder ||= ReturnValueBuilder.new vargen, @info.field_type
+      end
+
+      def setter_builder
+        vargen = VariableNameGenerator.new
+        argument_info = SetterArgumentInfo.new "value", @info.field_type
+        ArgumentBuilder.new vargen, argument_info
+      end
+    end
+  end
+end