ruby-internal 0.8.2 → 0.8.3

data/lib/internal/method/signature/iseq.rb

@@ -1,52 +0,0 @@
-class RubyVM
-  # YARV 1.9.2 and later
-  class InstructionSequence
-    include MethodSig
-
-    def local_vars
-      local_vars = self.local_table
-      return local_vars
-    end
-
-    def argument_names
-      local_vars = self.local_vars
-      opt_args = self.arg_opt_table
-      opt_args.pop # last arg is a pointer to the start of the code
-      num_args = \
-        self.argc + \
-        opt_args.size + \
-        (rest_arg ? 1 : 0) + \
-        (block_arg ? 1 : 0)
-      return local_vars[0...num_args]
-    end
-
-    def args_node
-      return nil
-    end
-
-    def rest_arg
-      arg_rest = self.arg_rest
-      return arg_rest >= 0 ? arg_rest : nil
-    end
-
-    def block_arg
-      arg_block = self.arg_block
-      return arg_block >= 0 ? arg_block : nil
-    end
-
-    def set_optional_args(args, args_node, names)
-      opt_table = self.arg_opt_table
-      opt_table.pop
-      first_opt_idx =
-        names.size -
-        opt_table.size -
-        (self.rest_arg ? 1 : 0) -
-        (self.block_arg ? 1 : 0)
-      opt_table.each_with_index do |pc, idx|
-        name = names[first_opt_idx + idx]
-        args[name] = YarvOptionalArgument.new(name, self, pc, idx, false, false)
-      end
-    end
-  end
-end
-

data/lib/internal/method/signature/node.rb

@@ -1,160 +0,0 @@
-class Node
-  # pre-YARV
-  class SCOPE
-    include MethodSig
-
-    def local_vars
-      return self.tbl || []
-    end
-
-    def argument_names
-      local_vars = self.local_vars
-      args = self.args_node
-      num_required_args = args.cnt
-      num_optional_args = 0
-      opt = args.opt
-      while opt do
-        num_optional_args += 1
-        opt = opt.next
-      end
-      num_args = \
-        num_required_args + \
-        num_optional_args + \
-        (rest_arg ? 1 : 0) + \
-        (block_arg ? 1 : 0)
-      return local_vars[0...num_args]
-    end
-
-    def args_node
-      if self.next.class == Node::ARGS then
-        return self.next
-      elsif self.next.head.class == Node::ARGS then
-        return self.next.head
-      else
-        raise "Could not find method arguments"
-      end
-    end
-
-    def rest_arg
-      args_node = args_node()
-      rest = args_node.rest()
-      if rest.class == Node::LASGN then
-        # subtract 2 to account for implicit vars
-        return rest.cnt - 2
-      elsif not rest
-        return nil
-      else
-        return rest > 0 ? rest - 2 : nil
-      end
-    end
-
-    def block_arg
-      block = self.next
-      if block.class == Node::BLOCK and
-         block.next.head.class == Node::BLOCK_ARG then
-        # subtract 2 to account for implicit vars
-        return block.next.head.cnt - 2
-      else
-        return nil
-      end
-    end
-
-    def set_optional_args(args, args_node, names)
-      opt = args_node.opt
-      while opt do
-        head = opt.head
-        if head.class == Node::LASGN then
-          args[head.vid] = NodeOptionalArgument.new(
-              head.vid, head.value.as_expression, head.value, false, false)
-        else
-          raise "Unexpected node type: #{opt.class}"
-        end
-        opt = opt.next
-      end
-    end
-  end
-
-  # Pre-YARV, I think
-  class BMETHOD
-    def local_vars
-      raise "TODO: Not implemented yet"
-    end
-
-    def argument_names
-      return self.cval.arguments.names
-    end
-
-    def arguments
-      return self.cval.arguments
-    end
-
-    def args_node
-      raise "TODO: Not implemented yet"
-    end
-
-    def rest_arg
-      raise "TODO: Not implemented yet"
-    end
-
-    def block_arg
-      raise "TODO: Not implemented yet"
-    end
-
-    def set_optional_args(args, args_node, names)
-      raise "TODO: Not implemented yet"
-    end
-  end
-
-  # YARV up to 1.9.1
-  class METHOD
-    include MethodSig
-
-    def local_vars
-      iseq = self.body
-      local_vars = iseq.local_table
-      return local_vars
-    end
-
-    def argument_names
-      local_vars = self.local_vars
-      iseq = self.body
-      opt_args = iseq.arg_opt_table
-      opt_args.pop # last arg is a pointer to the start of the code
-      num_args = \
-        iseq.argc + \
-        opt_args.size + \
-        (rest_arg ? 1 : 0) + \
-        (block_arg ? 1 : 0)
-      return local_vars[0...num_args]
-    end
-
-    def args_node
-      return nil
-    end
-
-    def rest_arg
-      arg_rest = self.body.arg_rest
-      return arg_rest >= 0 ? arg_rest : nil
-    end
-
-    def block_arg
-      arg_block = self.body.arg_block
-      return arg_block >= 0 ? arg_block : nil
-    end
-
-    def set_optional_args(args, args_node, names)
-      opt_table = self.body.arg_opt_table
-      opt_table.pop
-      first_opt_idx =
-        names.size -
-        opt_table.size -
-        (self.rest_arg ? 1 : 0) -
-        (self.block_arg ? 1 : 0)
-      opt_table.each_with_index do |pc, idx|
-        name = names[first_opt_idx + idx]
-        args[name] = YarvOptionalArgument.new(name, self.body, pc, idx, false, false)
-      end
-    end
-  end
-end
-

