trepanning 0.0.4 → 0.0.6

data/processor/command/enable.rb

@@ -10,15 +10,15 @@ class Trepan::Command::EnableCommand < Trepan::Command::DisableCommand
   # Silence already initialized constant .. warnings
   old_verbose = $VERBOSE  
   $VERBOSE    = nil
-  HELP = 
-      'enable [display] bpnumber [bpnumber ...]
+  NAME        = File.basename(__FILE__, '.rb')
+  HELP        = <<-HELP
+#{NAME} [display] bpnumber [bpnumber ...]
     
 Enables the breakpoints given as a space separated list of breakpoint
 numbers. See also "info break" to get a list.
-'
+  HELP
 
   ALIASES       = %w(en)
-  NAME          = File.basename(__FILE__, '.rb')
   SHORT_HELP    = 'Enable some breakpoints'
   $VERBOSE      = old_verbose 
 
@@ -31,13 +31,12 @@ end
         
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
-  cmd.run([name])
-  cmd.run([name, '1'])
-  cmdproc = dbgr.core.processor
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, '1'])
+  cmdproc = cmd.proc
   cmds = cmdproc.commands
   break_cmd = cmds['break']
   break_cmd.run(['break', cmdproc.frame.source_location[0].to_s])
-  cmd.run([name, '1'])
+  cmd.run([cmd.name, '1'])
 end

data/processor/command/exit.rb

@@ -3,19 +3,22 @@ require_relative 'base/cmd'
 class Trepan::Command::ExitCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-      'exit [exitcode] - hard exit of the debugged program.  
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [exitcode] 
+
+hard exit of the debugged program.  
 
 The program being debugged is exited via exit!() which does not run
 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.
 
-See also the commands "quit" and "kill".'
+See also the commands "quit" and "kill".
+    HELP
 
     CATEGORY     = 'support'
     MAX_ARGS     = 2  # Need at most this many
-    NAME         = File.basename(__FILE__, '.rb')
     SHORT_HELP  = 'Exit program via "exit!"'
   end
 
@@ -23,7 +26,7 @@ See also the commands "quit" and "kill".'
   # whether exit! or exit is used.
 
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     unconditional = 
       if args.size > 1 && args[1] == 'unconditionally'
         args.shift
@@ -46,9 +49,7 @@ 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, '10'])
+  dbgr, cmd = MockDebugger::setup
+  fork { cmd.run([cmd.name]) }
+  cmd.run([cmd.name, '10'])
 end

data/processor/command/finish.rb

@@ -5,8 +5,9 @@ require_relative 'base/cmd'
 class Trepan::Command::FinishCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-"finish [levels]
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [levels]
 
 Continue execution until leaving the current function. 
 Sometimes this is called 'step out'.
@@ -21,20 +22,21 @@ guarentee the stack level is the same as or less than the current
 one. 
 
 See the break command if you want to stop at a particular point in a
-program. In general, 'finish', 'step' and 'next' may slow a program down
+program. In general, '#{NAME}', 'step' and 'next' may slow a program down
 while 'break' will have less overhead.
-"
+    HELP
     ALIASES      = %w(fin)
     CATEGORY     = 'running'
     # execution_set = ['Running']
-    MAX_ARGS     = 1   # Need at most this many. 
-    NAME         = File.basename(__FILE__, '.rb')
+
+    # Need at most this many. 
+    MAX_ARGS     = 1   
     NEED_STACK   = true
     SHORT_HELP   = 'Step program without entering called functions'
   end
 
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     opts = {}
     if args.size == 1
       # Form is: "finish" which means "finish 1"
