cplus2ruby 1.0.0

data/lib/cplus2ruby/model.rb

@@ -0,0 +1,212 @@
+require 'facets/annotations'
+require 'facets/orderedhash'
+require 'cplus2ruby/typing'
+
+class Cplus2Ruby::Property; end
+class Cplus2Ruby::Method; end
+
+class Cplus2Ruby::Model
+  attr_reader :typing
+  attr_reader :code
+  attr_reader :includes
+
+  def next_order_cnt
+    @order_cnt += 1
+  end
+
+  def initialize
+    @typing = Cplus2Ruby::Typing.new
+    @code = ""
+    @includes = []
+    @settings = default_settings()
+    @order_cnt = 0
+  end
+
+  def finish!
+    entities.each do |klass|
+      @typing.add_object_type(klass)
+    end
+  end
+
+  def entities
+    entities = []
+    ObjectSpace.each_object(Class) {|o|
+      entities << o if o.kind_of?(Cplus2Ruby::Entity)
+    }
+    entities
+  end
+
+  def entity_usage(klass, other)
+    usage_cnt = 0
+    klass.local_annotations.each do |name, opts|
+      usage_cnt += 1 if opts[:arguments] and opts[:arguments].values.include?(other)
+      usage_cnt += 1 if opts[:type] and opts[:type] == other 
+    end
+    usage_cnt
+  end
+
+  def entities_ordered
+    entities().sort {|a, b|
+      if a.ancestors.include?(b)
+        # a 'after' b (a > b)
+        1
+      elsif b.ancestors.include?(a)
+        -1
+      else
+        ea = entity_usage(a, b)
+        eb = entity_usage(b, a)
+
+        if ea > 0 and eb == 0
+          -1
+        elsif eb > 0 and ea == 0 
+          1
+        else
+          ao = (a.heritage(:__options__) || {})[:order] || 0
+          bo = (b.heritage(:__options__) || {})[:order] || 0
+          ao <=> bo
+        end
+      end
+    }
+  end
+
+  #
+  # Update or retrieve the current settings.
+  #
+  def settings(h={})
+    @settings.update(h)
+    @settings
+  end
+
+  protected
+
+  def default_settings
+    {
+      :substitute_iv_ats => true,
+      :default_body_when_nil => ''
+    }
+  end
+
+end
+
+module Cplus2Ruby
+  # 
+  # Global code
+  #
+  def self.<<(code)
+    model.code << "\n"
+    model.code << code
+    model.code << "\n"
+  end
+
+  def self.include(header)
+    model.includes << header
+  end
+
+  def self.settings(h={})
+    model.settings(h)
+  end
+
+  def self.model
+    @model ||= Cplus2Ruby::Model.new
+  end
+
+  def self.add_type_alias(h)
+    h.each {|from, to| model.typing.alias_entry(from, to)}
+  end
+
+  def self.startup(*args, &block)
+    self.model.finish!
+    Cplus2Ruby::Compiler.new(self.model).startup(*args, &block)
+  end
+
+  def self.compile(*args)
+    self.model.finish!
+    Cplus2Ruby::Compiler.new(self.model).compile(*args)
+  end
+
+end
+
+module Cplus2Ruby::Entity
+  def property(name, type=Object, options={})
+    raise ArgumentError if options[:type]
+    options[:type] = type
+    ann! name, Cplus2Ruby::Property, options
+  end
+
+  #
+  # method :name, {hash}, {hash}, ..., {hash}, body, hash 
+  #
+  def method(name, *args)
+    options = parse_method_args(args)
+    ann! name, Cplus2Ruby::Method, options 
+  end 
+
+  def static_method(name, *args)
+    options = parse_method_args(args)
+    options[:static] = true
+    ann! name, Cplus2Ruby::Method, options 
+  end
+
+  def stub_method(name, *args)
+    options = parse_method_args(args)
+    options[:stub] = true
+    ann! name, Cplus2Ruby::Method, options 
+  end
+
+  alias method_c method
+
+  def virtual(*virtuals)
+    virtuals.each do |name|
+      ann! name, :virtual => true
+    end
+  end
+
+  protected
+
+  def parse_method_args(args)
+    params = OrderedHash.new
+    body = nil
+    options = {}
+
+    state = :want_param
+
+    while not args.empty?
+      arg = args.shift
+
+      case state
+      when :want_param
+        if arg.is_a?(Hash)
+          params.update(arg)
+        else
+          args.unshift(arg)
+          state = :want_body
+        end
+      when :want_body
+        body = arg
+        state = :want_options
+      when :want_options
+        raise unless arg.is_a?(Hash)
+        raise unless args.empty?
+        options = arg
+      else
+        raise
+      end
+    end
+
+    options[:body] ||= body 
+    options[:arguments] ||= params
+
+    return options
+  end
+
+
+end
+
+class Module
+  def cplus2ruby(hash={})
+    include Cplus2Ruby::Entity
+    extend Cplus2Ruby::Entity
+    ann! :__options__, hash 
+    ann! :__options__, :order => Cplus2Ruby.model.next_order_cnt if hash[:order].nil?
+  end
+end