data/lib/internal/method/signature/signature.rb

@@ -1,23 +0,0 @@
-module MethodSig
-  # An abstraction for a method signature.
-  class Signature
-    attr_reader :origin_class, :name, :arg_names, :args
-
-    def initialize(origin_class, name, arg_names, args)
-      @origin_class = origin_class
-      @name = name
-      @arg_names = arg_names
-      @args = args
-    end
-
-    def to_s
-      return "#{@origin_class}\##{@name}(#{param_list})"
-    end
-
-    def param_list
-      params = @arg_names.map{ |n| args[n].to_s }
-      return params.join(', ')
-    end
-  end
-end
-

data/lib/internal/module/as_code.rb

@@ -1,45 +0,0 @@
-require 'internal/node/as_code'
-require 'internal/module'
-
-class Module
-  # TODO: it would be nice if we could go back and find the AST
-  # for the class instead of recreating the code from the class's
-  # current state.
-  def as_code(indent=0)
-    imethods = self.instance_methods - self.superclass.instance_methods
-    cmethods = self.instance_methods - self.superclass.instance_methods
-    constants = self.constants - self.superclass.constants
-    name = self.name.gsub(/.*::/, '')
-
-    # TODO: included modules?
-    if self.class == Class then
-      s = "#{'  '*indent}class #{name} < #{self.superclass}\n"
-    else
-      s = "#{'  '*indent}module #{name}\n"
-    end
-
-    constants.each do |constant|
-      s += "#{'  '*indent} #{constant}=#{self.const_get(constant).as_code}\n"
-    end
-
-    # TODO: protected/private
-    imethods.each do |method|
-      s += self.instance_method(method).as_code(indent+1)
-      s += "\n"
-    end
-
-    cmethods.each do |method|
-      s += self.instance_method(method).as_code(indent+1, "self.#{method}")
-      s += "\n"
-    end
-
-    # TODO: singleton class constants
-    # TODO: class variables
-    # TODO: singleton instance variables
-
-    s += "#{'  '*indent}end"
-
-    return s
-  end
-end
-

data/lib/internal/node/as_code.rb

