trepanning 0.0.4 → 0.0.6

data/processor/command/base/subcmd.rb

@@ -27,7 +27,6 @@ class Trepan
       # which append current settings to list output.
       MIN_ABBREV = 1
       NEED_STACK = false
-      NAME       = 'your_command_name'
     end
 
 

data/processor/command/base/submgr.rb

@@ -43,6 +43,7 @@ class Trepan::SubcommandMgr < Trepan::Command
     # Initialization
     cmd_names     = []
     subcmd_names  = []
+    cmd_basenames = []
     cmd_dir = File.dirname(__FILE__)
     subcmd_dir = File.join(cmd_dir, '..', name + '_subcmd')
     files = Dir.glob(File.join(subcmd_dir, '*.rb'))
@@ -52,15 +53,23 @@ class Trepan::SubcommandMgr < Trepan::Command
         subcmd_names << name.capitalize + basename.capitalize
       else
         cmd_names << name.capitalize + basename.capitalize
+        cmd_basenames << basename
       end
       require rb
     end if File.directory?(subcmd_dir)
 
     subcommands = {}
-    cmd_names.each do |name|
+    cmd_names.each_with_index do |name, i|
       next unless Trepan::Subcommand.constants.member?(name.to_sym)
-      subcmd_class = "Trepan::Subcommand::#{name}.new(self)"
-      cmd = self.instance_eval(subcmd_class)
+      subcmd_class = self.instance_eval("Trepan::Subcommand::#{name}")
+      unless subcmd_class.const_defined?(:NAME)
+        subcmd_class.const_set(:NAME, cmd_basenames[i])
+      end
+      unless subcmd_class.const_defined?(:PREFIX)
+        subcmd_class.const_set(:PREFIX, %W(#{parent.name} #{cmd_basenames[i]}))
+      end
+      subcmd_new_str = "Trepan::Subcommand::#{name}.new(self)"
+      cmd = self.instance_eval(subcmd_new_str)
       cmd_name = cmd.name
       @subcmds.add(cmd)
     end

data/processor/command/break.rb

@@ -5,27 +5,27 @@ require_relative '../../app/breakpoint'
 class Trepan::Command::BreakCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-'break [line number|offset]
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [line number|offset]
 
 With a line number argument, set a break there in the current
 instruction sequence.  With an offset (a number prefaced with an "O")
 set a breakpoint at that instruction offset.
 
 Examples:
-   break
-   break 10    # set breakpoint on line 10
-   break o20   # set breakpoint VM Instruction Sequence offset 20
-'
+   #{NAME}
+   #{NAME} 10    # set breakpoint on line 10
+   #{NAME} o20   # set breakpoint VM Instruction Sequence offset 20
+    HELP
 
     ALIASES      = %w(b)
     CATEGORY     = 'breakpoints'
-    NAME         = File.basename(__FILE__, '.rb')
     SHORT_HELP  = 'Set a breakpoint'
   end
 
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     # FIXME: handle more conditions
     # a line number
     if args.size == 1
@@ -69,17 +69,16 @@ end
 
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
-  cmd.run([name])
-  cmd.run([name, __LINE__.to_s])
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, __LINE__.to_s])
   require 'thread_frame'
   tf = RubyVM::ThreadFrame.current
   pc_offset = tf.pc_offset
-  cmd.run([name, "O#{pc_offset}"])
+  cmd.run([cmd.name, "O#{pc_offset}"])
   def foo
     5 
   end
-  cmd.run([name, 'foo', (__LINE__-2).to_s])
-  cmd.run([name, 'foo'])
+  cmd.run([cmd.name, 'foo', (__LINE__-2).to_s])
+  cmd.run([cmd.name, 'foo'])
 end

data/processor/command/condition.rb

@@ -8,8 +8,9 @@ require_relative '../../app/condition'
 class Trepan::Command::ConditionCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-'condition BP_NUMBER CONDITION
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} BP_NUMBER CONDITION
 
 BP_NUMBER is a breakpoint number.  CONDITION is an expression which
 must evaluate to True before the breakpoint is honored.  If CONDITION
@@ -17,14 +18,13 @@ is absent, any existing condition is removed; i.e., the breakpoint is
 made unconditional.
 
 Examples:
-   condition 5 x > 10  # Breakpoint 5 now has condition x > 10
-   condition 5         # Remove above condition
-'
+   #{NAME} 5 x > 10  # Breakpoint 5 now has condition x > 10
+   #{NAME} 5         # Remove above condition
+    HELP
 
     ALIASES       = %w(cond)
     CATEGORY      = 'breakpoints'
     MIN_ARGS      = 1
-    NAME          = File.basename(__FILE__, '.rb')
     NEED_STACK    = false
     SHORT_HELP    = 'Specify breakpoint number N to break only if COND is true'
   end
@@ -50,15 +50,14 @@ end
 if __FILE__ == $0
   require 'thread_frame'
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
+  dbgr, cmd = MockDebugger::setup
   cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
   
-  cmd.run([name, '1'])
+  cmd.run([cmd.name, '1'])
   cmdproc = dbgr.core.processor
   cmds = cmdproc.commands
   break_cmd = cmds['break']
