ruby-decompiler 0.0.1

data/lib/decompiler/proc/as_code.rb

@@ -0,0 +1,23 @@
+require 'internal/node/as_code'
+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
+    s = "#{'  '*indent}proc do"
+    if not sig.args.unspecified then
+      s += " #{sig}"
+    end
+    s += "\n"
+    if body_expression then
+      s += "#{body_expression}\n"
+    end
+    s += "#{'  '*indent}end"
+    return s
+  end
+end
+

data/lib/decompiler/proc/as_expression.rb

@@ -0,0 +1,16 @@
+require 'internal/node/as_expression'
+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
+    s = sig.args.unspecified ? "" : sig.to_s + ' '
+    b = body_expression ? body_expression + ' ' : ''
+    return "proc { #{s}#{b}}"
+  end
+end
+

data/lib/decompiler/proc/signature.rb

@@ -0,0 +1,184 @@
+require 'internal/node'
+require 'internal/proc'
+require 'internal/vm'
+
+class Proc
+  class Arguments
+    include Enumerable
+
+    def initialize(names, multiple_assignment, rest_arg)
+      @names = names
+      @multiple_assignment = multiple_assignment
+      @rest_arg = rest_arg
+    end
+
+    def unspecified
+      if defined?(RubyVM) and defined?(RubyVM::InstructionSequence) then
+        # YARV
+        return @names.length == 0
+      else
+        # pre-YARV
+        @names.nil?
+      end
+    end
+
+    def single_assignment
+      !@multiple_assignment
+    end
+
+    def multiple_assignment
+      @multiple_assignment
+    end
+
+    def names
+      @names
+    end
+
+    def [](idx)
+      @names[idx]
+    end
+
+    def each(&block)
+      (@names || []).each(&block)
+    end
+
+    def size
+      @names.size
+    end
+
+    def rest_arg
+      @rest_arg
+    end
+
+    def empty_last_arg
+      if defined?(VM) and defined?(VM::InstructionSequence) then
+        # YARV
+        return (@rest_arg and @names[-1] == nil)
+      else
+        # pre-YARV
+        return (@names.size == 1 and not @rest_arg)
+      end
+    end
+  end
+
+  # Return an Arguments object representing the arguments in the order
+  # in which they appear in the argument list.
+  def arguments
+    has_rest_arg = self.has_rest_arg
+
+    if self.respond_to?(:var) then
+      # pre-YARV
+      case self.var
+      when Node::DASGN_CURR
+        return Arguments.new([ self.var.vid ], false, has_rest_arg ? 0 : nil)
+      when Node::MASGN
+        if self.var.head then
+          a = self.var.head.to_a
+          args = a.map { |n| n.vid }
+        else
+          args = []
+        end
+        if self.var.args then
+          args.push(self.var.args.vid)
+        end
+        return Arguments.new(args, true, has_rest_arg ? args.size - 1: nil)
+      when nil
+        return Arguments.new(nil, false, has_rest_arg ? 0 : nil)
+      when Fixnum
+        return Arguments.new([], false, has_rest_arg ? 0 : nil)
+      else
+        raise "Unexpected node type: #{self.var.class}"
+      end
+    elsif
+      # YARV
+      iseq = self.body
+      local_vars = iseq.local_table
+      has_rest_arg = iseq.arg_rest != -1
+      has_block_arg = iseq.arg_block != -1
+      num_args = \
+        iseq.argc + \
+        iseq.arg_opt_table.size + \
+        (has_rest_arg ? 1 : 0) + \
+        (has_block_arg ? 1 : 0)
+      names = local_vars[0...num_args]
+      # TODO: masgn
+      return Arguments.new(names, true, has_rest_arg ? -1 : nil)
+    else
+      return Arguments.new(nil, false, nil)
+    end
+  end
+
+  # Return true if the proc has a rest arg
+  def has_rest_arg
+    if self.respond_to?(:var) then
+      # pre-YARV
+      has_rest_arg = false
+      if self.var then
+        if self.var.class == Node::MASGN then
+          if self.var.args then
+            has_rest_arg = true
+          end
+        end
+      end
+    else
+      # YARV
+      rest = self.body.arg_rest
+      has_rest_arg = (rest >= 0 ? rest - 1 : nil)
+    end
+    return has_rest_arg
+  end
+
+  # Return a hash mapping each argument name to a description of that
+  # argument.
+  def argument_info
+    args = self.arguments()
+
+    info = {}
+    args.each do |name|
+      info[name] = name.to_s
+    end
+
+    # Rest arg
+    if args.rest_arg then
+      rest_name = args[args.rest_arg]
+      if rest_name then
+        info[rest_name] = "*#{rest_name}"
+      end
+    end
+
+    return info
+  end
+
+  class Signature
+    attr_reader :args, :arg_info
+
+    def initialize(args, arg_info)
+      @args = args
+      @arg_info = arg_info
+    end
+
+    def to_s
+      if @args.unspecified then
+        return ""
+      elsif @args.multiple_assignment then
+        if @args.empty_last_arg then
+          params = @args.map{ |n| arg_info[n] }
+          return "|#{@arg_info[@args[0]]},|"
+        else
+          params = @args.map{ |n| arg_info[n] }
+          return "|#{params.join(', ')}|"
+        end
+      else
+        return "|#{@arg_info[@args[0]]}|"
+      end
+    end
+  end
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        arguments(),
+        argument_info)
+  end
+end
+