data/lib/cplus2ruby/typing.rb

@@ -0,0 +1,152 @@
+class Cplus2Ruby::Typing
+  require 'facets/orderedhash'
+
+  attr_reader :aliases
+
+  def initialize
+    @map = default_map() 
+    @aliases = OrderedHash.new
+    clone_entry Object, 'VALUE'
+  end
+
+  def add_entry(type, entry)
+    type = to_key(type)
+    raise if @map.include?(type)
+    @map[type] = entry
+  end
+
+  def clone_entry(from, to)
+    from = to_key(from)
+    to = to_key(to)
+    raise if @map.include?(from)
+    @map[from] = @map[to] # FIXME: .dup?
+  end
+
+  #
+  # Add a type alias. Also modifies type map.
+  #
+  def alias_entry(from, to)
+    from = to_key(from)
+    to = to_key(to)
+    @aliases[from] = to
+    clone_entry(from, to)
+  end
+
+  def get_entry(type)
+    @map[to_key(type)]
+  end
+
+  #
+  # Looks up first in the annotation options, then 
+  # in the type options.
+  #
+  def lookup_entry(attribute, options, type)
+    (get_entry(type) || {}).dup.update(options)[attribute]
+  end
+
+  # 
+  # Returns a C++ declaration
+  #
+  def var_decl(type, name)
+    if entry = get_entry(type)
+      entry[:ctype].gsub("%s", name.to_s)
+    # FIXME type.to_s
+    elsif type.to_s.include?("%s")
+      type.gsub("%s", name.to_s)
+    else
+      "#{type} #{name}"
+    end
+  end
+
+  def var_assgn(name, value)
+    raise ArgumentError if value.nil?
+    if value.is_a?(String) and value.include?('%s')
+      value.gsub('%s', name)
+    else
+      "#{name} = #{value}"
+    end
+  end
+
+  # 
+  # Returns true if Ruby <-> C conversion for this type is possible
+  #
+  def can_convert?(type)
+    get_entry(type) ? true : false
+  end
+
+  def convert(type, var, kind)
+    (get_entry(type)[kind] || "").gsub('%s', var.to_s)
+  end
+
+  def add_object_type(klass)
+    add_entry(klass, object_type(klass.name))
+  end
+
+  protected
+
+  def to_key(type)
+    if type.is_a?(Symbol)
+      type.to_s
+    else
+      type
+    end
+  end
+
+  def object_type(type)
+    {
+      :init   => "NULL",
+      :mark   => "if (%s) rb_gc_mark(%s->__obj__)",
+      :ruby2c => "(NIL_P(%s) ? NULL : (#{type}*)DATA_PTR(%s))",
+      :c2ruby => "(%s ? %s->__obj__ : Qnil)", 
+      :ctype  => "#{type} *%s",
+      :ruby2c_checktype => "if (!NIL_P(%s)) Check_Type(%s, T_DATA)"
+    }
+  end
+
+  def default_map
+    { 
+      'VALUE' => {
+        :init   => 'Qnil',
+        :mark   => 'rb_gc_mark(%s)',
+        :ruby2c => '%s',
+        :c2ruby => '%s',
+        :ctype  => 'VALUE %s' 
+      },
+      'float' => {
+        :init   => 0.0,
+        :ruby2c => '(float)NUM2DBL(%s)',
+        :c2ruby => 'rb_float_new((double)%s)',
+        :ctype  => 'float %s'
+      },
+      'double' => {
+        :init   => 0.0,
+        :ruby2c => '(double)NUM2DBL(%s)',
+        :c2ruby => 'rb_float_new(%s)',
+        :ctype  => 'double %s'
+      },
+      'int' => {
+        :init   => 0,
+        :ruby2c => '(int)NUM2INT(%s)',
+        :c2ruby => 'INT2NUM(%s)',
+        :ctype  => 'int %s'
+      },
+      'unsigned int' => {
+        :init   => 0,
+        :ruby2c => '(unsigned int)NUM2INT(%s)',
+        :c2ruby => 'INT2NUM(%s)',
+        :ctype  => 'unsigned int %s'
+      },
+      'bool' => { 
+        :init   => false,
+        :ruby2c => '(RTEST(%s) ? true : false)',
+        :c2ruby => '(%s ? Qtrue : Qfalse)',
+        :ctype  => 'bool %s'
+      },
+      'void' => {
+        :c2ruby => 'Qnil',
+        :ctype  => 'void'
+      }
+    }
+  end
+
+end