-  break_cmd.run(['break', cmdproc.frame.source_location[0].to_s])
-  cmd.run([name, '1', 'x' '>' '10'])
-  cmd.run([name, '1'])
+  break_cmd.run([break_cmd.name, cmdproc.frame.source_location[0].to_s])
+  cmd.run([cmd.name, '1', 'x' '>' '10'])
+  cmd.run([cmd.name, '1'])
 end

data/processor/command/continue.rb

@@ -5,8 +5,9 @@ require_relative '../../app/breakpoint' # FIXME: possibly temporary
 class Trepan::Command::ContinueCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-'continue [offset|line number]
+    NAME         = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [offset|line number]
 
 Leave the debugger loop and continue execution. Subsequent entry to
 the debugger however may occur via breakpoints or explicit calls, or
@@ -17,21 +18,20 @@ before continuing. Offset are numbers preficed with an "O" otherwise
 the parameter is taken as a line number.
 
 Examples:
-   continue
-   continue 10    # continue to line 10
-   continue o20   # continue to VM Instruction Sequence offset 20
-'
+   #{NAME}
+   #{NAME} 10    # continue to line 10
+   #{NAME} o20   # continue to VM Instruction Sequence offset 20
+    HELP
 
     ALIASES      = %w(c)
     CATEGORY     = 'running'
     MAX_ARGS     = 1  # Need at most this many
-    NAME         = File.basename(__FILE__, '.rb')
     NEED_RUNNING = true
     SHORT_HELP   = 'Continue execution of debugged program'
   end
 
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     if args.size == 1
       # Form is: "continue"
       @proc.continue
@@ -55,7 +55,6 @@ end
 
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
-  p cmd.run([name])
+  dbgr, cmd = MockDebugger::setup
+  p cmd.run([cmd.name])
 end

data/processor/command/debug.rb

@@ -5,15 +5,16 @@ require_relative 'base/cmd'
 
 class Trepan::Command::DebugCommand < Trepan::Command
   unless defined?(HELP)
-    HELP =
-"debug RUBY-CODE
+    NAME          = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} RUBY-CODE
 
-Enter the debugger recursively on RUBY-CODE."
+Enter the debugger recursively on RUBY-CODE.
+    HELP
 
     CATEGORY      = 'data'
     MIN_ARGS      = 1
     MAX_ARG       = nil
-    NAME          = File.basename(__FILE__, '.rb')
     NEED_STACK    = false
     SHORT_HELP    = 'recursive debugging of an expression'
 
@@ -76,10 +77,8 @@ end
 
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
-  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup
   cmd.proc.hidelevels[Thread.current] = 0
   cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
-  cmd.run([name, 'x = 1; y = 2'])
+  cmd.run([cmd.name, 'x = 1; y = 2'])
 end

data/processor/command/delete.rb

@@ -6,8 +6,11 @@ require_relative '../../app/breakpoint'
 class Trepan::Command::DeleteCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = 
-      'delete [bpnumber [bpnumber...]]  - Delete some breakpoints.
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [bpnumber [bpnumber...]]  
+
+Delete some breakpoints.
 
 Arguments are breakpoint numbers with spaces in between.  To delete
 all breakpoints, give no argument.  those breakpoints.  Without
@@ -15,10 +18,9 @@ argument, clear all breaks (but first ask confirmation).
     
 See also the "clear" command which clears breakpoints by line/file
 number.
-'
+    HELP
 
     CATEGORY      = 'breakpoints'
-    NAME          = File.basename(__FILE__, '.rb')
     SHORT_HELP    = 'Delete some breakpoints'
   end
   
@@ -40,15 +42,14 @@ end
         
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
-  cmd.run([name])
-  cmd.run([name, '1'])
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, '1'])
   cmdproc = dbgr.core.processor
   cmds = dbgr.core.processor.commands
   break_cmd = cmds['break']
   break_cmd.run(['break', cmdproc.frame.source_location[0].to_s])
   # require_relative '../../lib/trepanning'
   # Trepan.debug(:set_restart => true)
-  cmd.run([name, '1'])
+  cmd.run([cmd.name, '1'])
 end

data/processor/command/directory.rb

@@ -21,7 +21,7 @@ kernel/common/module.rb if have the source code somewhere.
   end
     
   # This method runs the command
-  def run(args) # :nodoc
+  def run(args)
     if args.size > 1
       settings[:directory] = "#{args[1]}:#{settings[:directory]}"
       msg "Source directories searched: #{settings[:directory]}"

data/processor/command/disable.rb

@@ -14,15 +14,15 @@ class Trepan::Command::DisableCommand < Trepan::Command
   # Silence already initialized constant .. warnings
   old_verbose = $VERBOSE  
   $VERBOSE    = nil
-  HELP = 
-      'disable [display] bpnumber [bpnumber ...]
+  NAME = File.basename(__FILE__, '.rb')
+  HELP = <<-HELP
+#{NAME} [display] bpnumber [bpnumber ...]
     
 Disables the breakpoints given as a space separated list of breakpoint
 numbers. See also "info break" to get a list.
