trepanning 0.0.4

data/processor/command/list.rb

@@ -0,0 +1,327 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# -*- coding: utf-8 -*-
+require 'linecache'
+require_relative 'base/cmd'
+
+class Trepan::Command::ListCommand < Trepan::Command
+  unless defined?(HELP)
+    HELP = 
+"list[>] [MODULE] [FIRST [NUM]]
+list[>] LOCATION [NUM]
+
+List source code. 
+
+Without arguments, prints lines centered around the current
+line. If this is the first list command issued since the debugger
+command loop was entered, then the current line is the current
+frame. If a subsequent list 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 lines centering is disabled and
+listing begins at the specificed location.
+
+The number of line to show is controled by the debugger listsize
+setting. Use 'set listsize' or 'show listsize' to see or set the
+value.
+
+\"list -\" 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 less than the start line, in which case it is taken to mean the
+number of lines to list instead.
+
+Wherever a number is expected, it does not need to be a constant --
+just something that evaluates to a positive integer.
+
+Some examples:
+
+list 5            # List centered around line 5
+list 4+1          # Same as above.
+list 5>           # List starting at line 5
+list foo.rb:5     # List centered around line 5 of foo.rb
+list foo.rb 5     # Same as above.
+list foo.rb:5>    # List starting around line 5 of foo.rb
+list foo.rb  5 6  # list lines 5 and 6 of foo.rb
+list foo.rb  5 2  # Same as above, since 2 < 5.
+list foo.rb:5 2   # Same as above
+list FileUtils.cp # List lines around the FileUtils.cp function.
+list .            # List lines centered from where we currently are stopped
+list -            # List lines previous to those just shown
+
+The output of the list command give a line number, and some status
+information about the line and the text of the line. Here is some 
+hypothetical list 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."
+
+    ALIASES       = %w(l list> l>)
+    CATEGORY      = 'files'
+    MAX_ARGS      = 3
+    NAME          = File.basename(__FILE__, '.rb')
+    SHORT_HELP    = 'List source code'
+  end
+
+  # What a f*cking mess. Necessitated I suppose because we want to 
+  # allow somewhat flexible parsing with either module names, files or none
+  # and optional line counts or end-line numbers.
+  
+  # Parses arguments for the "list" command and returns the tuple:
+  # filename, start, last
+  # or sets these to nil if there was some problem.
+  def parse_list_cmd(args, listsize, center_correction)
+    
+    frame = @proc.frame
+    
+    container = @proc.frame_container(frame, false)
+
+    # FIXME: put into a helper routine
+    # See also duplicate code in print_location
+    if container[0] != 'file'
+      try_container = container
+      while try_container[0] != 'file' && frame.prev do
+        frame            = frame.prev
+        try_container = @proc.frame_container(frame, false)
+      end
+      container = try_container if try_container[0] == 'file'
+    end
+
+    filename = container[1]
+    
+    last = nil
+    if args.empty? and not frame
+      errmsg("No Ruby program loaded.")
+      return nil, nil, nil
+    end
+    
+    if args.size > 0
+      if args[0] == '-'
+        return no_frame_msg unless @proc.line_no
+        first = [1, @proc.line_no - 2*listsize - 1].max
+      elsif args[0] == '.'
+        return no_frame_msg unless @proc.line_no
+        first = [1, @proc.frame_line - center_correction].max
+      else
+        modfunc, container, first = @proc.parse_position(args[0])
+        if first == nil and modfunc == nil
+          # error should have been shown previously
+          return nil, nil, nil
+        end
+        if args.size == 1
+          first = 1 if !first and modfunc
+          first = [1, first - center_correction].max
+        elsif args.size == 2 or (args.size == 3 and modfunc)
+          opts = {
+            :msg_on_error => 
+            'Starting line expected, got %s.' % args[-1]
+          }
+          num = @proc.get_an_int(args[1], opts)
+
+          return nil, nil, nil unless num 
+          if modfunc
+            if first
+              first = num
+              if args.size == 3 and modfunc
+                opts[:msg_on_error] = ('last or count parameter expected, ' +
+                                       'got: %s.' % args[2])
+                last = @proc.get_an_int(args[2], opts)
+              end
+            else
+              last = num
+            end
+          else
+            first = num - center_correction
+          end
+          if last and last < first
+            # Assume last is a count rather than an end line number
+            last = first + last - 1
+          end
+        elsif not modfunc
+          errmsg('At most 2 parameters allowed when no module' +
+                  ' name is found/given. Saw: %d parameters' % args.size)
+          return nil, nil, nil
+        else
+          errmsg(('At most 3 parameters allowed when a module' +
+                  ' name is given. Saw: %d parameters') % args.size)
+          return nil, nil, nil
+        end
+      end
+    elsif !@proc.line_no and frame
+      first = [1, @proc.frame_line - center_correction].max
+    else
+      first = [1, @proc.line_no - center_correction].max 
+    end
+    last = first + listsize - 1 unless last
+  
+    LineCache::cache(container[1]) unless 
+        'file' != container[0] || LineCache::cached?(container[1])
+    return container, first, last
+  end
+
+  def no_frame_msg
+    errmsg("No Ruby program loaded.")
+    return nil, nil, nil
+  end
+    
+  def run(args)
+    listsize = settings[:maxlist]
+    center_correction = 
+      if args[0][-1..-1] == '>'
+        0
+      else
+        (listsize-1) / 2
+      end
+
+    container, first, last = 
+      parse_list_cmd(args[1..-1], listsize, center_correction)
+    frame = @proc.frame
+    return unless container
+    breaklist = @proc.brkpts.line_breaks(container)
+
+    # We now have range information. Do the listing.
+    max_line = LineCache::size(container[1])
+    unless max_line 
+      errmsg('File "%s" not found.' % container[1])
+      return
+    end
+
+    if first > max_line
+      errmsg('Bad line range [%d...%d]; file "%s" has only %d lines' %
+             [first, last, container[1], max_line])
+      return
+    end
+
+    if last > max_line
+      # msg('End position changed to last line %d ' % max_line)
+      last = max_line
+    end
+
+    begin
+      first.upto(last).each do |lineno|
+        line = LineCache::getline(container[1], lineno,
+                                  @proc.reload_on_change).chomp
+        unless line
+          msg('[EOF]')
+          break
+        end
+        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 &&
+              container == frame.source_container) ? '->' : a_pad
+        msg(s + "\t" + line)
+        @proc.line_no = lineno
+      end
+    rescue => e
+      errmsg e if settings[:debugexcept]
+    end
+  end
+end
+
+if __FILE__ == $0
+  if  not (ARGV.size == 1 && ARGV[0] == 'noload')
+    ISEQS__        = {}
+    SCRIPT_ISEQS__ = {}
+    ARGV[0..-1]    = ['noload']
+    load(__FILE__)
+  else    
+    require_relative '../location'
+    require_relative '../mock'
+    require_relative '../frame'
+    name = File.basename(__FILE__, '.rb')
+    dbgr, cmd = MockDebugger::setup(name)
+    cmd.proc.send('frame_initialize')
+    LineCache::cache(__FILE__)
+    cmd.run(['list'])
+    cmd.run(['list', __FILE__ + ':10'])
+
+    def run_cmd(cmd, args)
+      seps = '--' * 10
+      puts "%s %s %s" % [seps, args.join(' '), seps]
+      cmd.run(args)
+    end
+      
+
+    load 'tmpdir.rb'
+    run_cmd(cmd, %w(list tmpdir.rb 10))
+    run_cmd(cmd, %w(list tmpdir.rb))
+
+    # cmd.proc.frame = sys._getframe()
+    # cmd.proc.setup()
+    # cmd.run(['list'])
+
+    run_cmd(cmd, %w(list .))
+    run_cmd(cmd, %w(list 30))
+
+    # cmd.run(['list', '9+1'])
+
+    run_cmd(cmd, %w(list> 10))
+    run_cmd(cmd, %w(list 3000))
+    run_cmd(cmd, %w(list run_cmd))
+
+    p = Proc.new do 
+      |x,y| x + y
+    end
+    run_cmd(cmd, %w(list p))
+
+    # Function from a file found via an instruction sequence
+    run_cmd(cmd, %w(list Columnize.columnize))
+
+    # Use Class/method name. 15 isn't in the function - should this be okay?
+    run_cmd(cmd, %w(list Columnize.columnize 15))
+
+    # Start line and count, since 3 < 30
+    run_cmd(cmd, %w(list Columnize.columnize 30 3))
+
+    # Start line finish line 
+    run_cmd(cmd, %w(list Columnize.columnize 40 50))
+
+    # puts '--' * 10
+    # cmd.run(['list', os.path.abspath(__file__)+':3', '4'])
+    # puts '--' * 10
+    # cmd.run(['list', os.path.abspath(__file__)+':3', '12-10'])
+    # cmd.run(['list', 'os.path:5'])
+
+    require 'thread_frame'
+    tf = RubyVM::ThreadFrame.current
+    cmd.proc.frame_setup(tf)
+    brkpt_cmd = cmd.proc.instance_variable_get('@commands')['break']
+    brkpt_cmd.run(['break'])
+    line = __LINE__
+    run_cmd(cmd, ['list', __LINE__.to_s])
+
+    disable_cmd = cmd.proc.instance_variable_get('@commands')['disable']
+    disable_cmd.run(['disable', '1'])
+
+    run_cmd(cmd, ['list', line.to_s])
+    run_cmd(cmd, %w(list parse_list_cmd))
+  end
+end