data/lib/decompiler/vm/bytedecoder.rb

@@ -0,0 +1,866 @@
+require 'internal/vm/iseq'
+require 'internal/vm/instruction'
+require 'internal/vm/inline_cache'
+require 'internal/vm/constants'
+
+module Internal
+
+# A module for decoding YARV bytecode.
+#
+# This is actually pretty cool.  It's actually a miniature VM, where the
+# result of evaluating an expression is itself another expression.  This
+# turns out to be much simpler than a full ruby VM, but I think one
+# could use this as a base for building one.
+#
+# Example usage:
+#   env = Internal::ByteDecoder::Environment.new(is.local_table)
+#   is = RubyVM::InstructionSequence.new('1 + 1')
+#   is.bytedecode(env)
+#   env.expressions.each do |expr|
+#     puts expr
+#   end
+#   puts stack[-1]
+#
+module ByteDecoder
+
+class Environment
+  attr_reader :stack
+  attr_reader :expressions
+  attr_reader :local_table
+  attr_accessor :last
+  attr_reader :seq
+  attr_accessor :pc
+
+  def initialize(local_table)
+    @stack = []
+    @expressions = []
+    @local_table = local_table
+    @last = nil
+    @pc = 0
+  end
+
+  def advance(instruction_length)
+    @pc += instruction_length
+  end
+
+  def remember(expression)
+    if not expression.is_a?(Expression::Literal) then
+      @expressions << expression
+    end
+  end
+end
+
+class Expression
+  attr_reader :pc
+
+  def initialize(pc)
+    @pc = pc
+  end
+
+  def <=>(rhs)
+    return @pc <=> rhs.pc
+  end
+
+  def fmt(arg)
+    if arg.respond_to?(:precedence)
+      p = arg.precedence
+    else
+      p = 0
+    end
+
+    if p >= self.precedence then
+      return "(#{arg})"
+    else
+      return arg
+    end
+  end
+
+  class Literal < Expression
+    attr_reader :value
+
+    def initialize(pc, value)
+      super(pc)
+      @value = value
+    end
+
+    def to_s
+      case @value
+      when Regexp then "/#{@value.inspect[1..-2]}/"
+      else; return @value.inspect
+      end
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Infix < Expression
+    attr_reader :op
+    attr_reader :lhs
+    attr_reader :rhs
+
+    def initialize(pc, op, lhs, rhs)
+      super(pc)
+      @op = op
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def to_s
+      return "#{fmt(@lhs)} #{@op} #{fmt(@rhs)}"
+    end
+
+    def precedence
+      case @op
+      when :*, :/, :%
+        return 2
+      when '+'.intern, '-'.intern
+        return 3
+      when :<<, :>>
+        return 4
+      when :>, :>=, :<, :<=, :==, :===, :!=
+        return 5
+      when :undef
+        return 6
+      else
+        raise ArgumentError, "Unknown op: #{@op}"
+      end
+    end
+  end
+
+  class Prefix < Expression
+    def initialize(pc, op, expr)
+      super(pc)
+      @op = op
+      @expr = expr
+    end
+
+    def to_s
+      op = @op.to_s
+      op.chop! if op[-1] == ?@
+      if @op == '!'.intern and @expr.is_a?(Infix) and @expr.op == :== then
+        return "#{@expr.fmt(@expr.lhs)} != #{@expr.fmt(@expr.rhs)}"
+      elsif self.precedence < @expr.precedence then
+        return "#{op}(#{@expr})"
+      else
+        return "#{op}#{@expr}"
+      end
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Send < Expression
+    attr_reader :is_assignment
+
+    def initialize(pc, id, has_receiver, has_parens, receiver, block, splat_last, *args)
+      super(pc)
+      @id = id
+      @is_assignment = id.to_s[-1] == ?=
+      @has_receiver = has_receiver
+      @has_parens = has_parens
+      @receiver = receiver
+      @block = block
+      @splat_last = splat_last
+      @args = args
+    end
+
+    def to_s
+      s = ''
+      receiver_str = @has_receiver \
+        ? "#{@receiver}." \
+        : nil
+      args = @args.map { |x| x.to_s }
+      if @splat_last then
+        args[-1] = "*#{@args[-1]}"
+      end
+      if @is_assignment and args.size == 1 then
+        s = "#{receiver_str}#{@id.to_s[0..-2]} = #{args[0]}"
+      else
+        open = @has_parens ? '(' : ''
+        close = @has_parens ? ')' : ''
+        s = "#{receiver_str}#{@id}#{open}#{args.join(', ')}#{close}"
+      end
+      if @block then
+        # TODO: this code is duplicated elsewhere
+        # TODO: handle block args
+        env = Environment.new(@block.local_table)
+        @block.bytedecode(env)
+        expressions = env.expressions + env.stack
+        expressions.sort!
+        expressions.map! { |x| x.to_s }
+        if expressions.length == 1 and
+           expressions[0].is_a?(Literal) and
+           expressions[0].value == nil then
+          # empty
+        else
+          s << " { #{expressions.join('; ')} }"
+        end
+      end
+      return s
+    end
+
+    def precedence
+      if @has_receiver then
+        if @receiver.respond_to?(:precedence) then
+          return @receiver.precedence
+        end
+      end
+      return 1
+    end
+  end
+
+  class Self < Expression
+    def initialize(pc)
+      super(pc)
+    end
+
+    def to_s
+      return "self"
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Hash < Expression
+    def initialize(pc, args)
+      super(pc)
+      @args = args
+    end
+
+    def to_s
+      s = '{ '
+      a = []
+      i = 0
+      while i < @args.length do
+        a << "#{@args[i]} => #{@args[i + 1]}"
+        i += 2
+      end
+      s << a.join(', ')
+      s << ' ' if a.length != 0
+      s << '}'
+      return s
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Array < Expression
+    def initialize(pc, args)
+      super(pc)
+      @args = args
+    end
+
+    def to_s
+      s = '[ '
+      s << @args.join(', ')
+      s << ' ]'
+      return s
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class ConcatArray < Expression
+    def initialize(array, splat)
+      @array = array
+      @splat = splat
+    end
+
+    def to_s
+      s = '[ '
+      case @array
+      when Array then s << @array.args.join(', ')
+      when Literal then s << @array.value.join(', ')
+      else; raise "Unexpected: #{@array.inspect}"
+      end
+      s << ', *'
+      s << @splat.to_s
+      s << ' ]'
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Defined < Expression
+    def initialize(pc, arg)
+      super(pc)
+      @arg = arg
+    end
+
+    def to_s
+      return "defined?(#{@arg.to_s})"
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Variable < Expression
+    def initialize(pc, name)
+      super(pc)
+      @name = name
+    end
+
+    def to_s
+      return @name.to_s
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Constant < Expression
+    def initialize(pc, klass, name)
+      super(pc)
+      @klass = klass
+      @name = name
+    end
+
+    def to_s
+      if @klass then
+        if @klass == Object then
+          return "::#{@name}"
+        else
+          return "#{@klass}::#{@name}"
+        end
+      else
+        return "#{@name}"
+      end
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class ConstantAssignment < Constant
+    def initialize(pc, klass, name, value)
+      super(pc, klass, name)
+      @value = value
+    end
+
+    def to_s
+      s = super()
+      s << " = #{@value}"
+      return s
+    end
+  end
+
+  class ConcatStrings < Expression
+    def initialize(pc, args)
+      super(pc)
+      @args = args
+    end
+
+    def to_s
+      s = "\""
+      @args.each do |arg|
+        case arg
+        when Literal
+          case arg.value
+          when String then s << arg.value
+          else; s << arg.to_s
+          end
+        else
+          s << "\#{#{arg.to_s}}"
+        end
+      end
+      s << "\""
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Assignment < Expression
+    attr_reader :rhs
+
+    def initialize(pc, name, rhs)
+      super(pc)
+      @name = name
+      @rhs = rhs
+    end
+
+    def to_s
+      return "#{@name} = #{@rhs}"
+    end
+
+    def precedence
+      return 5
+    end
+  end
+
+  class ToRegexp < Expression
+    def initialize(pc, value)
+      super(pc)
+      @value = value
+    end
+
+    def to_s
+      case @value
+      when ConcatStrings
+        string = @value.to_s
+        unstring = string[1..-2]
+        return Regexp.compile(unstring).inspect
+      else
+        return Regexp.compile(@value.to_s).inspect
+      end
+    end
+
+    def precedence
+      return 1
+    end
+  end
+
+  class Throw < Expression
+    def initialize(pc, value)
+      super(pc)
+      @value = value
+    end
+
+    def to_s
+      # TODO: not all throws are breaks...
+      if not @value or (@value.is_a?(Literal) and @value.value == nil) then
+        return "break"
+      else
+        return "break #{@value}"
+      end
+    end
+
+    def precedence
+      return 1
+    end
+  end
+end
+
+end # ByteDecoder
+
+end # Internal
+
+class RubyVM
+  class Instruction
+    include Internal::ByteDecoder
+
+    class PUTOBJECT
+      def bytedecode(env)
+        env.stack.push Expression::Literal.new(env.pc, self.operands[0])
+      end
+    end
+
+    INFIX_OPCODES = {
+      OPT_PLUS  => '+'.intern,
+      OPT_MINUS => '-'.intern,
+      OPT_MULT  => :*,
+      OPT_DIV   => :/,
+      OPT_MOD   => :%,
+      OPT_LTLT  => :<<,
+      # OPT_GTGT  => :>>,
+      OPT_EQ    => :==,
+      OPT_NEQ   => :!=,
+      OPT_GT    => :>,
+      OPT_GE    => :>=,
+      OPT_LT    => :<,
+      OPT_LE    => :<=,
+    }
+
+    INFIX_OPERATORS = INFIX_OPCODES.values + [ :===, :>> ]
+
+    INFIX_OPCODES.each do |klass, op|
+      klass.class_eval do
+        define_method(:bytedecode) do |env|
+          rhs = env.stack.pop
+          lhs = env.stack.pop
+          env.stack.push Expression::Infix.new(env.pc, op, lhs, rhs)
+        end
+      end
+    end
+
+    PREFIX_OPCODES = {
+      OPT_NOT   => :!,
+    }
+
+    if defined?(UNDEF)
+      PREFIX_OPCODES[UNDEF] = :undef
+    end
+
+    PREFIX_OPERATORS = PREFIX_OPCODES.values + [ :~, :+@, :-@ ]
+
+    PREFIX_OPCODES.each do |klass, op|
+      klass.class_eval do
+        define_method(:bytedecode) do |env|
+          expr = env.stack.pop
+          env.stack.push Expression::Prefix.new(env.pc, op, expr)
+        end
+      end
+    end
+
+    class TRACE
+      def bytedecode(env)
+      end
+    end
+
+    class LEAVE
+      def bytedecode(env)
+      end
+    end
+
+    LITERAL_OPCODES = [
+      PUTNIL,
+      DUPARRAY,
+      PUTSTRING,
+    ]
+
+    LITERAL_OPCODES.each do |klass|
+      klass.class_eval do
+        define_method(:bytedecode) do |env|
+          env.stack.push Expression::Literal.new(env.pc, @operands[0])
+        end
+      end
+    end
+
+    class SEND
+      def bytedecode(env)
+        id = @operands[0]
+        num_args = @operands[1]
+        args = []
+        num_args.times do
+          args.unshift env.stack.pop
+        end
+        has_receiver = !flag_set(RubyVM::CALL_FCALL_BIT)
+        has_parens = !flag_set(RubyVM::CALL_VCALL_BIT)
+        splat_last = flag_set(RubyVM::CALL_ARGS_SPLAT_BIT)
+        receiver = env.stack.pop
+        block = @operands[2]
+        if INFIX_OPERATORS.include?(id) and args.size == 1 then
+          env.stack.push Expression::Infix.new(env.pc, id, receiver, args[0])
+        elsif PREFIX_OPERATORS.include?(id) and args.size == 0 then
+          env.stack.push Expression::Prefix.new(env.pc, id, receiver)
+        else
+          env.stack.push Expression::Send.new(
+              env.pc, id, has_receiver, has_parens, receiver, block, splat_last, *args)
+        end
+      end
+
+      def flag_set(flag)
+        flags = @operands[3]
+        return flags & flag == flag
+      end
+    end
+
+    class PUTSELF
+      def bytedecode(env)
+        env.stack.push Expression::Self.new(env.pc)
+      end
+    end
+
+    class NEWHASH
+      def bytedecode(env)
+        i = @operands[0]
+        args = []
+        while i > 0 do
+          args.unshift env.stack.pop
+          i -= 1
+        end
+        env.stack.push Expression::Hash.new(env.pc, args)
+      end
+    end
+
+    class NEWARRAY
+      def bytedecode(env)
+        i = @operands[0]
+        args = []
+        while i > 0 do
+          args.unshift env.stack.pop
+          i -= 1
+        end
+        env.stack.push Expression::Array.new(env.pc, args)
+      end
+    end
+
+    class DEFINED
+      def bytedecode(env)
+        env.stack.push Expression::Defined.new(env.pc, @operands[1])
+      end
+    end
+
+    GET_VARIABLE_OPCODES = [
+      GETCLASSVARIABLE,
+      GETINSTANCEVARIABLE,
+      GETGLOBAL,
+    ]
+
+    GET_VARIABLE_OPCODES.each do |klass|
+      klass.class_eval do
+        define_method(:bytedecode) do |env|
+          env.stack.push Expression::Variable.new(env.pc, @operands[0])
+        end
+      end
+    end
+
+    SET_VARIABLE_OPCODES = [
+      SETCLASSVARIABLE,
+      SETINSTANCEVARIABLE,
+      SETGLOBAL,
+    ]
+
+    SET_VARIABLE_OPCODES.each do |klass|
+      klass.class_eval do
+        define_method(:bytedecode) do |env|
+          value = env.stack.pop
+          env.stack.delete_at(-1) # TODO: dup'd value.. is this right?
+          env.stack.push Expression::Assignment.new(env.pc, @operands[0], value)
+        end
+      end
+    end
+
+    class GETCONSTANT
+      def bytedecode(env)
+        klass = env.stack.pop
+        env.stack.push Expression::Constant.new(env.pc, klass, @operands[0])
+      end
+    end
+
+    class SETCONSTANT
+      def bytedecode(env)
+        klass = env.stack.pop
+        value = env.stack.pop
+        env.stack.push Expression::ConstantAssignment.new(env.pc, klass, @operands[0], value)
+      end
+    end
+
+    class GETSPECIAL
+      def bytedecode(env)
+        type = @operands[1] >> 1
+        type += ?0.ord if type < 10
+        env.stack.push Expression::Variable.new(env.pc, "$#{type.chr}")
+      end
+    end
+
+    class GETINLINECACHE
+      def bytedecode(env)
+        env.stack.push nil
+      end
+    end
+
+    class SETINLINECACHE
+      def bytedecode(env)
+      end
+    end
+
+    class NOP
+      def bytedecode(env)
+      end
+    end
+
+    class TOSTRING
+      def bytedecode(env)
+      end
+    end
+
+    class CONCATSTRINGS
+      def bytedecode(env)
+        i = @operands[0]
+        args = []
+        while i > 0 do
+          args.unshift env.stack.pop
+          i -= 1
+        end
+        env.stack.push Expression::ConcatStrings.new(env.pc, args)
+      end
+    end
+
+    class TOREGEXP
+      def bytedecode(env)
+        env.stack.push Expression::ToRegexp.new(env.pc, env.stack.pop)
+      end
+    end
+
+    class DUP
+      def bytedecode(env)
+        arg = env.stack.pop
+        env.stack.push arg
+        env.stack.push arg
+      end
+    end
+
+    class SETLOCAL
+      def bytedecode(env)
+        idx = env.local_table.size - @operands[0] + 1
+        name = env.local_table[idx]
+        value = env.stack.pop
+        env.stack.push Expression::Assignment.new(env.pc, name, value)
+      end
+    end
+
+    class GETLOCAL
+      def bytedecode(env)
+        idx = env.local_table.size - @operands[0] + 1
+        name = env.local_table[idx]
+        env.stack.push Expression::Variable.new(env.pc, name)
+      end
+    end
+
+    class SETDYNAMIC
+      def bytedecode(env)
+        idx = env.local_table.size - @operands[0]
+        name = env.local_table[idx]
+        value = env.stack.pop
+        env.stack.push Expression::Assignment.new(env.pc, name, value)
+      end
+    end
+
+    class GETDYNAMIC
+      def bytedecode(env)
+        idx = env.local_table.size - @operands[0]
+        name = env.local_table[idx]
+        env.stack.push Expression::Variable.new(env.pc, name)
+      end
+    end
+
+    class SETN
+      # set nth stack entry to stack top
+      def bytedecode(env)
+        n = @operands[0]
+        dest = -(n+1)
+        if env.stack[dest].is_a?(Expression) then
+          env.remember env.stack[dest]
+        end
+        env.stack[dest] = env.stack[-1]
+      end
+    end
+
+    class TOPN
+      # get nth stack entry from stack top
+      def bytedecode(env)
+        n = @operands[0]
+        idx = -(n+1)
+        env.stack[idx]
+      end
+    end
+
+    class POP
+      def bytedecode(env)
+        top = env.stack[-1]
+        if top.is_a?(Expression::Send) and top.is_assignment then
+          # special case - the return value from the assignment gets
+          # thrown away and the result is the rhs
+          env.remember env.stack[-2]
+          env.stack.delete_at(-2)
+        end
+        env.remember top
+        env.stack.pop
+      end
+    end
+
+    class THROW
+      def bytedecode(env)
+        value = env.stack.pop
+        env.remember env.stack.pop
+        env.stack.push Expression::Throw.new(env.pc, value)
+      end
+    end
+
+    class CONCATARRAY
+      def bytedecode(env)
+        splat = env.stack.pop
+        array = env.stack.pop
+        env.stack.push Expression::ConcatArray.new(array, splat)
+      end
+    end
+  end
+
+  class InstructionSequence
+    def bytedecode(env, start_pc=0, end_pc=nil, &block)
+      self.each(start_pc) do |instruction|
+        # p instruction
+        instruction.bytedecode(env)
+        # p env.stack
+        env.advance(instruction.length)
+        break if end_pc and env.pc >= end_pc
+        break if block and block.call(instruction)
+      end
+    end
+
+    def opt_pc
+      opt_table = self.arg_opt_table
+      return opt_table.length > 0 ? opt_table[-1] : 0
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  # def foo; @@foo = 1; end
+  # def foo; a = [2, 3]; foo(1, *a); end
+  # def foo; not true; end
+  # def foo; catch(:foo) { throw :foo; 42 }; end
+  # def foo; a ? b : c; end
+  # def foo; loop { a = 1; break }; end
+  # def foo; ::BAR; end
+  # def foo; a != b; end
+  # def foo; 1 - 2; end
+  # def foo; +a; end
+  # def foo; !a; end
+  # def foo; a << b; end
+  # def foo; a === b; end
+  # def foo; []; end
+  def foo; foo.bar = 42; end
+  # def foo; h = {}; h.default = true; h; end
+  # def foo; @FOO; end
+  # def foo; $FOO; end
+  # def foo; /foo#{bar}/; end
+  # def foo; /foo/; end
+  # def foo; foo = 1; bar=2; baz=3 end
+  # def foo; "foo#{bar}"; end
+  # def foo; $`; end
+  # def foo; FOO; end
+  # def foo; @@foo; end
+  # def foo; defined?(FOO); end
+  # def foo; [1+1, 2, 3, 4] ; end
+  # def foo; { 1 => 2, 3 => 4 }; end
+  # def foo; foo(1 + 2 * (3 + 4), 5); end
+  # def foo; 1 + 2 * (3 + 4); end
+
+  n = method(:foo).body
+  is = n.body
+  puts is.disasm
+
+  env = Internal::ByteDecoder::Environment.new(is.local_table)
+  s = ''
+  # puts "local_table = #{is.local_table.inspect}"
+  is.each do |i|
+    # p i.operand_types, i.operand_names
+    # p i #, i.operand_types, i.operand_names
+    print i.class, ' '
+    a = []
+    i.operand_names.each_with_index do |name, idx|
+      a << "#{name}(#{i.operand_types[idx]})=#{i.operands[idx].inspect}"
+    end
+    puts a.join(', ')
+    i.bytedecode(env)
+    env.advance(i.length)
+    # p env.stack
+    # p env.stack.map { |x| x.to_s }
+    # puts
+  end
+
+  puts "---"
+  (env.expressions + env.stack).sort.each do |expr|
+    puts expr.to_s
+  end
+end
+