rbx-trepanning 0.2.0-universal-rubinius-2.0

data/processor/command/list.rb

@@ -0,0 +1,234 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'require_relative'
+require 'linecache'
+require_relative '../command'
+require_relative '../list'
+
+class Trepan::Command::ListCommand < Trepan::Command
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME}[>] [MODULE] [FIRST [NUM]]
+#{NAME}[>] LOCATION [NUM]
+
+#{NAME} source code. 
+
+Without arguments, prints lines centered around the current
+line. If this is the first #{NAME} command issued since the debugger
+command loop was entered, then the current line is the current
+frame. If a subsequent #{NAME} command was issued with no intervening
+frame changing, then that is start the line after we last one
+previously shown.
+
+If the command has a '>' suffix, then line centering is disabled and
+listing begins at the specificed location.
+
+The number of lines to show is controlled by the debugger "listsize"
+setting. Use 'set max list' or 'show max list' to see or set the
+value.
+
+\"#{NAME} -\" shows lines before a previous listing. 
+
+A LOCATION is a either 
+  - number, e.g. 5, 
+  - a function, e.g. join or os.path.join
+  - a module, e.g. os or os.path
+  - a filename, colon, and a number, e.g. foo.rb:5,  
+  - or a module name and a number, e.g,. os.path:5.  
+  - a '.' for the current line number
+  - a '-' for the lines before the current line number
+
+If the location form is used with a subsequent parameter, the
+parameter is the starting line number.  When there two numbers are
+given, the last number value is treated as a stopping line unless it
+is positive and less than the start line. In this case, it is taken to
+mean the number of lines to list instead. If last is negative, we start
+that many lines back from first and list to first.
+
+Wherever a number is expected, it does not need to be a constant --
+just something that evaluates to a positive integer.
+
+Some examples:
+
+#{NAME} 5            # List centered around line 5
+#{NAME} @5           # List lines centered around bytecode offset 5.
+#{NAME} 5>           # List starting at line 5
+#{NAME} foo.rb:5     # List centered around line 5 of foo.rb
+#{NAME} foo.rb 5     # Same as above.
+#{NAME}> foo.rb:5    # List starting around line 5 of foo.rb
+#{NAME} foo.rb  5 6  # list lines 5 and 6 of foo.rb
+#{NAME} foo.rb  5 2  # Same as above, since 2 < 5.
+#{NAME} foo.rb:5 2   # Same as above
+#{NAME} foo.rb 15 -5 # List lines 10..15 of foo
+#{NAME} FileUtils.cp # List lines around the FileUtils.cp function.
+#{NAME} .            # List lines centered from where we currently are stopped
+#{NAME} . 3          # List 3 lines starting from where we currently are stopped
+                     # if . > 3. Otherwise we list from . to 3.
+#{NAME} -            # List lines previous to those just shown
+
+The output of the #{NAME} command gives a line number, and some status
+information about the line and the text of the line. Here is some 
+hypothetical #{NAME} output modeled roughly around line 251 of one
+version of this code:
+
+  251    	  cmd.proc.frame_setup(tf)
+  252  ->	  brkpt_cmd.run(['break'])
+  253 B01   	  line = __LINE__
+  254 b02   	  cmd.run(['list', __LINE__.to_s])
+  255 t03   	  puts '--' * 10
+
+Line 251 has nothing special about it. Line 252 is where we are
+currently stopped. On line 253 there is a breakpoint 1 which is
+enabled, while at line 255 there is an breakpoint 2 which is
+disabled.
+    HELP
+
+    ALIASES       = %W(l #{NAME}> l> cat)
+    CATEGORY      = 'files'
+    MAX_ARGS      = 3
+    SHORT_HELP    = 'List source code'
+  end
+
+  def run(args)
+    if args.empty? and not frame
+      errmsg("No Ruby program loaded.")
+      return
+    end
+    listsize = settings[:maxlist]
+    center_correction = 
+      if args[0][-1..-1] == '>'
+        0
+      else
+        (listsize-1) / 2
+      end
+
+    cm, filename, first, last = 
+      @proc.parse_list_cmd(@proc.cmd_argstr, listsize, center_correction)
+    return unless filename
+    breaklist = @proc.brkpts.line_breaks(cm)
+
+    # We now have range information. Do the listing.
+    max_line = LineCache::size(filename)
+    unless max_line 
+      errmsg('File "%s" not found.' % filename)
+      return
+    end
+
+    if first > max_line
+      errmsg('Bad line range [%d...%d]; file "%s" has only %d lines' %
+             [first, last, filename, max_line])
+      return
+    end
+
+    if last > max_line
+      # msg('End position changed to last line %d ' % max_line)
+      last = max_line
+    end
+
+    begin
+      opts = {
+        :reload_on_change => settings[:reload],
+        :output => settings[:highlight]
+      }
+      frame = @proc.frame
+      first.upto(last).each do |lineno|
+        line = LineCache::getline(filename, lineno, opts)
+        unless line
+          msg('[EOF]')
+          break
+        end
+        line.chomp!
+        s = '%3d' % lineno
+        s = s + ' ' if s.size < 4 
+        s += if breaklist.member?(lineno)
+               bp = breaklist[lineno]
+               a_pad = '%02d' % bp.id
+               bp.icon_char
+             else 
+               a_pad = '  '
+               ' ' 
+             end
+        s += (frame && lineno == @proc.frame.line &&
+              filename == @proc.frame.file) ? '->' : a_pad
+        msg(s + "\t" + line, {:unlimited => true})
+        @proc.line_no = lineno
+      end
+    rescue => e
+      errmsg e.to_s if settings[:debugexcept]
+    end
+  end
+end
+
+if __FILE__ == $0
+  # require_relative '../../lib/trepanning'; debugger
+  require_relative '../location'
+  require_relative '../mock'
+  require_relative '../frame'
+  dbgr, cmd = MockDebugger::setup
+  cmd.proc.send('frame_initialize')
+  
+  def run_cmd(cmd, args)
+    cmd.proc.instance_variable_set('@cmd_argstr', args[1..-1].join(' '))
+    cmd.run(args)
+  end
+  
+  LineCache::cache(__FILE__)
+  run_cmd(cmd, [cmd.name])
+  run_cmd(cmd, [cmd.name, __FILE__ + ':10'])
+
+  def run_cmd2(cmd, args)
+    seps = '--' * 10
+    puts "%s %s %s" % [seps, args.join(' '), seps]
+    run_cmd(cmd,args)
+  end
+
+  require 'tmpdir.rb'
+  run_cmd2(cmd, %w(list tmpdir.rb 10))
+  run_cmd2(cmd, %w(list tmpdir.rb))
+
+  # cmd.proc.frame = sys._getframe()
+  # cmd.proc.setup()
+  # run_cmd2(['list'])
+
+  run_cmd2(cmd, %w(list .))
+  run_cmd2(cmd, %w(list 30))
+
+  # run_cmd2(['list', '9+1'])
+
+  run_cmd2(cmd, %w(list> 10))
+  run_cmd2(cmd, %w(list 3000))
+  run_cmd2(cmd, %w(list run_cmd2))
+
+  p = Proc.new do 
+    |x,y| x + y
+  end
+  run_cmd2(cmd, %w(list p))
+
+  # Function from a file found via an instruction sequence
+  run_cmd2(cmd, %w(list Columnize.columnize))
+
+  # Use Class/method name. 15 isn't in the function - should this be okay?
+  run_cmd2(cmd, %W(#{cmd.name} Columnize.columnize 15))
+
+  # Start line and count, since 3 < 30
+  run_cmd2(cmd, %W(#{cmd.name} Columnize.columnize 30 3))
+
+  # Start line finish line 
+  run_cmd2(cmd, %W(#{cmd.name} Columnize.columnize 40 50))
+
+  line = __LINE__
+  brkpt_cmd = cmd.proc.instance_variable_get('@commands')['break']
+  cmd.proc.instance_variable_set('@cmd_argstr', "#{__FILE__} #{line}")
+  brkpt_cmd.run(['break', __FILE__, line.to_s])
+  run_cmd2(cmd, [cmd.name, line.to_s])
+
+  # disable_cmd = cmd.proc.instance_variable_get('@commands')['disable']
+  # disable_cmd.run(['disable', '1'])
+
+  # run_cmd2(cmd, [cmd.name, line.to_s])
+  run_cmd2(cmd, %W(#{cmd.name} run_cmd2))
+  run_cmd2(cmd, %W(#{cmd.name} run_cmd2))
+  run_cmd2(cmd, %W(#{cmd.name} @713))
+end

data/processor/command/macro.rb

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../eval'
+class Trepan::Command::MacroCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME          = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} MACRO-NAME PROC-OBJECT
+
+Define MACRO-NAME as a debugger macro. Debugger macros get a list of
+arguments. Debugger macros get a list of arguments which you supply
+without parenthesis or commas. See below for an example.
+
+The macro (really a Ruby Proc) should return either a String or an
+Array of Strings. The string in both cases are strings of debugger
+commands.  If the return is a String, that gets tokenized by a simple
+String#split .  Note that macro processing is done right after
+splitting on ;; so if the macro returns a string containing ;; this
+will not be handled on the string returned.
+
+If instead, Array of Strings is returned, then the first string is
+shifted from the array and executed. The remaining strings are pushed
+onto the command queue. In contrast to the first string, subsequent
+strings can contain other macros, and ;; in those strings will be
+split into separate commands.
+
+Here is an example. The below creates a macro called fin+ which
+issues two commands 'finish' followed by 'step':
+
+  macro fin+ Proc.new{|*args| %w(finish step)}
+
+If you wanted to parameterize the argument of the 'finish' command
+you could do that this way:
+
+  macro fin+ Proc.new{|*args| ['finish \#{args[0]}' 'step']}
+
+Invoking with 
+  fin+ 3
+
+would expand to ["finish 3", "step"]
+
+If you were to add another parameter for 'step', the note that the 
+invocation might be 
+  fin+ 3 2
+
+rather than 'fin+(3,2)' or 'fin+ 3, 2'.
+
+See also 'info macro'.
+    HELP
+
+    CATEGORY      = 'support'
+    MIN_ARGS      = 2  # Need at least this many
+    SHORT_HELP    = 'Define a macro'
+  end
+  
+  def run(args)
+    cmd_name = args[1]
+    cmd_argstr = @proc.cmd_argstr[cmd_name.size..-1].lstrip
+    proc_obj = @proc.debug_eval(cmd_argstr, @proc.settings[:maxstring])
+    if proc_obj
+      if proc_obj.is_a?(Proc)
+        @proc.macros[cmd_name] = [proc_obj, cmd_argstr]
+        msg "Macro \"#{cmd_name}\" defined."
+      else
+        errmsg "Expecting a Proc object; got: #{cmd_argstr}"
+      end
+    end
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmdproc = cmd.proc
+  ["#{cmd.name} foo Proc.new{|x, y| 'x+y'}",
+   "#{cmd.name} bad2 1+2"].each do |cmdline|
+    args = cmdline.split
+    cmd_argstr = cmdline[args[0].size..-1].lstrip
+    cmdproc.instance_variable_set('@cmd_argstr', cmd_argstr)
+    cmd.run(args)
+  end
+  p cmdproc.macros
+end

data/processor/command/next.rb

@@ -0,0 +1,67 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../stepping'
+require_relative '../../app/breakpoint'
+
+class Trepan::Command::NextCommand < Trepan::Command
+
+  ALIASES      = %w(n)
+  CATEGORY     = 'running'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP= <<-HELP
+#{NAME} [NUM]
+
+Attempt to continue execution and stop at the next line. If there is
+a conditional branch between the current position and the next line,
+execution is stopped within the conditional branch instead.
+
+The optional argument is a number which specifies how many lines to
+attempt to skip past before stopping execution.
+
+If the current line is the last in a method, execution is stopped
+at the current position of the caller.
+
+See also 'step' and 'nexti'.
+      HELP
+  NEED_RUNNING = true
+  SHORT_HELP   =  'Move to the next line or conditional branch'
+
+  def run(args)
+    if args.size == 1
+      step_count = 1
+    else
+      step_str = args[1]
+      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, opts)
+      return unless step_count
+    end
+
+    @proc.step('next', step_count)
+    # @proc.next(step_count)
+  end
+  
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  # [%w(n 5), %w(next 1+2), %w(n foo)].each do |c|
+  #   dbgr.core.step_count = 0
+  #   cmd.proc.leave_cmd_loop = false
+  #   result = cmd.run(c)
+  #   puts 'Run result: %s' % result
+  #   puts 'step_count %d, leave_cmd_loop: %s' % [dbgr.core.step_count,
+  #                                               cmd.proc.leave_cmd_loop]
+  # end
+  # [%w(n), %w(next+), %w(n-)].each do |c|
+  #   dbgr.core.step_count = 0
+  #   cmd.proc.leave_cmd_loop = false
+  #   result = cmd.run(c)
+  #   puts cmd.proc.different_pos
+  # end
+end

data/processor/command/nexti.rb

@@ -0,0 +1,59 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../stepping'
+require_relative '../../app/breakpoint'
+require_relative '../../app/iseq'
+
+class Trepan::Command::NextInstructionCommand < Trepan::Command
+  ALIASES      = %w(ni)
+  CATEGORY     = 'running'
+  HELP         = <<-HELP
+Continue but stop execution at the next bytecode instruction.
+
+Does not step into send instructions.
+
+See also 'continue', 'step', and 'next' commands.
+      HELP
+  NAME         = File.basename(__FILE__, '.rb')
+  NEED_STACK   = true
+  SHORT_HELP   = 'Move to the next bytecode instruction'
+  
+  def run(args)
+    if args.size == 1
+      step = 1
+    else
+      step_str = args[1]
+      opts = {
+        :msg_on_error => 
+        "The 'next' command argument must eval to an integer. Got: %s" % 
+        step_str,
+        :min_value => 1
+      }
+      step = @proc.get_an_int(step_str, opts)
+      return unless step
+    end
+    
+    exec = current_method
+    insn = Rubinius::InstructionSet[exec.iseq[@proc.frame.next_ip]]
+    
+    next_ip = @proc.frame.next_ip + insn.width
+    
+    if next_ip >= exec.iseq.size
+      @proc.step_to_parent
+    elsif ISeq.goto_op?(exec, @proc.frame.next_ip)
+      @proc.set_breakpoints_between(exec, @proc.frame.next_ip, next_ip)
+    else
+      line = exec.line_from_ip(next_ip)
+      
+      bp = Breakpoint.for_ip(exec, next_ip, :event => 'vm-insn')
+      bp.scoped!(@proc.frame.scope)
+      bp.activate
+    end
+    @proc.continue('nexti')
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+end

data/processor/command/parsetree.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require 'pp'
+require_relative '../command'
+require_relative '../../app/cmd_parse'
+class Trepan::Command::ParseTreeCommand < Trepan::Command
+  
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [FILE]
+#{NAME} 
+
+In the first form, print a ParseTree S-expression of the current file
+or FILE.
+HELP
+      
+    # ALIASES       = %w(p)
+    MAX_ARGS      = 1
+    CATEGORY      = 'data'
+    SHORT_HELP    = 'PrettyPrint a ParseTree S-expression for a file'
+  end
+  
+  def run(args)
+    meth = nil
+    case args.size
+    when 1
+      file = @proc.frame.file
+    when 2
+      file = args[1]
+    else
+      errmsg 'Expecting a file name'
+    end
+    expanded_file = @proc.canonic_file(file)
+    if File.readable?(expanded_file)
+      section "ParseTree for file: #{expanded_file}"
+      msg File.to_sexp(expanded_file).pretty_inspect
+    else
+      errmsg "File #{expanded_file} is not readable."
+    end
+  end
+  
+  if __FILE__ == $0
+    require 'pp'
+    require_relative '../mock'
+    dbgr, cmd = MockDebugger::setup
+    cmd.run([cmd.name, __FILE__])
+  end
+  
+end

data/processor/command/pr.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+class Trepan::Command::PrCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = 
+      "#{NAME} EXPRESSION
+
+Print the value of the EXPRESSION. Variables accessible are those of the
+environment of the selected stack frame, plus globals. 
+
+If the length output string large, the first part of the value is
+shown and ... indicates it has been truncated.
+
+See 'set max string' to change the string truncation limit.
+"
+
+    # ALIASES       = %w(p)
+    CATEGORY      = 'data'
+    SHORT_HELP    = 'print expression truncating long output'
+  end
+  
+  def run(args)
+    msg @proc.debug_eval(@proc.cmd_argstr, settings[:maxstring])
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  arg_str = '1 + 2'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([cmd.name, arg_str])
+end

data/processor/command/ps.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../eval'
+class Trepan::Command::PsCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+      "ps ARRAY
+
+Print the value of the ARRAY in columns and sorted."
+
+    CATEGORY      = 'data'
+    MIN_ARGS      = 1  # Need least this many
+    NAME          = File.basename(__FILE__, '.rb')
+    SHORT_HELP    = 'Print array sorted and in columns'
+  end
+  
+  def run(args)
+    array = @proc.debug_eval(@proc.cmd_argstr, settings[:maxstring])
+    # FIXME: should test for enumerable
+    if array.is_a?(Array)
+      msg columnize_commands(array.sort)
+    else
+      errmsg "ps: #{@proc.cmd_argstr} should evaluate an Array not #{array.class}"
+    end
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  arg_str = '(1..30).to_a'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([cmd.name, arg_str])
+  arg_str = '1'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([cmd.name, arg_str])
+end

data/processor/command/restart.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../../app/run'
+class Trepan::Command::RestartCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME         = File.basename(__FILE__, '.rb')
+    ALIASES      = %w(R run)
+    HELP = <<-HELP
+#{NAME} 
+
+Restart debugger and program via an exec call. All state is lost, and
+new copy of the debugger is used.
+    HELP
+    
+    CATEGORY     = 'running'
+    MAX_ARGS     = 0  # Need at most this many
+    SHORT_HELP  = '(Hard) restart of program via exec()'
+  end
+    
+  # This method runs the command
+  def run(args)
+
+    dbgr = @proc.dbgr
+    argv = dbgr.restart_argv
+    if argv and argv.size > 0
+      @proc.run_cmd(%w(show args))
+      if not confirm('Restart (exec)?', false)
+        msg "Restart not confirmed"
+      else
+        if defined?(Trepan::PROG_UNRESOLVED_SCRIPT) &&
+            position = argv.index(Trepan::PROG_UNRESOLVED_SCRIPT)
+          save_filename = @proc.save_commands(:erase =>true)
+          argv.insert(position, '--command', save_filename) if save_filename
+        end
+        Dir.chdir(Rubinius::OS_STARTUP_DIR)
+        msg 'Restarting using...'
+        msg "\t #{argv.inspect}"
+        @proc.finalize
+        exec(*argv)
+      end
+    else
+      errmsg("No executable file and command options recorded.")
+    end
+  end
+end
+
+if __FILE__ == $0
+  exit if ARGV[-1] == 'exit'
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  dbgr.restart_argv = []
+  cmd.run([cmd.name])
+  dbgr.restart_argv = Rubinius::OS_ARGV + ['exit']
+  # require_relative '../../debugger'
+  # Trepan.start
+  cmd.run([cmd.name])
+end

data/processor/command/save.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+class Trepan::Command::SaveCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [--[no-]erase] [--output|-o FILENAME]
+
+Save settings to file FILENAME. If FILENAME not given one will be made
+selected.
+    HELP
+
+    CATEGORY     = 'running'
+    MAX_ARGS     = 1  # Need at most this many
+    SHORT_HELP  = 'Send debugger state to a file'
+
+    DEFAULT_OPTIONS = { :erase => true, }
+  end
+    
+  def parse_options(options, args) # :nodoc
+    parser = OptionParser.new do |opts|
+      opts.on("-e", "--[no-]erase", 
+              "Add line to erase after reading") do
+        |v| 
+        options[:erase] = v
+      end
+      opts.on("-o", "--output FILE", String, 
+              "Save file to FILE. ") do 
+        |filename|
+        options[:filename] = filename
+      end
+    end
+    parser.parse(args)
+    return options
+  end
+
+  # This method runs the command
+  def run(args)
+    options = parse_options(DEFAULT_OPTIONS.dup, args[1..-1])
+    save_filename = @proc.save_commands(options)
+    msg "Debugger commands written to file: #{save_filename}" if
+      save_filename
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  require 'tmpdir'
+  cmd.run([cmd.name])
+  # require_relative '../../lib/trepanning'; debugger
+  cmd.run([cmd.name, '--erase', 
+           '--output', File.join(Dir.tmpdir, 'save_file.txt')])
+  # A good test would be to see we can read in those files without error.
+end