rbx-trepanning 0.0.5-universal-rubinius-1.2.1

data/processor/command/step.rb

@@ -0,0 +1,84 @@
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../stepping'
+
+class Trepan::Command::StepCommand < Trepan::Command
+
+  ALIASES      = %w(s s+ s- step+ step-)
+  CATEGORY     = 'running'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP         = <<-HELP
+#{NAME}[+|-] [into]  [count]
+#{NAME} over [args..]
+#{NAME} out  [args..]
+
+Execute the current line, stopping at the next line.  Sometimes this
+is called 'step into'.
+
+Behaves like 'next', but if there is a method call on the current line,
+execution is stopped in the called method.
+
+Examples: 
+  #{NAME}        # step 1 line
+  #{NAME} 1      # same as above
+  #{NAME} into   # same as above
+  #{NAME} into 1 # same as above
+  #{NAME} 5/5+0  # same as above
+  #{NAME}+       # same but force stopping on a new line
+  #{NAME}-       # same but force stopping on a new line a new frame added
+  #{NAME} over   # same as 'next'
+  #{NAME} out    # same as 'finish'
+
+Related and similar is the 'next' (step over) and 'finish' (step out)
+commands.
+
+See also the commands:
+'continue', 'next', 'nexti' and 'finish' for other ways to progress execution.
+      HELP
+  NEED_RUNNING = true
+  SHORT_HELP   = 'Step into next method call or to next line'
+
+  Keyword_to_related_cmd = {
+    'out'  => 'finish',
+    'over' => 'next',
+    'into' => 'step',
+  }
+  
+  def run(args)
+    if args.size == 1
+      step_count = 1
+      opts = {}
+    else
+      replace_cmd = Keyword_to_related_cmd[args[1]]
+      if replace_cmd
+        cmd = @proc.commands[replace_cmd]
+        return cmd.run([replace_cmd] + args[2..-1])
+      else
+        step_str = args[1]
+        opts = @proc.parse_next_step_suffix(args[0])
+        count_opts = {
+          :msg_on_error => 
+          "The #{NAME} command argument must eval to an integer. Got: %s" % 
+          step_str,
+          :min_value => 1
+        }
+        step_count = @proc.get_an_int(step_str, count_opts)
+        return unless step_count
+      end
+    end
+    
+    @proc.step('step', step_count, opts)
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  [%W(#{cmd.name}), %W(#{cmd.name} 2), %W(#{cmd.name} into 1+2),
+   %W(#{cmd.name} over)].each do |c|
+    cmd.proc.instance_variable_set('@return_to_program', false)
+    cmd.run(c)
+    puts 'return_to_program: %s' % cmd.proc.instance_variable_get('@return_to_program')
+    puts 'step_count: %s' % cmd.proc.instance_variable_get('@step_count')
+  end
+end

data/processor/command/tbreak.rb

@@ -0,0 +1,19 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+require_relative 'break'
+
+class Trepan::Command::SetTempBreakpointCommand < 
+    Trepan::Command::SetBreakpointCommand
+  ALIASES      = %w(tb tbrk)
+  CATEGORY     = 'breakpoints'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP         = <<-HELP
+Same as break, but the breakpoint is deleted when it is hit.
+      HELP
+  SHORT_HELP   = 'Set a temporary breakpoint'
+  
+  def run(args)
+    super args, true
+  end
+end
+

data/processor/command/unalias.rb

@@ -0,0 +1,44 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+class Trepan::Command::UnaliasCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"unalias COMMAND
+
+Remove alias for COMMAND
+
+See also 'alias'.
+"
+
+    CATEGORY      = 'support'
+    MIN_ARGS      = 1
+    # MAX_ARGS      = 1  # Need at most this many
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = true
+    SHORT_HELP    = 'Remove an alias'
+  end
+  
+  # Run command. 
+  def run(args)
+    args[1..-1].each do |arg|
+      if @proc.aliases.member?(arg)
+        @proc.aliases.delete(arg)
+        msg "Alias for #{arg} removed."
+      else
+        msg "No alias found for #{arg}."
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run %w(cmd.name n)
+  cmd.run %w(cmd.name n)
+  cmd.run %w(cmd.name foo bar c)
+end

data/processor/command/undisplay.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+# undisplay display-number...
+class Trepan::Command::UndisplayCommand < Trepan::Command
+    
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<EOH
+undisplay DISPLAY_NUMBER ...
+Cancel some expressions to be displayed when program stops.
+Arguments are the code numbers of the expressions to stop displaying.
+No argument means cancel all automatic-display expressions.
+"delete display" has the same effect as this command.
+Do "info display" to see current list of code numbers.
+EOH
+
+    ALIASES       = %w(und)
+    CATEGORY      = 'data'
+    NEED_STACK    = false
+    SHORT_HELP    = 'Cancel some expressions to be displayed when program stops'
+  end
+
+  def run(args)
+    
+    if args.size == 1
+      @proc.displays.clear
+      return
+    end
+    opts = {}
+    args[1..-1].each do |arg|
+      opts[:msg_on_error] = '%s must be a display number' % arg
+      i = @proc.get_an_int(arg, opts)
+      if i 
+        unless @proc.displays.delete_index(i)
+          errmsg("no display number %d." % i)
+          return
+        end
+      end
+      return false
+    end
+  end
+end
+
+if __FILE__ == $0
+  # demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  def run_cmd(cmd, args)
+    cmd.run(args)
+    puts '==' * 10
+  end
+
+  run_cmd(cmd, %W(#{cmd.name} z))
+  run_cmd(cmd, %W(#{cmd.name} 1 10))
+end

data/processor/command/up.rb

@@ -0,0 +1,86 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+# up command. Like 'down' butthe direction (set by DIRECTION) is different.
+#
+# NOTE: The down command  subclasses this, so beware when changing!
+class Trepan::Command::UpCommand < Trepan::Command
+
+  # Silence already initialized constant .. warnings
+  old_verbose = $VERBOSE
+  $VERBOSE    = nil
+  HELP        =
+"u(p) [count]
+
+Move the current frame up in the stack trace (to an older frame). 0 is
+the most recent frame. If no count is given, move up 1.
+
+See also 'down' and 'frame'.
+"
+
+  ALIASES       = %w(u)
+  CATEGORY      = 'stack'
+  MAX_ARGS      = 1  # Need at most this many
+  NAME          = File.basename(__FILE__, '.rb')
+  NEED_STACK    = true
+  SHORT_HELP    = 'Move frame in the direction of the caller of the last-selected frame'
+  $VERBOSE      = old_verbose
+
+  def initialize(proc)
+    super
+    @direction = +1 # -1 for down.
+  end
+
+  # Run 'up' command.
+  def run(args)
+
+    # FIXME: move into @proc and test based on NEED_STACK.
+    if @proc.stack_size == 0
+      errmsg('No frames recorded.')
+      return false
+    end
+
+    if args.size == 1
+      # Form is: "up" which means "up 1"
+      count = 1
+    else
+      count_str = args[1]
+      name_or_id = args[1]
+      opts = {
+        :msg_on_error =>
+        "The '#{NAME}' command argument must eval to an integer. Got: %s" % count_str,
+        :min_value => -@proc.stack_size,
+        :max_value => @proc.stack_size-1
+      }
+      count = @proc.get_an_int(count_str, opts)
+      return false unless count
+    end
+    @proc.adjust_frame(@direction * count, false)
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  # def sep ; puts '=' * 40 end
+  # cmd.run [cmd.name]
+  # %w(-1 0 1 -2).each do |count|
+  #   puts "#{cmd.name} #{count}"
+  #   cmd.run([cmd.name, count])
+  #   sep
+  # end
+  # def foo(cmd, cmd.name)
+  #   puts "#{cmd.name}"
+  #   cmd.run([cmd.name])
+  #   sep
+  #   %w(-2 -1).each do |count|
+  #     puts "#{cmd.name} #{count}"
+  #     cmd.run([cmd.name, count])
+  #     sep
+  #   end
+  # end
+  # foo(cmd, cmd.name)
+end

data/processor/default.rb

@@ -0,0 +1,58 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../app/default'
+class Trepan
+  class CmdProcessor
+
+    DEFAULT_SETTINGS = {
+      :autoeval      => true,      # Ruby eval non-debugger commands
+      :autoirb       => false,     # Go into IRB in debugger command loop
+      :autolist      => false,     # Run 'list' 
+
+      :basename      => false,     # Show basename of filenames only
+      :confirm       => true,      # Confirm potentially dangerous operations?
+      :different     => 'nostack', # stop *only* when  different position? 
+
+      :debugdbgr     => false,     # Debugging the debugger
+      :debugexcept   => true,      # Internal debugging of command exceptions
+      :debugmacro    => false,     # debugging macros
+      :debugskip     => false,     # Internal debugging of step/next skipping
+      :directory     =>            # last-resort path-search for files
+                    '$cdir:$cwd',  # that are not fully qualified.
+
+      :hidestack     => nil,       # Fixnum. How many hidden outer
+                                   # debugger stack frames to hide?
+                                   # nil or -1 means compute value. 0
+                                   # means hide none. Less than 0 means show
+                                   # all stack entries.
+      :hightlight    => false,     # Use terminal highlight? 
+      
+      :maxlist       => 10,        # Number of source lines to list 
+      :maxstack      => 10,        # backtrace limit
+      :maxstring     => 150,       # Strings which are larger than this
+                                   # will be truncated to this length when
+                                   # printed
+      :maxwidth       => (ENV['COLUMNS'] || '80').to_i,
+      :prompt         => 'trepanx', # core part of prompt. Additional info like
+                                   # debug nesting and 
+      :save_cmdfile  => nil,       # If set, debugger command file to be
+                                   # used on restart
+      :timer         => false,     # show elapsed time between events
+      :traceprint    => false,     # event tracing printing
+      :tracebuffer   => false,     # save events to a trace buffer.
+      :user_cmd_dir  => File.join(Trepan::HOME_DIR, 'tepanx', 'command'),
+                                   # User command directory
+
+      # Rubinius-specific user variables
+      :show_ip         => false,
+      :show_bytecode   => false,
+
+    } unless defined?(CmdProcessor::DEFAULT_SETTINGS)
+  end
+end
+
+if __FILE__ == $0
+  # Show it:
+  require 'pp'
+  PP.pp(Trepan::CmdProcessor::DEFAULT_SETTINGS)
+end

data/processor/disassemble.rb

@@ -0,0 +1,46 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../app/iseq'
+
+class Trepan
+  class CmdProcessor
+
+    def show_bytecode(line=@frame.vm_location.line)
+      meth = @frame.method
+      start = meth.first_ip_on_line(line)
+      fin = meth.first_ip_on_line(line+1)
+
+      if fin == -1
+        fin = meth.iseq.size
+      end
+
+      start += 1 if start == -1
+      section "Bytecode between #{start} and #{fin-1} for line #{line}"
+
+      iseq_decoder = Rubinius::InstructionDecoder.new(meth.iseq)
+      partial = iseq_decoder.decode_between(start, fin)
+
+      ip = start
+
+      prefixes = []
+      disasm = partial.inject('') do |result, ins|
+        inst = Rubinius::CompiledMethod::Instruction.new(ins, meth, ip)
+        prefixes << ISeq::disasm_prefix(ip, frame.next_ip, meth)
+        ip += ins.size
+        result += "#{inst}\n"
+      end
+
+      # FIXME DRY with command/disassemble.rb
+      if @settings[:highlight]
+        require_relative '../app/rbx-llvm'
+        @llvm_highlighter = CodeRay::Duo[:llvm, :term]
+        # llvm_scanner = CodeRay.scanner :llvm
+        # p llvm_scanner.tokenize(disasm)
+        disasm = @llvm_highlighter.encode(disasm)
+      end
+      disasm.split("\n").each_with_index do |inst, i|
+        msg "#{prefixes[i]} #{inst}", :unlimited => true
+      end
+    end
+  end
+end

data/processor/display.rb

@@ -0,0 +1,18 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../app/display'
+class Trepan
+  class CmdProcessor
+    attr_reader   :displays
+
+    def display_initialize
+      @displays = DisplayMgr.new
+    end
+
+    def run_eval_display(args={})
+      for line in @displays.display(@frame) do 
+        msg(line)
+      end
+    end
+  end
+end

data/processor/eval.rb

@@ -0,0 +1,96 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  class CmdProcessor
+
+    def debug_eval(str, max_fake_filename=15)
+      begin
+        debug_eval_with_exception(str, max_fake_filename)
+      rescue SyntaxError, StandardError, ScriptError => e
+        exception_dump(e, @settings[:stack_trace_on_error], $!.backtrace)
+        nil
+      end
+    end
+
+    def debug_eval_with_exception(str, max_fake_filename=15)
+      @frame.run(str, fake_eval_filename(str, max_fake_filename))
+    end
+
+    def debug_eval_no_errmsg(str, max_fake_filename=15)
+      begin
+        debug_eval_with_exception(str, max_fake_filename)
+      rescue SyntaxError, StandardError, ScriptError => e
+        nil
+      end
+    end
+
+    def eval_code(str, max_fake_filename)
+      obj = debug_eval(str, max_fake_filename)
+      
+      idx = @user_variables
+      @user_variables += 1
+      
+      str = "$d#{idx}"
+      Rubinius::Globals[str.to_sym] = obj
+      msg "#{str} = #{obj.inspect}"
+      obj
+    end
+
+    def exception_dump(e, stack_trace, backtrace)
+      str = "#{e.class} Exception:\n\t#{e.message}"
+      if stack_trace
+        str += "\n" + backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+      end
+      msg str
+      # throw :debug_error
+    end
+
+    def fake_eval_filename(str, maxlen = 15)
+      fake_filename = 
+        if maxlen < str.size
+          # FIXME: Guard against \" in positions 13..15?
+          str.inspect[0..maxlen-1] + '"...'
+        else
+          str.inspect
+        end
+      "(eval #{fake_filename})"
+    end
+    
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  cmdp = Trepan::CmdProcessor.new
+  puts cmdp.fake_eval_filename('x = 1; y = 2')
+  puts cmdp.fake_eval_filename('x = 1; y = 2', 7)
+  def cmdp.errmsg(msg)
+    puts "** #{msg}"
+  end
+  def cmdp.msg(msg)
+    puts "#{msg}"
+  end
+  begin 
+    1/0
+  rescue Exception => exc
+    cmdp.exception_dump(exc, true, $!.backtrace)
+    puts '=' * 40
+  end
+
+  x = 10
+
+  require 'rubygems'; require 'require_relative'
+  require_relative '../app/frame'
+  frame = Trepan::Frame.new(self, 1, Rubinius::VM.backtrace(0)[0])
+  cmdp.instance_variable_set('@frame', frame)
+  cmdp.instance_variable_set('@settings', {:stack_trace_on_error => true})
+  def cmdp.errmsg(mess) ; puts mess end
+  # require_relative '../lib/trepanning'
+  # Trepan.start
+  puts cmdp.debug_eval('x = "#{x}"')
+  puts '=' * 40
+  puts cmdp.debug_eval('x+')
+  puts cmdp.debug_eval_no_errmsg('y+')
+  puts '=' * 40
+  puts cmdp.debug_eval('x+')
+  puts cmdp.debug_eval('y = 1; x+', 4)
+end