gir_ffi 0.0.1

data/lib/gir_ffi.rb

@@ -0,0 +1,47 @@
+
+module GirFFI
+
+  # :stopdoc:
+  VERSION = '0.0.1'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+end
+
+require 'gir_ffi/i_repository'
+require 'gir_ffi/builder'
+
+module GirFFI
+  def self.setup module_name
+    module_name = module_name.to_s
+    GirFFI::Builder.build_module module_name
+    begin
+      require "gir_ffi/overrides/#{module_name.downcase}"
+    rescue LoadError
+    end
+  end
+end
+# EOF

data/lib/gir_ffi/allocation_helper.rb

@@ -0,0 +1,12 @@
+require 'gir_ffi/lib_c'
+
+module GirFFI
+  module AllocationHelper
+    def self.safe_malloc size
+      ptr = LibC.malloc size
+      raise NoMemoryError if ptr.null?
+      ptr
+    end
+  end
+end
+

data/lib/gir_ffi/arg_helper.rb

@@ -0,0 +1,77 @@
+require 'gir_ffi/allocation_helper'
+
+module GirFFI
+  module ArgHelper
+    def self.object_to_inptr obj
+      return obj.to_ptr if obj.respond_to? :to_ptr
+      return nil if obj.nil?
+      FFI::Pointer.new(obj.object_id)
+    end
+
+    def self.int_to_inoutptr val
+      ptr = AllocationHelper.safe_malloc FFI.type_size(:int)
+      ptr.write_int val
+      return ptr
+    end
+
+    def self.string_array_to_inoutptr ary
+      return nil if ary.nil?
+
+      ptrs = ary.map {|str|
+	len = str.bytesize
+	AllocationHelper.safe_malloc(len + 1).write_string(str).put_char(len, 0)
+      }
+
+      block = AllocationHelper.safe_malloc FFI.type_size(:pointer) * ptrs.length
+      block.write_array_of_pointer ptrs
+
+      argv = AllocationHelper.safe_malloc FFI.type_size(:pointer)
+      argv.write_pointer block
+      argv
+    end
+
+    # Converts an outptr to an int, then frees the outptr.
+    def self.outptr_to_int ptr
+      value = ptr.read_int
+      LibC.free ptr
+      value
+    end
+
+    # Converts an outptr to a string array, then frees the outptr.
+    def self.outptr_to_string_array ptr, size
+      return nil if ptr.nil?
+
+      block = ptr.read_pointer
+      LibC.free ptr
+
+      return nil if block.null?
+
+      ptrs = block.read_array_of_pointer(size)
+      LibC.free block
+
+      ptrs.map { |p| p.null? ? nil : (str = p.read_string; LibC.free p; str) }
+    end
+
+    def self.mapped_callback_args prc=nil, &block
+      return prc if FFI::Function === prc
+      if prc.nil?
+	return nil if block.nil?
+	prc = block
+      end
+      return Proc.new do |*args|
+	mapped = args.map {|arg|
+	  if FFI::Pointer === arg
+	    begin
+	      ObjectSpace._id2ref arg.address
+	    rescue RangeError
+	      arg
+	    end
+	  else
+	    arg
+	  end
+	}
+	prc.call(*mapped)
+      end
+    end
+  end
+end

data/lib/gir_ffi/base.rb

@@ -0,0 +1,23 @@
+require 'forwardable'
+module GirFFI
+  class Base
+    extend Forwardable
+    def_delegators :@struct, :[], :[]=, :to_ptr
+
+    def initialize(ptr=nil)
+      @struct = ptr.nil? ?
+	self.ffi_structure.new :
+	self.ffi_structure.new(ptr)
+    end
+
+    def ffi_structure
+      self.class.ffi_structure
+    end
+
+    class << self
+      def ffi_structure
+	self.const_get(:Struct)
+      end
+    end
+  end
+end

data/lib/gir_ffi/builder.rb

