ruby2c 1.0.0.6

data/lib/ruby_to_ruby_c.rb

@@ -0,0 +1,382 @@
+
+$TESTING = false unless defined? $TESTING
+
+begin require 'rubygems'; rescue LoadError; end
+require 'ruby_to_ansi_c'
+
+class RubyToRubyC < RubyToAnsiC
+
+  ##
+  # Lazy initializer for the composite RubytoC translator chain.
+
+  def self.translator
+    # TODO: FIX, but write a test first
+    unless defined? @translator then
+      @translator = CompositeSexpProcessor.new
+      @translator << Rewriter.new
+      @translator << TypeChecker.new
+      @translator << CRewriter.new
+      @translator << RubyToRubyC.new
+      @translator.on_error_in(:defn) do |processor, exp, err|
+        result = processor.expected.new
+        case result
+        when Array then
+          result << :error
+        end
+        msg = "// ERROR: #{err.class}: #{err}"
+        msg += " in #{exp.inspect}" unless exp.nil? or $TESTING
+        msg += " from #{caller.join(', ')}" unless $TESTING
+        result << msg
+        result
+      end
+    end
+    @translator
+  end
+
+  def self.c_type(x)
+    "VALUE"
+  end
+
+  def initialize
+    super
+
+    self.unsupported -= [:dstr, :dxstr, :xstr]
+
+    @c_klass_name = nil
+    @current_klass = nil
+    @klass_name = nil
+    @methods = {}
+  end
+
+  def process_call(exp)
+    receiver = process(exp.shift) || "self"
+    name = exp.shift.to_s
+    arg_count = exp.first.size - 1 rescue 0
+    args = process(exp.shift) # TODO: we never ever test multiple arguments!
+
+    # TODO: eric is a big boner
+    return "NIL_P(#{receiver})" if name == "nil?"
+
+    name = '===' if name =~ /^case_equal_/ # undo the evils of TypeChecker
+
+    if args.empty? || args == "rb_ary_new()" then # HACK
+      args = "0"
+    else
+      args = "#{arg_count}, #{args}"
+    end
+
+    "rb_funcall(#{receiver}, rb_intern(#{name.inspect}), #{args})"
+  end
+
+  # TODO: pull process_const from obfuscator
+  # TODO: pull process_colon2 from obfuscator
+  # TODO: pull process_cvar from obfuscator
+  # TODO: pull process_dasgn_curr from obfuscator
+
+  ##
+  # Function definition
+
+  def process_defn(exp)
+    make_function exp
+  end
+
+  def process_defx(exp)
+    make_function exp, false
+  end
+
+  ##
+  # String interpolation
+
+  def process_dstr(exp)
+    parts = []
+    parts << process(s(:str, exp.shift))
+    until exp.empty? do
+      parts << process(exp.shift)
+    end
+
+    pattern = process(s(:str, "%s" * parts.length))
+    parts.unshift pattern
+                     
+    return %{rb_funcall(rb_mKernel, rb_intern("sprintf"), #{parts.length}, #{parts.join(", ")})}
+  end
+
+  ##
+  # Backtick interpolation.
+
+  def process_dxstr(exp)
+    dstr = process_dstr exp
+    return "rb_funcall(rb_mKernel, rb_intern(\"`\"), 1, #{dstr})"
+  end
+
+  ##
+  # False. Pretty straightforward.
+
+  def process_false(exp)
+    "Qfalse"
+  end
+
+  # TODO: pull up process_gasgn from obfuscator
+
+  ##
+  # Global variables, evil but necessary.
+
+  def process_gvar(exp)
+    var = exp.shift
+    "rb_gv_get(#{var.to_s.inspect})"
+  end
+
+  # TODO: pull hash from obfuscator
+  # TODO: pull iasgn from obfuscator
+  # TODO: pull ivar from obfuscator
+
+  ##
+  # Iterators for loops. After rewriter nearly all iter nodes
+  # should be able to be interpreted as a for loop. If not, then you
+  # are doing something not supported by C in the first place.
+
+  def process_OLD_iter(exp) # TODO/REFACTOR: audit against obfuscator
+    out = []
+    # Only support enums in C-land
+    raise UnsupportedNodeError if exp[0][1].nil? # HACK ugly
+    @env.scope do
+      enum = exp[0][1][1] # HACK ugly t(:iter, t(:call, lhs <-- get lhs
+      call = process exp.shift
+      var  = process(exp.shift).intern # semi-HACK-y
+      body = process exp.shift
+      index = "index_#{var}"
+
+      body += ";" unless body =~ /[;}]\Z/
+      body.gsub!(/\n\n+/, "\n")
+
+      out << "unsigned long #{index};"
+      out << "unsigned long arrays_max = FIX2LONG(rb_funcall(arrays, rb_intern(\"size\"), 0));"
+      out << "for (#{index} = 0; #{index} < arrays_max; ++#{index}) {"
+      out << "VALUE x = rb_funcall(arrays, rb_intern(\"at\"), 1, LONG2FIX(index_x));"
+      out << body
+      out << "}"
+    end
+
+    return out.join("\n")
+  end
+
+  ##
+  # Iterators for loops. After rewriter nearly all iter nodes
+  # should be able to be interpreted as a for loop. If not, then you
+  # are doing something not supported by C in the first place.
+  #--
+  # TODO have CRewriter handle generating lasgns for statics
+
+  def process_iter(exp)
+    call = exp.shift
+    args = exp.shift
+    block_method = exp.shift
+
+    iterable = process call[1] # t(:call, lhs, :iterable, rhs)
+
+    # t(:args, t(:array, of frees), t(:array, of statics))
+    free_arg_exps = args[1]
+    static_arg_exps = args[2]
+    free_arg_exps.shift # :array
+    static_arg_exps.shift # :array
+
+    free_args = free_arg_exps.zip(static_arg_exps).map { |f,s| [process(f), process(s)] }
+
+    out = []
+
+    # save
+    out.push(*free_args.map { |free,static| "#{static} = #{free};" })
+
+    out << "rb_iterate(rb_each, #{iterable}, #{block_method}, Qnil);"
+
+    # restore
+    free_args.each do |free, static|
+      out << "#{free} = #{static};"
+      statics << "static VALUE #{static};"
+    end
+
+    return out.join("\n")
+  end
+
+  ##
+  # Assignment to a local variable.
+  #
+  # TODO: figure out array issues and clean up.
+
+  def process_lasgn(exp) # TODO: audit against obfuscator
+    out = ""
+
+    var = exp.shift
+    value = exp.shift
+    # grab the size of the args, if any, before process converts to a string
+    arg_count = 0
+    arg_count = value.length - 1 if value.first == :array
+    args = value
+
+    exp_type = exp.sexp_type
+    @env.add var.to_sym, exp_type
+    var_type = self.class.c_type exp_type
+
+    if exp_type.list? then
+      assert_type args, :array
+
+      raise "array must be of one type" unless args.sexp_type == Type.homo
+
+      args.shift # :arglist
+      # REFACTOR: this (here down) is the only diff w/ super
+      out << "#{var} = rb_ary_new2(#{args.length});\n"
+      args.each_with_index do |o,i|
+        out << "rb_ary_store(#{var}, #{i}, #{process o});\n"
+      end
+    else
+      out << "#{var} = #{process args}"
+    end
+
+    out.sub!(/;\n\Z/, '')
+
+    return out
+  end
+
+  ##
+  # Literals, numbers for the most part. Will probably cause
+  # compilation errors if you try to translate bignums and other
+  # values that don't have analogs in the C world. Sensing a pattern?
+
+  def process_lit(exp)
+    # TODO: audit against obfuscator
+    value = exp.shift
+    case value
+    when Integer then
+      return "LONG2NUM(#{value})"
+    when Float then
+      return "rb_float_new(#{value})"
+    when Symbol
+      return "ID2SYM(rb_intern(#{value.to_s.inspect}))"
+    when Range
+      f = process_lit [ value.first ]
+      l = process_lit [ value.last ]
+      x = 0
+      x = 1 if value.exclude_end?
+
+      return "rb_range_new(#{f}, #{l}, #{x})"
+    when Regexp
+      src = value.source
+      return "rb_reg_new(#{src.inspect}, #{src.size}, #{value.options})"
+    else
+      raise "Bug! no: Unknown literal #{value}:#{value.class}"
+    end
+    return nil
+  end
+
+  # TODO: pull match/2/3 from obfuscator
+  # TODO: pull next from obfuscator (and modify for iters)
+
+  # TODO: process_not?!? wtf? I don't think the ansi not works
+
+  ##
+  # Nil, currently ruby nil, not C NULL (0).
+
+  def process_nil(exp)
+    return "Qnil"
+  end
+
+  ##
+  # Strings. woot.
+
+  def process_str(exp)
+    return "rb_str_new2(#{exp.shift.inspect})"
+  end
+
+  ##
+  # Truth... what is truth? In this case, Qtrue.
+
+  def process_true(exp)
+    "Qtrue"
+  end
+
+  ##
+  # Backtick.  Maps directly to Kernel#`, no overriding.
+
+  def process_xstr(exp)
+    command = exp.shift
+    return "rb_funcall(rb_mKernel, rb_intern(\"`\"), 1, rb_str_new2(#{command.inspect}))"
+  end
+
+  # TODO: pull while from obfuscator
+  # TODO: pull zsuper from obfuscator
+
+  ##
+  # Makes a new function from +exp+.  Registers the function in the method
+  # list and adds self to the signature when +register+ is true.
+
+  def make_function(exp, register = true)
+    name = map_name exp.shift
+    args = exp.shift
+    ruby_args = args.deep_clone
+    ruby_args.shift # :args
+
+    @method_name = name
+    @c_method_name = "rrc_c#{@c_klass_name}_#{normal_to_C name}"
+
+    @env.scope do
+      c_args = check_args args, register # registered methods get self
+      @methods[name] = ruby_args if register
+
+      body = process exp.shift
+
+      if name == :initialize then
+        body[-1] = "return self;\n}"
+      end
+
+      return "static VALUE\n#{@c_method_name}#{c_args} #{body}"
+    end
+  end
+
+  ##
+  # Checks +args+ for unsupported variable types.  Adds self when +add_self+
+  # is true.
+
+  def check_args(args, add_self = true)
+    c_args = process args
+
+# HACK
+#     c_args.each do |arg|
+#       raise UnsupportedNodeError,
+#       "'#{arg}' is not a supported variable type" if arg.to_s =~ /^\*/
+#     end
+
+    if add_self then
+      if c_args == '()' then
+        c_args = '(VALUE self)'
+      else
+        c_args.sub! '(', '(VALUE self, '
+      end
+    end
+
+    return c_args
+  end
+
+  ##
+  # HACK merge with normal_to_C (?)
+
+  def map_name(name)
+    # HACK: get from zentest
+    name = METHOD_MAP[name] if METHOD_MAP.has_key? name
+    name.to_s.sub(/(.*)\?$/, 'is_\1').intern
+  end
+
+  ##
+  # DOC
+  # TODO:  get mappings from zentest
+
+  def normal_to_C(name)
+    name = name.to_s.dup
+
+    name.sub!(/==$/, '_equals2')
+    name.sub!(/=$/, '_equals')
+    name.sub!(/\?$/, '_p')
+    name.sub!(/\!$/, '_bang')
+
+    return name
+  end
+
+end

data/lib/type.rb

@@ -0,0 +1,148 @@
+
+require 'handle'
+require 'function_type'
+
+class Type
+
+  # REFACTOR: nuke this
+  KNOWN_TYPES = {
+    :bool         => "Bool",
+    :bool_list    => "Bool list",
+    :const        => "Const",
+    :file         => "File",
+    :float        => "Float",
+    :float_list   => "Float list",
+    :function     => "Function",
+    :long         => "Integer",
+    :long_list    => "Integer list",
+    :range        => "Range",
+    :regexp       => "Regular Expression",
+    :str          => "String",
+    :str_list     => "String list",
+    :symbol       => "Symbol",
+    :value        => "Value",
+    :value_list   => "Value list",
+    :void         => "Void",
+    :zclass       => "Class",
+
+    :fucked       => "Untranslatable type",
+    :hetero       => "Heterogenous",
+    :homo         => "Homogenous",
+    :unknown      => "Unknown",
+    :unknown_list => "Unknown list",
+  }
+
+  TYPES = {}
+
+  def self.function lhs_type, arg_types, return_type = nil
+    unless return_type then
+      $stderr.puts "\nWARNING: adding Type.unknown for #{caller[0]}" if $DEBUG
+      # TODO: gross, maybe go back to the *args version from method_missing
+      return_type = arg_types
+      arg_types = lhs_type
+      lhs_type = Type.unknown
+    end
+
+    self.new FunctionType.new(lhs_type, arg_types, return_type)
+  end
+
+  def self.unknown
+    self.new :unknown
+  end
+
+  def self.method_missing(type, *args)
+    raise "Unknown type Type.#{type} (#{type.inspect})" unless
+      Type::KNOWN_TYPES.has_key?(type)
+
+    if type.to_s =~ /(.*)_list$/ then
+      TYPES[type] = self.new($1.intern, true) unless TYPES.has_key?(type)
+      return TYPES[type]
+    else
+      TYPES[type] = self.new(type) unless TYPES.has_key?(type)
+      return TYPES[type]
+    end
+  end
+
+  def self.unknown_list
+    self.new(:unknown, true)
+  end
+
+  attr_accessor :type
+  attr_accessor :list
+
+  def initialize(type, list=false)
+    # HACK
+    unless KNOWN_TYPES.has_key? type or type.class.name =~ /Type$/ then
+      raise "Unknown type Type.new(#{type.inspect})"
+    end
+    @type = Handle.new type
+    @list = list
+  end
+
+  def function?
+    not KNOWN_TYPES.has_key? self.type.contents
+  end
+
+  def unknown?
+    self.type.contents == :unknown
+  end
+
+  def list?
+    @list
+  end
+
+  # REFACTOR: this should be named type, but that'll break code at the moment
+  def list_type
+    @type.contents
+  end
+
+  def eql?(other)
+    return nil unless other.class == self.class
+
+    other.type == self.type && other.list? == self.list?
+  end
+
+  alias :== :eql?
+
+  def hash
+    type.contents.hash ^ @list.hash
+  end
+
+  def unify(other)
+    return other.unify(self) if Array === other
+    return self if other == self and (not self.unknown?)
+    return self if other.nil?
+    if self.unknown? and other.unknown? then
+      # link types between unknowns
+      self.type = other.type
+      self.list = other.list? or self.list? # HACK may need to be tri-state
+    elsif self.unknown? then
+      # other's type is now my type
+      self.type.contents = other.type.contents
+      self.list = other.list?
+    elsif other.unknown? then
+      # my type is now other's type
+      other.type.contents = self.type.contents
+      other.list = self.list?
+    elsif self.function? and other.function? then
+      self_fun = self.type.contents
+      other_fun = other.type.contents
+
+      self_fun.unify_components other_fun
+    else
+      raise TypeError, "Unable to unify #{self.inspect} with #{other.inspect}"
+    end
+    return self
+  end
+
+  def to_s
+    str = "Type.#{self.type.contents}"
+    str << "_list" if self.list?
+    str
+  end
+
+  def inspect
+    to_s
+  end unless $DEBUG
+
+end