ruby-internal 0.7.3 → 0.8.0

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

@@ -0,0 +1,102 @@
+
+module MethodSig
+  class Argument
+    attr_reader :name
+
+    def required?
+      return !optional?
+    end
+
+    def optional?
+      return rest? || block?
+    end
+
+    def rest?
+      return @is_rest
+    end
+
+    def block?
+      return @is_block
+    end
+
+    def default
+      return nil
+    end
+
+    def initialize(name, is_rest, is_block)
+      @name = name
+      @is_rest = is_rest
+      @is_block = is_block
+    end
+
+    def to_s
+      if @is_rest then
+        prefix = "*"
+      elsif @is_block then
+        prefix = "&"
+      end
+
+      if self.default then
+        suffix = "=#{default()}"
+      end
+
+      return "#{prefix}#{@name}#{suffix}"
+    end
+  end
+
+  class OptionalArgument < Argument
+    def optional?
+      return true
+    end
+  end
+
+  class NodeOptionalArgument < OptionalArgument
+    attr_reader :node_for_default
+    attr_reader :default
+
+    def initialize(name, default, node_for_default, is_rest, is_block)
+      super(name, is_rest, is_block)
+      @default = default
+      @node_for_default = node_for_default
+    end
+  end
+
+  class YarvOptionalArgument < OptionalArgument
+    attr_reader :iseq
+    attr_reader :pc_start
+    attr_reader :local_idx
+
+    def initialize(name, iseq, pc_start, local_idx, is_rest, is_block)
+      super(name, is_rest, is_block)
+      @iseq = iseq
+      @pc_start = pc_start
+      @local_idx = local_idx
+      @default = nil
+    end
+
+    def inspect
+      default()
+      super
+    end
+
+    def default
+      return @default if @default
+
+      env = Internal::ByteDecoder::Environment.new(@iseq.local_table())
+      local_table_idx = local_table_idx()
+      @iseq.bytedecode(env, @pc_start) do |instr|
+        RubyVM::Instruction::SETLOCAL === instr &&
+        instr.operands[0] == local_table_idx
+      end
+      expressions = env.expressions + env.stack
+
+      @default = expressions[0].rhs.to_s
+      return @default
+    end
+
+    def local_table_idx
+      return @iseq.local_table.size - @local_idx + 1
+    end
+  end
+end
+

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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,160 @@
+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

@@ -0,0 +1,23 @@
+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/proc/as_code.rb

@@ -3,6 +3,8 @@ require 'internal/proc'
 require 'internal/proc/signature'
 
 class Proc
+  # Return a string representation of a proc's definition/body,
+  # similarly to +Method#as_code+.
   def as_code(indent=0)
     sig = self.signature
     body_expression = self.body ? self.body.as_code(indent+1) : nil

data/lib/internal/proc/as_expression.rb

@@ -3,6 +3,8 @@ require 'internal/proc/signature'
 require 'internal/proc'
 
 class Proc
+  # Return a single-line string representation of a proc's
+  # definition/body, similarly to +Method#as_expression+.
   def as_expression
     sig = self.signature
     body_expression = self.body ? self.body.as_expression : nil

data/lib/internal/vm/bytedecoder.rb

@@ -3,7 +3,7 @@ require 'internal/vm/instruction'
 require 'internal/vm/inline_cache'
 require 'internal/vm/constants'
 
-module Nodewrap
+module Internal
 
 # A module for decoding YARV bytecode.
 #
@@ -13,7 +13,7 @@ module Nodewrap
 # could use this as a base for building one.
 #
 # Example usage:
-#   env = Nodewrap::ByteDecoder::Environment.new(is.local_table)
+#   env = Internal::ByteDecoder::Environment.new(is.local_table)
 #   is = RubyVM::InstructionSequence.new('1 + 1')
 #   is.bytedecode(env)
 #   env.expressions.each do |expr|
@@ -450,11 +450,11 @@ end
 
 end # ByteDecoder
 
-end # Nodewrap
+end # Internal
 
 class RubyVM
   class Instruction
-    include Nodewrap::ByteDecoder
+    include Internal::ByteDecoder
 
     class PUTOBJECT
       def bytedecode(env)
@@ -839,7 +839,7 @@ if __FILE__ == $0 then
   is = n.body
   puts is.disasm
 
-  env = Nodewrap::ByteDecoder::Environment.new(is.local_table)
+  env = Internal::ByteDecoder::Environment.new(is.local_table)
   s = ''
   # puts "local_table = #{is.local_table.inspect}"
   is.each do |i|

data/lib/internal/vm/iseq/as_code.rb

@@ -6,14 +6,14 @@ if defined?(RubyVM::InstructionSequence) then
   class RubyVM
     class InstructionSequence
       def as_code(indent=0)
-        env = Nodewrap::ByteDecoder::Environment.new(local_table())
+        env = Internal::ByteDecoder::Environment.new(local_table())
         opt_pc = self.opt_pc
         self.bytedecode(env, opt_pc)
         expressions = env.expressions + env.stack
         if expressions.length == 0 then
           return nil
         elsif expressions.length == 1 and
-           expressions[0].is_a?(Nodewrap::ByteDecoder::Expression::Literal) and
+           expressions[0].is_a?(Internal::ByteDecoder::Expression::Literal) and
            expressions[0].value == nil then
           return nil
         else

data/lib/internal/vm/iseq/as_expression.rb

@@ -6,14 +6,14 @@ if defined?(RubyVM::InstructionSequence) then
   class RubyVM
     class InstructionSequence
       def as_expression
-        env = Nodewrap::ByteDecoder::Environment.new(local_table())
+        env = Internal::ByteDecoder::Environment.new(local_table())
         opt_pc = self.opt_pc
         self.bytedecode(env, opt_pc)
         expressions = env.expressions + env.stack
         if expressions.length == 0 then
           return nil
         elsif expressions.length == 1 and
-           expressions[0].is_a?(Nodewrap::ByteDecoder::Expression::Literal) and
+           expressions[0].is_a?(Internal::ByteDecoder::Expression::Literal) and
            expressions[0].value == nil then
           return nil
         else

data/test/test_dump_method.rb

@@ -139,6 +139,6 @@ class TC_Dump_Module < Test::Unit::TestCase
 end
 
 if __FILE__ == $0 then
-  exit Test::Unit::AutoRunner.run
+  # exit Test::Unit::AutoRunner.run
 end