-'
+  HELP
 
   CATEGORY      = 'breakpoints'
-  NAME          = File.basename(__FILE__, '.rb')
   SHORT_HELP    = 'Disable some breakpoints'
 
   $VERBOSE      = old_verbose 
@@ -51,15 +51,14 @@ end
         
 if __FILE__ == $0
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
-  cmd.run([name])
-  cmd.run([name, '1'])
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, '1'])
   cmdproc = dbgr.core.processor
   cmds = cmdproc.commands
   break_cmd = cmds['break']
   break_cmd.run(['break', cmdproc.frame.source_location[0].to_s])
   # require_relative '../../lib/trepanning'
   # Trepan.debug(:set_restart => true)
-  cmd.run([name, '1'])
+  cmd.run([cmd.name, '1'])
 end

data/processor/command/disassemble.rb

@@ -9,8 +9,9 @@ class Trepan::Command::DisassembleCommand < Trepan::Command
     include Trepanning
 
   unless defined?(HELP)
-    HELP = 
-"disassemble [thing] [full]
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [thing] [full]
 
 With no argument, disassemble the current frame.  With a method,
 disassemble that method. '.' can be used to indicate the instruction
@@ -27,11 +28,10 @@ Examples:
   disas .       # Same as above
   disas . full  # At least the instruction sequence above but maybe more
   disas require_relative # disassemble method 'require_relative'
- "
+    HELP
 
     ALIASES       = %w(disas disassem) # Note we have disable
     CATEGORY      = 'data'
-    NAME          = File.basename(__FILE__, '.rb')
     NEED_STACK    = true
     SHORT_HELP    = 'Disassemble Ruby VM instructions'
   end
@@ -88,16 +88,15 @@ if __FILE__ == $0
   require 'thread_frame'
 
   require_relative '../mock'
-  name = File.basename(__FILE__, '.rb')
-  dbgr, cmd = MockDebugger::setup(name)
+  dbgr, cmd = MockDebugger::setup
   def small_fn(cmd, name)
     cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
     cmd.run [name]
   end
-  small_fn(cmd, name)
+  small_fn(cmd, cmd.name)
   p = Proc.new do 
     |x,y| x + y
   end
   cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
-  cmd.run([name, 'p'])
+  cmd.run([cmd.name, 'p'])
 end

data/processor/command/display.rb

@@ -5,8 +5,9 @@ require_relative 'base/cmd'
 class Trepan::Command::DisplayCommand < Trepan::Command
 
   unless defined?(HELP)
-    HELP = <<EOH
-display [format] EXP
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{name} [format] EXP
  
 Print value of expression EXP each time the program stops.  FMT may be
 used before EXP and may be one of 'c' for char, 'x' for hex, 'o' for
@@ -21,10 +22,9 @@ case or not.
 With no argument, evaluate and display all currently requested
 auto-display expressions.  Use "undisplay" to cancel display
 requests previously made.
-EOH
+    HELP
     
     CATEGORY      = 'data'
-    NAME          = File.basename(__FILE__, '.rb')
     NEED_STACK    = false
     SHORT_HELP    = 'Display expressions when entering debugger'
   end
@@ -62,8 +62,7 @@ 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 run_cmd(cmd, args)
     cmd.run(args)
@@ -72,10 +71,10 @@ if __FILE__ == $0
 
   cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
 
-  run_cmd(cmd, [name])
-  run_cmd(cmd, [name, '/x', '10'])
-  run_cmd(cmd, [name, 'd'])
-  run_cmd(cmd, [name])
+  run_cmd(cmd, [cmd.name])
+  run_cmd(cmd, [cmd.name, '/x', '10'])
+  run_cmd(cmd, [cmd.name, 'd'])
+  run_cmd(cmd, [cmd.name])
   e = 5
-  run_cmd(cmd, [name, 'e'])
+  run_cmd(cmd, [cmd.name, 'e'])
 end

data/processor/command/down.rb

@@ -9,14 +9,14 @@ class Trepan::Command::DownCommand < Trepan::Command::UpCommand
   # Silence already initialized constant .. warnings
   old_verbose = $VERBOSE  
   $VERBOSE    = nil
-  HELP = 
-"d(own) [count]
+  HELP = <<-HELP
+#{NAME} [count]
 
 Move the current frame down in the stack trace (to a newer frame). 0
 is the most recent frame. If no count is given, move down 1.
 
 See also 'up' and 'frame'.
-"
+  HELP
 
   ALIASES       = %w(d)
   NAME          = File.basename(__FILE__, '.rb')
@@ -34,14 +34,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
-  cmd.run [name]
+  cmd.run [cmd.name]
   %w(-1 0 1 -2).each do |count| 
-    puts "#{name} #{count}"
-    cmd.run([name, count])
+    puts "#{cmd.name} #{count}"
+    cmd.run([cmd.name, count])
     sep 
   end
   def foo(cmd, name)
@@ -52,5 +51,5 @@ if __FILE__ == $0
     puts "#{name} -1"
     cmd.run([name, '-1'])
   end
-  foo(cmd, name)
+  foo(cmd, cmd.name)
 end