@@ -0,0 +1,159 @@
+require 'gir_ffi/class_base'
+require 'gir_ffi/arg_helper'
+require 'gir_ffi/function_definition_builder'
+require 'gir_ffi/constructor_definition_builder'
+require 'gir_ffi/method_missing_definition_builder'
+require 'gir_ffi/base'
+require 'gir_ffi/class_builder'
+require 'gir_ffi/module_builder'
+require 'gir_ffi/builder_helper'
+
+module GirFFI
+  # Builds modules and classes based on information found in the
+  # introspection repository. Call its build_module and build_class methods
+  # to create the modules and classes used in your program.
+  module Builder
+    def self.build_class namespace, classname, box=nil
+      ClassBuilder.new(namespace, classname, box).generate
+    end
+
+    def self.build_module namespace, box=nil
+      ModuleBuilder.new(namespace, box).generate
+    end
+
+    # TODO: Make better interface
+    def self.setup_method namespace, classname, lib, modul, klass, method
+      go = method_introspection_data namespace, classname, method.to_s
+
+      setup_function_or_method klass, modul, lib, go
+    end
+
+    # TODO: Make better interface
+    def self.setup_function namespace, lib, modul, method
+      go = function_introspection_data namespace, method.to_s
+
+      setup_function_or_method modul, modul, lib, go
+    end
+
+    # All methods below will be made private at the end.
+ 
+    def self.function_definition info, libmodule
+      if info.constructor?
+	fdbuilder = ConstructorDefinitionBuilder.new info, libmodule
+      else
+	fdbuilder = FunctionDefinitionBuilder.new info, libmodule
+      end
+      fdbuilder.generate
+    end
+
+    def self.function_introspection_data namespace, function
+      gir = IRepository.default
+      return gir.find_by_name namespace, function.to_s
+    end
+
+    def self.method_introspection_data namespace, object, method
+      gir = IRepository.default
+      objectinfo = gir.find_by_name namespace, object.to_s
+      return objectinfo.find_method method
+    end
+
+    def self.attach_ffi_function modul, lib, info, box
+      sym = info.symbol
+      argtypes = ffi_function_argument_types modul, lib, info, box
+      rt = ffi_function_return_type modul, lib, info, box
+
+      lib.attach_function sym, argtypes, rt
+    end
+
+    def self.ffi_function_argument_types modul, lib, info, box
+      types = info.args.map do |a|
+	iarginfo_to_ffitype modul, lib, a, box
+      end
+      if info.type == :function
+	types.unshift :pointer if info.method?
+      end
+      types
+    end
+
+    def self.ffi_function_return_type modul, lib, info, box
+      itypeinfo_to_ffitype modul, lib, info.return_type, box
+    end
+
+    def self.define_ffi_types modul, lib, info, box
+      info.args.each do |arg|
+	type = iarginfo_to_ffitype modul, lib, arg, box
+      end
+    end
+
+    def self.itypeinfo_to_ffitype modul, lib, info, box
+      if info.pointer?
+	return :string if info.tag == :utf8
+	return :pointer
+      end
+      case info.tag
+      when :interface
+	interface = info.interface
+	case interface.type
+	when :object, :struct, :flags, :enum
+	  return build_class interface.namespace, interface.name, box
+	when :callback
+	  return build_callback modul, lib, interface, box
+	else
+	  raise NotImplementedError
+	end
+      when :boolean
+	return :bool
+      else
+	return info.tag
+      end
+    end
+
+    def self.iarginfo_to_ffitype modul, lib, info, box
+      return :pointer if info.direction == :inout
+      return itypeinfo_to_ffitype modul, lib, info.type, box
+    end
+
+    def self.build_callback modul, lib, interface, box
+      sym = interface.name.to_sym
+
+      # FIXME: Rescue is ugly here.
+      ft = lib.find_type sym rescue nil
+      if ft.nil?
+	args = ffi_function_argument_types modul, lib, interface, box
+	ret = ffi_function_return_type modul, lib, interface, box
+	lib.callback sym, args, ret
+      end
+      sym
+    end
+
+    def self.setup_function_or_method klass, modul, lib, go
+      return false if go.nil?
+      return false if go.type != :function
+
+      box = get_box modul
+
+      define_ffi_types modul, lib, go, box
+      attach_ffi_function modul, lib, go, box
+
+      (class << klass; self; end).class_eval function_definition(go, lib)
+      true
+    end
+
+    # TODO: This is a weird way to get back the box.
+    def self.get_box modul
+      name = modul.to_s
+      if name =~ /::/
+	return Kernel.const_get(name.split('::')[0])
+      else
+	return nil
+      end
+    end
+
+    # Set up method access.
+    (self.public_methods - Module.public_methods).each do |m|
+      private_class_method m.to_sym
+    end
+    public_class_method :build_module, :build_class, :setup_method, :setup_function, :setup_function_or_method
+    public_class_method :itypeinfo_to_ffitype
+  end
+end

data/lib/gir_ffi/builder_helper.rb