@@ -1,233 +0,0 @@
-require 'internal/node'
-require 'internal/node/as_expression'
-require 'internal/object/as_code'
-require 'rbconfig'
-
-class Node
-  public
-
-  def as_code(indent=0, *args)
-    return as_code_impl(self, indent, *args)
-  end
-
-  private
-
-  def as_code_impl(node, indent, *args)
-    # default -- most code is just an expression
-    expression = node.as_expression(*args)
-    if not expression.nil? then
-      return "#{'  '*indent}#{expression}"
-    else
-      return nil
-    end
-  end
-
-  class << self
-    def define_code(klass, &block)
-      if const_defined?(klass) then
-        const_get(klass).instance_eval { define_method(:as_code_impl, &block) }
-      end
-    end
-  end
-
-  define_code(:IF) do |node, indent|
-    if node.body.class == Node::BLOCK or
-       node.else.class == Node::BLOCK then
-      s = "#{'  '*indent}if #{node.cond.as_expression} then\n"
-      s << "#{'  '*indent}#{node.body.as_code(indent+1)}\n"
-      if node.else then
-        s << "#{'  '*indent}else\n"
-        s << "#{'  '*indent}#{node.else.as_code(indent+1)}\n"
-      end
-      s << "#{'  '*indent}end"
-      s
-    else
-      "#{'  '*indent}#{node.as_expression}"
-    end
-  end
-
-  define_code(:BLOCK) do |node, indent|
-    a = node.to_a
-    if a[0].class == Node::DASGN_CURR then
-      vardefs = a[0]
-      while vardefs.class == Node::DASGN_CURR do
-        vardefs = vardefs.value
-      end
-      if not vardefs then
-        # ignore variable definitions
-        a.shift
-      end
-    end
-    lines = a.map { |n| n.as_code(indent) }
-    lines.reject! { |e| e.nil? }
-    if lines.size == 0 then
-      "#{'  '*indent}nil"
-    else
-      lines.join("\n")
-    end
-  end
-
-  define_code(:ITER) do |node, indent|
-    "#{'  '*indent}#{node.iter.as_expression} {\n" +
-    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-    "#{'  '*indent}}"
-  end
-
-  define_code(:WHILE) do |node, indent|
-    if node.state == 1 then
-      "#{'  '*indent}while #{node.cond.as_expression} do\n" +
-      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-      "#{'  '*indent}end"
-    else
-      "#{'  '*indent}begin\n" +
-      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-      "#{'  '*indent}end while #{node.cond.as_expression}"
-    end
-  end
-
-  define_code(:UNTIL) do |node, indent|
-    if node.state == 1 then
-      "#{'  '*indent}until #{node.cond.as_expression} do\n" +
-      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-      "#{'  '*indent}end"
-    else
-      "#{'  '*indent}begin\n" +
-      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-      "#{'  '*indent}end until #{node.cond.as_expression}"
-    end
-  end
-
-  define_code(:BEGIN) do |node, indent|
-    if node.body.class == Node::RESCUE or
-       node.body.class == Node::ENSURE then
-      s = "#{'  '*indent}begin\n" +
-      "#{node.body.as_code(indent+1, true)}\n" +
-      "#{'  '*indent}end"
-    elsif node.body then
-      "#{'  '*indent}begin\n" +
-      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-      "#{'  '*indent}end"
-    else
-      "#{'  '*indent}begin\n" +
-      "#{'  '*indent}end\n"
-    end
-  end
-
-  def self.begin_end(indent, have_begin)
-    s = ''
-    if not have_begin then
-      s << "#{'  '*indent}begin\n"
-      indent += 1
-    end
-    yield s, indent, true
-    if not have_begin then
-      indent -= 1
-      s << "\n#{'  '*indent}end"
-    end
-    return s
-  end
-
-  define_code(:ENSURE) do |node, indent, *args|
-    begin_ensure = args[0] || false
-    Node.begin_end(indent, begin_ensure) do |s, indent_, begin_ensure|
-      if node.head then
-        s << "#{node.head.as_code(indent_)}\n"
-      end
-      s << "#{'  '*(indent_-1)}ensure\n"
-      s << "#{node.ensr.as_code(indent_)}"
-    end
-  end
-
-  define_code(:RESCUE) do |node, indent, *args|
-    begin_rescue = args[0] || false
-    Node.begin_end(indent, begin_rescue) do |s, indent_, begin_rescue|
-      if node.head then
-        if begin_rescue then
-          s << "#{node.head.as_code(indent_)}\n"
-          s << "#{'  '*(indent_-1)}rescue #{node.resq.as_code(indent_+1, begin_rescue)}"
-        else
-          s << "#{node.head.as_expression} rescue #{node.resq.as_expression(begin_rescue)}"
-        end
-      else
-        s << "rescue #{node.resq.as_expression(begin_rescue)}"
-      end
-    end
-  end
-
-  define_code(:RESBODY) do |node, indent, *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(', ')}\n" +
-        "#{'  '*indent}#{node.body.as_code(indent+1)}"
-      else
-        node.body ? "\n#{'  '*indent}#{node.body.as_code(indent+1)}" : ''
-      end
-    else
-      # TODO: assuming node.args is false...
-      node.body ? node.body.as_code : ''
-    end
-  end
-
-  define_code(:NEWLINE) do |node, indent|
-    node.next.as_code(indent)
-  end
-
-  define_code(:CASE) do |node, indent|
-    "#{'  '*indent}case #{node.head.as_expression}\n" +
-    "#{node.body.as_code(indent)}end"
-  end
-
-  define_code(:WHEN) do |node, indent|
-    args = node.head.to_a.map { |n| n.as_expression }
-    s = "#{'  '*indent}when #{args.join(', ')}\n"
-    if node.body then
-      s << "#{'  '*indent}#{node.body.as_code(indent+1)}; "
-    end
-    if node.next then
-      s << node.next.as_code
-    end
-    s
-  end
-
-  define_code(:CLASS) do |node, indent|
-    s_super = node.super ? " < #{node.super.as_expression}" : ''
-    if node.respond_to?(:cpath) then
-      path = node.cpath.as_expression
-    else
-      path = node.cname
-    end
-    "#{'  '*indent}class #{path}#{s_super}\n" +
-    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-    "#{'  '*indent}end"
-  end
-
-  define_code(:SCLASS) do |node, indent|
-    "#{'  '*indent}class << #{node.recv.as_expression}\n" +
-    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
-    "#{'  '*indent}end"
-  end
-
-  define_code(:DEFN) do |node, indent|
-    # TODO: what to do about noex?
-    "#{'  '*indent}def #{node.mid}\n" +
-    "#{'  '*indent}#{node.next.as_code(indent+1)}\n" +
-    "#{'  '*indent}end"
-  end
-
-  define_code(:DEFS) do |node, indent|
-    "#{'  '*indent}def #{node.recv.as_expression}.#{node.mid}\n" +
-    "#{'  '*indent}#{node.next.as_code(indent+1)}\n" +
-    "#{'  '*indent}end"
-  end
-
-  define_code(:SCOPE) do |node, indent|
-    case node.next
-    when nil then ''
-    when Node::ARGS then "#{'  '*indent}nil"
-    when Node::BLOCK_ARG then "#{'  '*indent}nil"
-    else node.next.as_code(indent)
-    end
-  end
-end