data/processor/command/macro.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../eval'
+class Trepan::Command::MacroCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+      "macro NAME PROC-OBJECT
+
+Define NAME as a debugger macro. Debugger macros get a list of arguments
+and should return a command string to use in its place.
+
+Here is a contrived example that shows how to issue 'finish' if we are in 
+method 'gcd' and 'step' otherwise:
+
+  macro step_unless_gcd Proc.new{|*args| \"$trepan_frame.method == 'gcd' ? 'finish' : 'step'\"}
+
+Here is another real example. I use the following to debug a
+debugger command, assuming 'set debug dbgr' is set:
+
+  macro dbgcmd Proc.new{|*args| \"debug $trepan_cmdproc.commands['\#{args[0]}'].run(\#{args.inspect})\"}
+
+With the above, 'dbgcmd list 5' will debug the debugger 'list' command 
+on the command 'list 5'.
+
+See also 'show macro'.
+"
+
+    CATEGORY      = 'support'
+    MIN_ARGS      = 2  # Need at least this many
+    NAME          = File.basename(__FILE__, '.rb')
+    SHORT_HELP    = 'Define a macro'
+  end
+  
+  def run(args)
+    macro_name = args[1]
+    proc_argstr = @proc.cmd_argstr[macro_name.size..-1].lstrip
+    proc_obj = @proc.debug_eval(proc_argstr, @proc.settings[:maxstring])
+    if proc_obj
+      if proc_obj.is_a?(Proc)
+        @proc.macros[macro_name] = proc_obj
+        msg "Macro \"#{macro_name}\" defined."
+      else
+        errmsg "Expecting a Proc object; got: #{proc_argstr}"
+      end
+    end
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  cmdproc = dbgr.core.processor
+  ['macro foo Proc.new{|x, y| x+y}',
+   'macro bad x+1',
+   'macro 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,89 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+
+class Trepan::Command::NextCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"next[+|=|-|<|>|!|<>] [EVENT-NAME...] [count]
+
+Step one statement ignoring steps into function calls at this level.
+Sometimes this is called 'step over'.
+
+With an integer argument, perform 'next' that many times. However if
+an exception occurs at this level, or we 'return' or 'yield' or the
+thread changes, we stop regardless of count.
+
+A suffix of '+' on the command or an alias to the command forces to
+move to another line, while a suffix of '-' does the opposite and
+disables the requiring a move to a new line. If no suffix is given,
+the debugger setting 'different' determines this behavior.
+
+If no suffix is given, the debugger setting 'different'
+determines this behavior.
+
+Examples: 
+  next        # next 1 event, *any* event 
+  next 1      # same as above
+  next+       # same but force stopping on a new line
+  next=       # same but force stopping on a new line a new frame added
+  next-       # same but force stopping on a new line a new frame added
+  next 5/5+0  # same as above
+  next line   # next using only line events
+  next call   # next using only call call events
+  next<>      # next using call return events at this level or below
+"
+
+    ALIASES      = %w(n next+ next- next< next> next<> next! n> n< n! n+ n- 
+                      n<> n=)
+    CATEGORY     = 'running'
+    # execution_set = ['Running']
+    MAX_ARGS     = 1   # Need at most this many. FIXME: will be eventually 2
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_RUNNING = true
+    SHORT_HELP   = 'Step program without entering called functions'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    opts = @proc.parse_next_step_suffix(args[0])
+    if args.size == 1
+      # Form is: "next" which means "next 1"
+      step_count = 0
+    else
+      count_str = args[1]
+      opts = {
+        :msg_on_error => 
+        "The 'next' command argument must eval to an integer. Got: %s" % 
+        count_str,
+        :min_value => 1
+      }
+      count = @proc.get_an_int(count_str, opts)
+      return unless count
+      # step 1 is core.step_count = 0 or "stop next event"
+      step_count = count - 1  
+    end
+    @proc.next(step_count, opts)
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  [%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/nocache.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+class Trepan::Command::NoCacheCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP         = "Remove getinlinecache instructions from instruction sequence."
+
+    CATEGORY     = 'running'
+    MAX_ARGS     = 0   # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    SHORT_HELP   = 'Remove getinlinecache instructions from instruction sequence.'
+
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    if @proc.frame.iseq
+      puts @proc.frame.iseq.disassemble
+      count = @proc.frame.iseq.killcache
+      msg ("%d locations removed" % count)
+      # puts @proc.frame.iseq.disassemble
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  cmd.run([name])
+end

data/processor/command/print.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../eval'
+class Trepan::Command::PrintCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+      "print 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."
+
+    # ALIASES       = %w(p)
+    CATEGORY      = 'data'
+    NAME          = File.basename(__FILE__, '.rb')
+    SHORT_HELP    = 'Print expression'
+  end
+  
+  def run(args)
+    msg @proc.debug_eval(@proc.cmd_argstr, @proc.settings[:maxstring])
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  arg_str = '1 + 2'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([name, arg_str])
+  cmdproc = dbgr.core.processor
+  cmds = dbgr.core.processor.commands
+end

data/processor/command/ps.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+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, @proc.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'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  arg_str = '(1..30).to_a'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([name, arg_str])
+  arg_str = '1'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([name, arg_str])
+end

data/processor/command/quit.rb

@@ -0,0 +1,62 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+class Trepan::Command::QuitCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+      'quit[!] [unconditionally] [exit code] - gentle termination
+
+The program being debugged is exited via exit() which runs the Kernel
+at_exit finalizers. If a return code is given, that is the return code
+passed to exit() - presumably the return code that will be passed back
+to the OS. If no exit code is given, 0 is used.
+
+Examples: 
+  quit                 # quit prompting if we are interactive
+  quit conditionally   # quit without prompting
+  quit!                # same as above
+  quit 0               # same as "quit"
+  quit! 1              # unconditional quit setting exit code 1
+
+See also the commands "exit" and "kill".'
+
+    ALIASES      = %w(quit! q q!)
+    CATEGORY     = 'support'
+    NAME         = File.basename(__FILE__, '.rb')
+    MAX_ARGS     = 2  # Need at most this many
+    SHORT_HELP  = 'Quit program - gently'
+  end
+
+  # FIXME: Combine 'quit' and 'exit'. The only difference is
+  # whether exit! or exit is used.
+
+  # This method runs the command
+  def run(args) # :nodoc
+    unconditional = 
+      if args.size > 1 && args[1] == 'unconditionally'
+        args.shift
+        true
+      elsif args[0][-1] == '!'
+        true
+      else
+        false
+      end
+    unless unconditional || confirm('Really quit?', false)
+      msg('Quit not confirmed.')
+      return
+    end
+
+    exitrc = (args.size > 1) ? exitrc = Integer(args[1]) rescue 0 : 0
+    # No graceful way to stop threads...
+    exit exitrc
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  name = File.basename(__FILE__, '.rb')
+  fork { cmd.run([name]) }
+  cmd.run([name, '5'])
+end

data/processor/command/raise.rb

@@ -0,0 +1,47 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+class Trepan::Command::RaiseCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"raise EXCEPTION
+
+Raise an exception in the debugged program."
+
+    CATEGORY     = 'running'
+    MAX_ARGS     = 1  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    SHORT_HELP  = 'Raise an exception in the debugged program'
+  end
+    
+  # This method runs the command
+  def run(args) # :nodoc
+    exception = 
+      if args.size > 1
+        except_str = args[1..-1].join(' ')
+        # Normally would need x.respond_to? && ..
+        # but since we catch errors with debug_eval.. not needed.
+        eval_str = ("%s.ancestors.include?(Exception)" %
+                    [except_str])
+        unless @proc.debug_eval_no_errmsg(eval_str)
+          errmsg "\"#{except_str}\" does not inherit Exception."
+          return
+        end
+        @proc.debug_eval_no_errmsg(except_str)
+      else
+        RuntimeError
+      end
+    @proc.step(0)
+    @proc.leave_cmd_loop = true
+    @proc.core.exception = exception
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  puts cmd.run([name, 'NotanException'])
+  puts cmd.run([name, '[5]'])
+  puts cmd.run([name, 'RuntimeError'])
+end