data/lib/cplus2ruby/wrapper_code_generator.rb

@@ -0,0 +1,165 @@
+require 'cplus2ruby/code_generator'
+
+class Cplus2Ruby::WrapperCodeGenerator < Cplus2Ruby::CodeGenerator
+  def gen_allocator(klass)
+    %[
+      static VALUE
+      #{klass.name}_alloc__(VALUE klass)
+      {
+        #{klass.name} *__cobj__;
+        __cobj__ = new #{klass.name}();
+        __cobj__->__obj__ = Data_Wrap_Struct(klass, RubyObject::__mark, RubyObject::__free, __cobj__);
+        return __cobj__->__obj__;
+      }
+    ]
+  end
+
+  def gen_method_wrapper(klass, name, options)
+    gen_wrapper(klass, name, options, :wrap)
+  end
+
+  def gen_property_getter(klass, name, options)
+    opts = options.dup
+    opts[:arguments] = {:returns => options[:type]}
+    gen_wrapper(klass, name, opts, :get)
+  end
+
+  def gen_property_setter(klass, name, options)
+    opts = options.dup
+    opts[:arguments] = {:__val__ => options[:type]}
+    gen_wrapper(klass, name, opts, :set)
+  end
+
+  def gen_property_accessor(klass, name, options)
+    [gen_property_getter(klass, name, options),
+     gen_property_setter(klass, name, options)].join
+  end
+
+  #
+  # kind is one of :set, :get, :wrap
+  #
+  def gen_wrapper(klass, name, options, kind)
+    args = options[:arguments].dup
+    return nil if options[:stub]
+    unless args_convertable?(args)
+      STDERR.puts "WARN: cannot wrap method #{klass.name}::#{name} (#{kind})"
+      return nil
+    end
+
+    returns = args.delete(:returns) || "void"
+
+    s = ([["__self__", "VALUE"]] + args.to_a).map {|n,_| "VALUE #{n}"}.join(", ")
+
+    out = ""
+    out << "static VALUE\n"
+    out << "#{klass.name}_#{kind}__#{name}(#{s})\n"
+    out << "{\n"
+
+    # declare C++ return value
+    if returns != 'void'
+      out << @model.typing.var_decl(returns, '__res__') + ";\n"
+    end
+    
+    # declare C++ object reference
+    out << "#{klass.name} *__cobj__;\n"
+    #out << @model.var_decl(klass, '__cobj__') + ";\n"
+
+    # convert __self__ to C++ object reference (FIXME: can remove?)
+    out << "Check_Type(__self__, T_DATA);\n"
+    out << "__cobj__ = (#{klass.name}*) DATA_PTR(__self__);\n"
+
+    # check argument types
+    out << args.map {|n, t| @model.typing.convert(t, n.to_s, :ruby2c_checktype) + ";\n" }.join
+
+    # call arguments
+    call_args = args.map {|n, t| @model.typing.convert(t, n.to_s, :ruby2c)}
+
+    # build method call
+    out << "__res__ = " if returns != 'void'
+    case kind
+    when :wrap
+      out << "__cobj__->#{name}(#{call_args.join(', ')});\n"
+    when :get
+      out << "__cobj__->#{name};\n"
+    when :set
+      raise ArgumentError if call_args.size != 1
+      out << "__cobj__->#{name} = #{call_args.first};\n"
+    else
+      raise ArgumentError
+    end
+
+    # convert return value
+    retval = @model.typing.convert(returns, '__res__', :c2ruby)
+
+    out << "return #{retval};\n"
+    out << "}\n"
+
+    return out
+  end
+
+  def gen_init(mod_name)
+    out = ""
+    out << %[extern "C" void Init_#{mod_name}()\n]
+    out << "{\n"
+    out << "  VALUE klass;\n"
+
+    @model.entities_ordered.each do |klass| 
+      next if no_wrap?(klass)
+      n = klass.name
+      out << %{  klass = rb_eval_string("#{n}");\n}
+      out << %{  rb_define_alloc_func(klass, #{n}_alloc__);\n}
+
+      all_methods_of(klass) do |name, options|
+        args = options[:arguments]
+        next unless args_convertable?(args)
+        next if options[:stub]
+        out << %{  rb_define_method(klass, "#{name}", } 
+        out << %{(VALUE(*)(...))#{n}_wrap__#{name}, #{arity(args)});\n}
+      end
+
+      all_properties_of(klass) do |name, options|
+        next unless @model.typing.can_convert?(options[:type])
+
+        # getter
+        out << %{  rb_define_method(klass, "#{name}", } 
+        out << %{(VALUE(*)(...))#{n}_get__#{name}, 0);\n}
+
+        # setter
+        out << %{rb_define_method(klass, "#{name}=", } 
+        out << %{(VALUE(*)(...))#{n}_set__#{name}, 1);\n}
+      end
+    end
+
+    out << "}\n"
+
+    return out
+  end
+
+  def gen_wrapper_file(mod_name)
+    out = ""
+    out << %{#include "#{mod_name}.h"\n\n}
+
+    @model.entities_ordered.each do |klass| 
+      next if no_wrap?(klass)
+
+      out << gen_allocator(klass)
+
+      all_methods_of(klass) do |name, options|
+        out << (gen_method_wrapper(klass, name, options) || "")
+      end
+
+      all_properties_of(klass) do |name, options|
+        out << gen_property_accessor(klass, name, options)
+      end
+    end
+
+    out << gen_init(mod_name)
+
+    return out
+  end
+
+  def write_files(mod_name)
+    write_out(mod_name + "_wrap.cc", gen_wrapper_file(mod_name))
+  end
+
+end

data/lib/cplus2ruby.rb

@@ -0,0 +1,30 @@
+module Cplus2Ruby; end
+
+require 'cplus2ruby/model'
+require 'cplus2ruby/compiler'
+
+#
+# Extend facets/annotations
+#
+class Module
+  def recursive_annotations
+    res = {}
+    ancestors.reverse.each { |ancestor|
+      ancestor.annotations.each { |ref, hash|
+        res[ref] ||= {}
+        res[ref].update(hash) if hash
+      }
+    }
+    res
+  end
+
+  def local_annotations
+    new_keys = recursive_annotations().keys - self.superclass.recursive_annotations().keys
+    all_keys = new_keys + annotations().keys
+    h = {}
+    all_keys.each do |key|
+      h[key] = heritage(key)
+    end
+    h
+  end
+end

data/test/test_mixin.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+$LOAD_PATH.unshift '../src'
+require 'cplus2ruby'
+
+module Mixin1; cplus2ruby
+  property :a, :int
+end
+
+class A; cplus2ruby
+  property :y, :int
+end
+
+class B < A; cplus2ruby
+  include Mixin1
+end
+
+class C < B; cplus2ruby
+  property :z, :int
+end
+
+Cplus2Ruby.startup('work/test_mixin', true)
+t = B.new
+t.y = 2
+p t.y
+
+t = C.new
+t.z = 343333
+p t.z
+p t.y