ruby-internal 0.8.2 → 0.8.3

data/lib/internal/node/as_expression.rb

@@ -1,619 +0,0 @@
-require 'internal/node'
-require 'internal/node/to_a'
-require 'rbconfig'
-
-class Node
-  public
-
-  # Return an string describing this node as a single expression.  By
-  # default, this just returns the name of the node's type, but some
-  # node types override this method to produce more meaningful output.
-  def as_expression(*args)
-    return as_expression_impl(self, *args)
-  end
-
-  # Return a string as with as_expression, but surround it with parens
-  # if it is a composite expression, so that it can be used to form more
-  # complex expressions.
-  def as_paren_expression(*args)
-    expr = self.as_expression(*args)
-    if not OMIT_PARENS[self.class] then
-      expr = "(#{expr})"
-    end
-    return expr
-  end
-
-  private
-
-  # default
-  def as_expression_impl(node)
-    return "<#{node.nd_type.to_s}>"
-  end
-
-  class << self
-    def define_expression(klass, &block)
-      if const_defined?(klass) then
-        const_get(klass).instance_eval { define_method(:as_expression_impl, &block) }
-      end
-    end
-  end
-
-  define_expression(:LIT) do |node|
-    # TODO: #inspect might not give an eval-able expression
-    node.lit.inspect
-  end
-
-  define_expression(:FCALL) do |node|
-    # args will either be an ARRAY or ARGSCAT
-    args = node.args
-    "#{node.mid}(#{args ? args.as_expression(false) : ''})"
-  end
-
-  define_expression(:VCALL) do |node|
-    node.mid.to_s
-  end
-
-  arithmetic_expressions = [
-    :+, :-, :*, :/, :<, :>, :<=, :>=, :==, :===, :<=>, :<<, :>>, :&, :|,
-    :^, :%, '!'.intern, '!='.intern
-  ]
-
-  # TODO: there should be a way to detect if the expressions need to be
-  # in parens
-  define_expression(:CALL) do |node|
-    recv_expr = node.recv.as_paren_expression
-
-    case node.mid
-    when *arithmetic_expressions
-      args = node.args
-      "#{recv_expr} #{node.mid} #{args ? args.as_paren_expression(false) : ''}"
-    when :[]
-      args = node.args
-      "#{recv_expr}[#{args ? args.as_expression(false) : ''}]"
-    else
-      args = node.args
-      "#{recv_expr}.#{node.mid}(#{args ? args.as_expression(false) : ''})"
-    end
-  end
-
-  define_expression(:ZSUPER) do |node|
-    "super"
-  end
-
-  define_expression(:SUPER) do |node|
-    "super(#{node.args ? node.args.as_expression(false) : ''})"
-  end
-
-  define_expression(:REDO) do |node|
-    "redo"
-  end
-
-  define_expression(:RETRY) do |node|
-    "retry"
-  end
-
-  define_expression(:NOT) do |node|
-    "not #{node.body.as_expression}"
-  end
-
-  define_expression(:AND) do |node|
-    "#{node.first.as_expression} and #{node.second.as_expression}"
-  end
-
-  define_expression(:OR) do |node|
-    "#{node.first.as_expression} or #{node.second.as_expression}"
-  end
-
-  class ARRAY < Node
-    def as_expression_impl(node, brackets = true)
-      s = brackets ? '[' : ''
-      s << (node.to_a.map { |n| n.as_expression }.join(', '))
-      s << (brackets ? ']' : '')
-      s
-    end
-  end
-
-  class ARGSCAT < Node
-    def as_expression_impl(node, brackets = true)
-      s = brackets ? '[' : ''
-      s << node.head.as_expression(false)
-      s << ", "
-      s << "*#{node.body.as_expression}"
-      s << (brackets ? ']' : '')
-      s
-    end
-  end
-
-  class ZARRAY < Node
-    def as_expression_impl(node, brackets = true)
-      brackets ? '[]' : ''
-    end
-  end
-
-  class BLOCK < Node
-    def as_expression_impl(node)
-      a = node.to_a
-      if a.size == 1 then
-        return 'nil'
-      end
-      d = a[0]
-      while d.class == Node::DASGN_CURR do
-        d = d.value
-      end
-      a.shift if not d
-      expressions = a.map { |n| n.as_expression }
-      expressions.reject! { |e| e.nil? }
-      if expressions.nitems == 0 then
-        return 'nil'
-      else
-        return expressions.join('; ')
-      end
-    end
-  end
-
-  define_expression(:HASH) do |node|
-    if not node.head then
-      "{}"
-    else
-      a = node.head.to_a
-      elems = []
-      i = 0
-      while i < a.size do
-        elems << "(#{a[i].as_expression})=>(#{a[i+1].as_expression})"
-        i += 2
-      end
-      "{#{elems.join(', ')}}"
-    end
-  end
-
-  define_expression(:IF) do |node|
-    if Node.const_defined?(:NEWLINE) then
-      bodynode = node.body.class == Node::NEWLINE ? node.body.next : node.body
-      elsenode = node.else.class == Node::NEWLINE ? node.else.next : node.else
-    else
-      bodynode = node.body
-      elsenode = node.else
-    end
-    if elsenode then
-      "#{node.cond.as_paren_expression} ? " +
-      "#{bodynode.as_paren_expression} : " +
-      "#{elsenode.as_paren_expression}"
-    else
-      "#{bodynode.as_paren_expression} if " +
-      "#{node.cond.as_paren_expression}"
-    end
-  end
-
-  define_expression(:TRUE) do |node|
-    "true"
-  end
-
-  define_expression(:FALSE) do |node|
-    "false"
-  end
-
-  define_expression(:NIL) do |node|
-    "nil"
-  end
-
-  define_expression(:SELF) do |node|
-    "self"
-  end
-
-  define_expression(:DOT2) do |node|
-    "#{node.beg.as_paren_expression}..#{node.end.as_paren_expression}"
-  end
-
-  define_expression(:DOT3) do |node|
-    "#{node.beg.as_paren_expression}...#{node.end.as_paren_expression}"
-  end
-
-  define_expression(:GVAR) do |node|
-    "#{node.vid}"
-  end
-
-  define_expression(:IVAR) do |node|
-    "#{node.vid}"
-  end
-
-  define_expression(:CVAR) do |node|
-    "#{node.vid}"
-  end
-
-  define_expression(:DVAR) do |node|
-    "#{node.vid}"
-  end
-
-  define_expression(:NTH_REF) do |node|
-    "$#{node.nth}"
-  end
-
-  define_expression(:BACK_REF) do |node|
-    "$`"
-  end
-
-  define_expression(:DASGN_CURR) do |node|
-    # node.value is unset for MASGN
-    node.value ? "#{node.vid} = #{node.value.as_expression}" : "#{node.vid}"
-  end
-
-  define_expression(:DASGN) do |node|
-    "#{node.vid} = #{node.value.as_expression}"
-  end
-
-  define_expression(:IASGN) do |node|
-    "#{node.vid} = #{node.value.as_expression}"
-  end
-
-  define_expression(:LASGN) do |node|
-    "#{node.vid} = #{node.value.as_expression}"
-  end
-
-  define_expression(:MASGN) do |node|
-    lhs = node.head.to_a.map { |n| n.as_expression }
-    rhs = node.value.to_a.map { |n| n.as_expression }
-    "#{lhs.join(', ')} = #{rhs.join(', ')}"
-  end
-
-  define_expression(:OP_ASGN1) do |node|
-    # TODO
-    raise "Not implemented"
-  end
-
-  define_expression(:OP_ASGN2) do |node|
-    recv = node.recv.as_expression
-    attr = node.next.vid # TODO: we assume it's the same as aid
-    op = case node.next.mid
-    when false then '||'
-    when nil then '&&'
-    else node.next.mid
-    end
-    value = node.value.as_expression
-    "#{recv}.#{attr} #{op}= #{value}"
-  end
-
-  define_expression(:CDECL) do |node|
-    "#{node.vid} = #{node.value.as_expression}"
-  end
-
-  define_expression(:CVDECL) do |node|
-    "#{node.vid} = #{node.value.as_expression}"
-  end
-
-  define_expression(:CVASGN) do |node|
-    "#{node.vid} = #{node.value.as_expression}"
-  end
-
-  define_expression(:ATTRASGN) do |node|
-    case node.mid
-    when :[]=
-      args = node.args.to_a
-      attrs = args[1..-2].map { |n| n.as_expression }
-      value = args[-1].as_expression
-      "#{node.recv.as_paren_expression}[#{attrs.join(', ')}] = #{value}"
-    else
-      "#{node.recv.as_paren_expression}.#{node.mid}#{node.args.as_expression(false)}"
-    end
-  end
-
-  define_expression(:CONST) do |node|
-    "#{node.vid}"
-  end
-
-  define_expression(:COLON2) do |node|
-    # TODO: shouldn't COLON2 have args if it's a method?
-    if node.head then
-      "#{node.head.as_expression}::#{node.mid}"
-    else
-      node.mid.to_s
-    end
-  end
-
-  define_expression(:COLON3) do |node|
-    "::#{node.mid}"
-  end
-
-  define_expression(:LVAR) do |node|
-    "#{node.vid}"
-  end
-
-  define_expression(:NEWLINE) do |node|
-    node.next.as_expression
-  end
-
-  define_expression(:STR) do |node|
-    "\"#{node.lit.inspect[1..-2]}\""
-  end
-
-  define_expression(:REGX) do |node|
-    # TODO: cflag
-    "/#{node.lit.inspect[1..-2]}/"
-  end
-
-  define_expression(:REGX_ONCE) do |node|
-    # TODO: cflag
-    "/#{node.lit.inspect[1..-2]}/o"
-  end
-
-  define_expression(:XSTR) do |node|
-    "`#{node.lit.inspect[1..-2]}`"
-  end
-
-  define_expression(:DSTR) do |node|
-    a = node.next.to_a
-    s = "\"#{node.lit.inspect[1..-2]}"
-    a.each do |elem|
-      case elem
-      when Node::STR then s += elem.lit
-      else s += elem.as_expression
-      end
-    end
-    s += "\""
-    s
-  end
-
-  define_expression(:DREGX) do |node|
-    a = node.next.to_a
-    s = "/#{node.lit.inspect[1..-2]}"
-    a.each do |elem|
-      case elem
-      when Node::STR then s += elem.lit
-      else s += elem.as_expression
-      end
-    end
-    s += "/"
-    # TODO: cflag
-    s
-  end
-
-  define_expression(:DREGX_ONCE) do |node|
-    a = node.next.to_a
-    s = "/#{node.lit.inspect[1..-2]}"
-    a.each do |elem|
-      case elem
-      when Node::STR then s += elem.lit
-      else s += elem.as_expression
-      end
-    end
-    s += "/o"
-    # TODO: cflag
-    s
-  end
-
-  define_expression(:DXSTR) do |node|
-    a = node.next.to_a
-    s = "`#{node.lit.inspect[1..-2]}"
-    a.each do |elem|
-      case elem
-      when Node::STR then s += elem.lit
-      else s += elem.as_expression
-      end
-    end
-    s += "`"
-    s
-  end
-
-  major = Config::CONFIG['MAJOR'].to_i
-  minor = Config::CONFIG['MINOR'].to_i
-  teeny = Config::CONFIG['TEENY'].to_i
-  ruby_version_code = major * 100 + minor * 10 + teeny
-
-  if ruby_version_code >= 180 then
-
-    define_expression(:EVSTR) do |node|
-      "\#\{#{node.body.as_expression}\}"
-    end
-
-  else
-
-    define_expression(:EVSTR) do |node|
-      "\#\{#{node.lit}\}"
-    end
-
-  end
-
-  define_expression(:ITER) do |node|
-    iter = node.iter.as_expression
-    body = node.body ? (node.body.as_expression + " ") : ""
-    "#{iter} { #{body} }"
-  end
-
-  define_expression(:WHILE) do |node|
-    if node.state == 1 then
-      "while #{node.cond.as_expression} do; #{node.body.as_expression}; end"
-    else
-      "begin; #{node.body.as_expression}; end while #{node.cond.as_expression}"
-    end
-  end
-
-  define_expression(:UNTIL) do |node|
-    if node.state == 1 then
-      "until #{node.cond.as_expression} do; #{node.body.as_expression}; end"
-    else
-      "begin; #{node.body.as_expression}; end until #{node.cond.as_expression}"
-    end
-  end
-
-  define_expression(:BREAK) do |node|
-    s = "break"
-    if node.stts then
-      s += " #{node.stts.as_expression}"
-    end
-    s
-  end
-
-  define_expression(:RETURN) do |node|
-    s = "return"
-    if node.stts then
-      s += " #{node.stts.as_expression}"
-    end
-    s
-  end
-
-  define_expression(:YIELD) do |node|
-    s = "yield"
-    if node.stts then
-      s += " #{node.stts.as_expression}"
-    end
-    s
-  end
-
-  define_expression(:BEGIN) do |node|
-    if node.body.class == Node::RESCUE or
-       node.body.class == Node::ENSURE then
-      "begin; #{node.body.as_expression(true)}; end"
-    elsif node.body then
-      "begin; #{node.body.as_expression}; end"
-    else
-      "begin; end"
-    end
-  end
-
-  define_expression(:ENSURE) do |node, *args|
-    begin_ensure = args[0] || false
-    if node.head then
-      if begin_ensure then
-        "#{node.head.as_expression} ensure #{node.ensr.as_expression}"
-      else
-        "begin; #{node.head.as_expression} ensure #{node.ensr.as_expression}; end"
-      end
-    else
-      if begin_ensure then
-        "ensure #{node.ensr.as_expression}"
-      else
-        "begin; ensure #{node.ensr.as_expression}; end"
-      end
-    end
-  end
-
-  define_expression(:RESCUE) do |node, *args|
-    begin_rescue = args[0] || false
-    if node.head then
-      if begin_rescue then
-        "#{node.head.as_expression}; rescue #{node.resq.as_expression(begin_rescue)}"
-      else
-        if not node.resq or not node.resq.body then
-          "begin; #{node.head.as_expression}; rescue; end"
-        else
-          "#{node.head.as_paren_expression} rescue #{node.resq.as_expression(begin_rescue)}"
-        end
-      end
-    else
-      if not node.resq or not node.resq.body then
-        "begin; rescue; end"
-      else
-        "rescue #{node.resq.as_expression(begin_rescue)}"
-      end
-    end
-  end
-
-  define_expression(:RESBODY) do |node, *args|
-    begin_rescue = args[0] || false
-    if begin_rescue then
-      if node.args then
-        a = node.args.to_a.map { |n| n.as_expression }
-        "#{a.join(', ')}; #{node.resq.as_expression}"
-      else
-        node.body ? "; #{node.body.as_expression}" : ''
-      end
-    else
-      # TODO: assuming node.args is false...
-      node.body ? node.body.as_expression : ''
-    end
-  end
-
-  define_expression(:CASE) do |node|
-    "case #{node.head.as_expression}; #{node.body.as_expression}end"
-  end
-
-  define_expression(:WHEN) do |node|
-    args = node.head.to_a.map { |n| n.as_expression }
-    s = ''
-    if node.body then
-      s = "when #{args.join(', ')} then #{node.body.as_expression}; "
-    else
-      s = "when #{args.join(', ')}; "
-    end
-    if node.next then
-      s += node.next.as_expression
-    end
-    s
-  end
-
-  define_expression(:ALIAS) do |node|
-    "alias #{node.new} #{node.old}"
-  end
-
-  define_expression(:VALIAS) do |node|
-    "alias #{node.new} #{node.old}"
-  end
-
-  define_expression(:UNDEF) do |node|
-    if defined? node.mid then
-      # < 1.8.5
-      "undef #{node.mid}"
-    else
-      # >= 1.8.5
-      "undef #{node.body.as_expression}"
-    end
-  end
-
-  define_expression(:CLASS) do |node|
-    s_super = node.super ? " < #{node.super.as_expression}" : ''
-    if node.respond_to?(:cpath) then
-      path = node.cpath.as_expression
-    else
-      path = node.cname
-    end
-    "class #{path}#{s_super}; #{node.body.as_expression}; end"
-  end
-
-  define_expression(:SCLASS) do |node|
-    "class << #{node.recv.as_expression}; #{node.body.as_expression}; end"
-  end
-
-  define_expression(:SCOPE) do |node|
-    case node.next
-    when nil then ''
-    when Node::ARGS then 'nil'
-    when Node::BLOCK_ARG then 'nil'
-    else node.next.as_expression
-    end
-  end
-
-  define_expression(:DEFN) do |node|
-    # TODO: what to do about noex?
-    "def #{node.mid}; #{node.next.as_expression}; end"
-  end
-
-  define_expression(:DEFS) do |node|
-    "def #{node.recv.as_expression}.#{node.mid}; #{node.next.as_expression}; end"
-  end
-
-  define_expression(:DEFINED) do |node|
-    "defined?(#{node.head.as_expression})"
-  end
-
-  define_expression(:ARGS) do |node|
-    nil
-  end
-
-  define_expression(:BLOCK_ARG) do |node|
-    nil
-  end
-
-  # TODO: MATCH3
-
-  OMIT_PARENS = {
-    LVAR   => true,
-    GVAR   => true,
-    IVAR   => true,
-    CVAR   => true,
-    DVAR   => true,
-    LIT    => true,
-    ARRAY  => true,
-    ZARRAY => true,
-    HASH   => true,
-  }
-end
-