@@ -62,9 +64,8 @@ end
 
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
-  [%w(finish 1), %w(fin 2-1), %w(n foo)].each do |c|
+  dbgr, cmd = MockDebugger::setup
+  [%W(#{cmd.name} 1), %w(fin 2-1), %w(n foo)].each do |c|
     cmd.proc.next_level = 0
     cmd.proc.leave_cmd_loop = false
     result = cmd.run(c)
@@ -72,7 +73,7 @@ if __FILE__ == $0
     puts 'level_count %d, leave_cmd_loop: %s' % [cmd.proc.next_level,
                                                 cmd.proc.leave_cmd_loop]
   end
-  [%w(fin), %w(finish)].each do |c|
+  [%w(fin), [cmd.name]].each do |c|
     cmd.proc.next_level = 0
     cmd.proc.leave_cmd_loop = false
     result = cmd.run(c)

data/processor/command/frame.rb

@@ -104,14 +104,13 @@ if __FILE__ == $0
   # Demo it.
   require 'thread_frame'
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
+  dbgr, cmd = MockDebugger::setup
 
   def sep ; puts '=' * 40 end
-  %w(0 1 -2).each {|count| cmd.run([name, count]); sep }
+  %w(0 1 -2).each {|count| cmd.run([cmd.name, count]); sep }
   def foo(cmd, name)
     cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
     %w(0 -1).each {|count| cmd.run([name, count]); sep }
   end
-  foo(cmd, name)
+  foo(cmd, cmd.name)
 end

data/processor/command/help.rb

@@ -3,8 +3,9 @@ require_relative 'base/cmd'
 class Trepan::Command::HelpCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-"help [command [subcommand]|expression]
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [command [subcommand]|expression]
 
 Without argument, print the list of available debugger commands.
 
@@ -21,8 +22,7 @@ subcommand. For example 'help info line' give help about the
 info line command.
 
 See also 'examine' and 'whatis'.
-"
-
+    HELP
 
     ALIASES       = %w(?)
     CATEGORIES    = {
@@ -35,7 +35,6 @@ See also 'examine' and 'whatis'.
     'stack'       => 'Examining the call stack'
     }
     CATEGORY      = 'support'
-    NAME          = File.basename(__FILE__, '.rb')
     NEED_STACK    = false
     SHORT_HELP    = 'Print commands or give help for command(s)'
   end
@@ -57,7 +56,7 @@ Type "help" followed by command name for full documentation.
   end
 
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     if args.size > 1
       cmd_name = args[1]
       if cmd_name == '*'
@@ -124,23 +123,22 @@ end
 if __FILE__ == $0
   # Demo it.
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
+  dbgr, cmd = MockDebugger::setup
 
-  cmd.run %w(help help)
+  cmd.run %W(cmd.name help)
   puts '=' * 40
-  cmd.run %w(help *)
+  cmd.run %W(cmd.name *)
   puts '=' * 40
-  cmd.run %w(help fdafsasfda)
+  cmd.run %W(cmd.name fdafsasfda)
   puts '=' * 40
-  cmd.run %w(help)
+  cmd.run %W(cmd.name)
   puts '=' * 40
-  cmd.run %w(help support)
+  cmd.run %W(cmd.name support)
   puts '=' * 40
-  cmd.run %w(help support *)
+  cmd.run %W(cmd.name support *)
 
   puts '=' * 40
-  cmd.run %w(help s.*)
+  cmd.run %W(cmd.name s.*)
   puts '=' * 40
-  cmd.run %w(help s<>)
+  cmd.run %W(cmd.name s<>)
 end

data/processor/command/info.rb

@@ -4,25 +4,24 @@ require_relative 'base/submgr'
 
 class Trepan::Command::InfoCommand < Trepan::SubcommandMgr
   unless defined?(HELP)
-    HELP =
-'Generic command for showing things about the program being debugged. 
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+Generic command for showing things about the program being debugged. 
 
 You can give unique prefix of the name of a subcommand to get
 information about just that subcommand.
 
-Type "info" for a list of "info" subcommands and what they do.
-Type "help info *" for just a list of "info" subcommands.
-'
+Type "#{NAME}" for a list of "info" subcommands and what they do.
+Type "help #{NAME} *" for just a list of "info" subcommands.
+    HELP
 
     ALIASES       = %w(i)
     CATEGORY      = 'status'
-    NAME          = File.basename(__FILE__, '.rb')
     SHORT_HELP    = 'Information about debugged program and its environment'
   end
 end
 
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
+  dbgr, cmd = MockDebugger::setup
 end

data/processor/command/irb.rb

@@ -5,23 +5,24 @@ require_relative '../../app/irb'
 class Trepan::Command::IRBCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-"          irb [-d]\tstarts an Interactive Ruby (IRB) session.
+    NAME         = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+          #{NAME} [-d]\tstarts an Interactive Ruby (IRB) session.
 
 If -d is added you can get access to debugger frame the global variables
 $trepan_frame and $trepan_cmdproc. 
 
-irb is extended with methods 'cont', 'dbgr', 'n', and, 'q', 'step' which 
-run the corresponding debugger commands. 
+#{NAME} is extended with methods 'cont', 'ne', and, 'q', 'step' which 
+run the corresponding debugger commands 'continue', 'next', 'exit' and 'step'. 
 
-To issue a debugger command, inside irb nested inside a debugger use
+To issue a debugger command, inside #{NAME} nested inside a debugger use
 'dbgr'. For example:
 
-  dbgr %%w(info program)
+  dbgr %w(info program)
   dbgr('info', 'program') # Same as above
   dbgr 'info program'     # Single quoted string also works
 
-But arguments have to be quoted because irb will evaluate them:
+But arguments have to be quoted because #{NAME} will evaluate them:
 
   dbgr info program     # wrong!
   dbgr info, program    # wrong!
@@ -29,16 +30,15 @@ But arguments have to be quoted because irb will evaluate them:
 
 Here then is a loop to query VM stack values:
   (-1..1).each {|i| dbgr(\"info reg sp \#{i}\")}
-"
+     HELP
 
     CATEGORY     = 'support'
     MAX_ARGS     = 1  # Need at most this many
-    NAME         = File.basename(__FILE__, '.rb')
-    SHORT_HELP  = 'Run interactive Ruby session irb as a command subshell'
+    SHORT_HELP  = "Run #{NAME} as a command subshell"
   end
 
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     add_debugging = 
       if args.size > 1
         '-d' == args[1]
@@ -99,8 +99,7 @@ end
 if __FILE__ == $0
   require 'thread_frame'
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
+  dbgr, cmd = MockDebugger::setup
   # Get an IRB session -- the hard way :-)
-  cmd.run([name]) if ARGV.size > 0
+  cmd.run([cmd.name]) if ARGV.size > 0
 end

data/processor/command/kill.rb

@@ -3,26 +3,38 @@ require_relative 'base/cmd'
 class Trepan::Command::KillCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-"Kill execution of program being debugged.
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [signal-number|signal-name|unconditionally]
+
+Kill execution of program being debugged.
 
 Equivalent of Process.kill('KILL', Process.pid). This is an unmaskable
 signal. When all else fails, e.g. in thread code, use this.
 
 If 'unconditionally' is given, no questions are asked. Otherwise, if
-we are in interactive mode, we'll prompt to make sure."
+we are in interactive mode, we'll prompt to make sure.
+
+Examples:
+
+  #{NAME}  
+  #{NAME} unconditionally
+  #{NAME} KILL # same as above
+  #{NAME} kill # same as above
+  #{NAME} -9   # same as above
+  #{NAME} 9    # same as above
+    HELP
 
     CATEGORY     = 'running'
     MAX_ARGS     = 1  # Need at most this many
-    NAME         = File.basename(__FILE__, '.rb')
     SHORT_HELP  = 'Send this process a POSIX signal (default "9" is "kill -9")'
   end
     
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     if args.size > 1
       sig = Integer(args[1]) rescue args[1]
-      unless sig.is_a?(Integer) || Signal.list.member?(sig)
+      unless sig.is_a?(Integer) || Signal.list.member?(sig.upcase)
         errmsg("Signal name '#{sig}' is not a signal I know about.\n")
         return false
         end
@@ -48,11 +60,10 @@ end
 
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
+  dbgr, cmd = MockDebugger::setup
   %w(fooo 1 -1 HUP -9).each do |arg| 
-    puts "#{name} #{arg}"
-    cmd.run([name, arg])
+    puts "#{cmd.name} #{arg}"
+    cmd.run([cmd.name, arg])
     puts '=' * 40
   end
 end

data/processor/command/list.rb

@@ -5,16 +5,17 @@ require_relative 'base/cmd'
 
 class Trepan::Command::ListCommand < Trepan::Command
   unless defined?(HELP)
-    HELP = 
-"list[>] [MODULE] [FIRST [NUM]]
-list[>] LOCATION [NUM]
+    NAME          = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME}[>] [MODULE] [FIRST [NUM]]
+#{NAME}[>] LOCATION [NUM]
 
-List source code. 
+#{NAME} source code. 
 
 Without arguments, prints lines centered around the current
-line. If this is the first list command issued since the debugger
+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 list command was issued with no intervening
+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.
 
@@ -25,7 +26,7 @@ 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. 
+\"#{NAME} -\" shows lines before a previous listing. 
 
 A LOCATION is a either 
   - number, e.g. 5, 
@@ -47,22 +48,22 @@ 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
+#{NAME} 5            # List centered around line 5
+#{NAME} 4+1          # Same as above.
+#{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} FileUtils.cp # List lines around the FileUtils.cp function.
+#{NAME} .            # List lines centered from where we currently are stopped
+#{NAME} -            # List lines previous to those just shown
+
+The output of the #{NAME} 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
+hypothetical #{NAME} output modeled roughly around line 251 of one
 version of this code:
 
   251    	  cmd.proc.frame_setup(tf)
@@ -74,12 +75,12 @@ version of this code:
 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."
+disabled.
+    HELP
 
-    ALIASES       = %w(l list> l>)
+    ALIASES       = %W(l #{NAME}> l>)
     CATEGORY      = 'files'
     MAX_ARGS      = 3
-    NAME          = File.basename(__FILE__, '.rb')
     SHORT_HELP    = 'List source code'
   end
 
@@ -256,8 +257,7 @@ if __FILE__ == $0
     require_relative '../location'
     require_relative '../mock'
     require_relative '../frame'
-    name = File.basename(__FILE__, '.rb')
-    dbgr, cmd = MockDebugger::setup(name)
+    dbgr, cmd = MockDebugger::setup
     cmd.proc.send('frame_initialize')
     LineCache::cache(__FILE__)
     cmd.run(['list'])
@@ -296,19 +296,19 @@ if __FILE__ == $0
     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))
+    run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 15))
 
     # Start line and count, since 3 < 30