@@ -0,0 +1,32 @@
+module GirFFI
+  module BuilderHelper
+    def self.const_defined_for parent, name
+      if RUBY_VERSION < "1.9"
+	parent.const_defined? name
+      else
+	parent.const_defined? name, false
+      end
+    end
+
+    def self.optionally_define_constant parent, name
+      unless const_defined_for parent, name
+	parent.const_set name, yield
+      end
+      parent.const_get name
+    end
+
+    def self.get_or_define_module parent, name
+      optionally_define_constant(parent, name) { Module.new }
+    end
+
+    def self.get_or_define_class namespace, name, parent
+      BuilderHelper.optionally_define_constant namespace, name do
+	if parent.nil?
+	  klass = Class.new
+	else
+	  klass = Class.new parent
+	end
+      end
+    end
+  end
+end

data/lib/gir_ffi/class_base.rb

@@ -0,0 +1,11 @@
+module GirFFI
+  # Provides methods needed by all generated classes
+  module ClassBase
+    def initialize ptr
+      @gobj = ptr
+    end
+    def to_ptr
+      @gobj
+    end
+  end
+end

data/lib/gir_ffi/class_builder.rb

@@ -0,0 +1,116 @@
+module GirFFI
+  # Builds a class based on information found in the introspection
+  # repository.
+  class ClassBuilder
+    def initialize namespace, classname, box
+      @namespace = namespace
+      @classname = classname
+      @box = box
+    end
+
+    def generate
+      build_class
+    end
+
+    private
+
+    def build_class
+      get_gir_info
+      instantiate_module
+      case @info.type
+	when :object, :struct
+	  instantiate_class
+	  setup_class unless already_set_up
+	when :enum, :flags
+	  @klass = BuilderHelper.optionally_define_constant @module, @classname do
+	    vals = @info.values.map {|v| [v.name.to_sym, v.value]}.flatten
+	    @lib.enum(@classname.to_sym, vals)
+	  end
+      end
+      @klass
+    end
+
+    def get_gir_info
+      gir = IRepository.default
+      gir.require @namespace, nil
+
+      @info = gir.find_by_name @namespace, @classname
+      raise "Class #{@classname} not found in namespace #{@namespace}" if @info.nil?
+    end
+
+    def get_superclass
+      @parent = @info.type == :object ? @info.parent : nil
+      if @parent
+	@superclass = Builder.build_class @parent.namespace, @parent.name, @box
+      else
+	@superclass = GirFFI::Base
+      end
+    end
+
+    def instantiate_module
+      @module = Builder.build_module @namespace, @box
+      @lib = @module.const_get :Lib
+    end
+
+    def instantiate_class
+      get_superclass
+      @klass = BuilderHelper.get_or_define_class @module, @classname, @superclass
+      @structklass = BuilderHelper.get_or_define_class @klass, :Struct, FFI::Struct
+    end
+
+    def setup_class
+      setup_method_missing
+      setup_base
+      setup_layout
+      setup_constructor
+    end
+
+    def setup_base
+      return if @parent
+      class << @klass
+	self.class_eval { alias_method :_real_new, :new }
+      end
+    end
+
+    def setup_constructor
+      ctor = @info.find_method 'new'
+      if not ctor.nil? and ctor.constructor?
+	Builder.setup_function_or_method @klass, @module, @lib, ctor
+      end
+    end
+
+    def setup_method_missing
+      @klass.class_eval instance_method_missing_definition
+      @klass.class_eval class_method_missing_definition
+    end
+
+    def setup_layout
+      layoutspec = []
+      @info.fields.each do |f|
+	layoutspec << f.name.to_sym
+
+	ffitype = Builder.itypeinfo_to_ffitype @module, @lib, f.type, @box
+	if ffitype.kind_of?(Class) and BuilderHelper.const_defined_for ffitype, :Struct
+	  ffitype = ffitype.const_get :Struct
+	end
+
+	layoutspec << ffitype
+
+	layoutspec << f.offset
+      end
+      @structklass.class_eval { layout(*layoutspec) }
+    end
+
+    def instance_method_missing_definition
+      InstanceMethodMissingDefinitionBuilder.new(@lib, @module, @namespace, @classname).generate
+    end
+
+    def class_method_missing_definition
+      ClassMethodMissingDefinitionBuilder.new(@lib, @module, @namespace, @classname).generate
+    end
+
+    def already_set_up
+      @klass.instance_methods(false).map(&:to_sym).include? :method_missing
+    end
+  end
+end