-    run_cmd(cmd, %w(list Columnize.columnize 30 3))
+    run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 30 3))
 
     # Start line finish line 
-    run_cmd(cmd, %w(list Columnize.columnize 40 50))
+    run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 40 50))
 
     # puts '--' * 10
-    # cmd.run(['list', os.path.abspath(__file__)+':3', '4'])
+    # cmd.run([cmd.name, os.path.abspath(__file__)+':3', '4'])
     # puts '--' * 10
-    # cmd.run(['list', os.path.abspath(__file__)+':3', '12-10'])
-    # cmd.run(['list', 'os.path:5'])
+    # cmd.run([cmd.name, os.path.abspath(__file__)+':3', '12-10'])
+    # cmd.run([cmd.name, 'os.path:5'])
 
     require 'thread_frame'
     tf = RubyVM::ThreadFrame.current
@@ -316,12 +316,12 @@ if __FILE__ == $0
     brkpt_cmd = cmd.proc.instance_variable_get('@commands')['break']
     brkpt_cmd.run(['break'])
     line = __LINE__
-    run_cmd(cmd, ['list', __LINE__.to_s])
+    run_cmd(cmd, [cmd.name, __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))
+    run_cmd(cmd, [cmd.name, line.to_s])
+    run_cmd(cmd, %W(#{cmd.name} run_cmd))
   end
 end