trepanning 0.1.0 → 0.1.1

data/processor/command/info_subcmd/iseq.rb

@@ -1,33 +1,49 @@
 # -*- coding: utf-8 -*-
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
-require_relative '../base/subcmd'
+require 'columnize'
 require 'pp'
+require_relative '../base/subcmd'
+require_relative '../../../app/file'
 
 class Trepan::Subcommand::InfoIseq < Trepan::Subcommand
   unless defined?(HELP)
     Trepanning::Subcommand.set_name_prefix(__FILE__, self)
-    HELP         = 
-'info iseq [METHOD|.]
+    HELP = <<-EOH
+#{CMD} iseq [METHOD|.]
 
 Show information about an instruction sequence.
 
 Examples:
-  info iseq
-  info iseq .
-  info iseq require_relative
-'
+  #{CMD}
+  #{CMD} .
+  #{CMD} *
+  #{CMD} require_relative
+  EOH
     MIN_ABBREV   = 'is'.size
     NEED_STACK   = true
     SHORT_HELP   = 'Information about an instruction sequence'
   end
 
+  def iseq_list
+    ISEQS__.keys
+  end
+  def complete(prefix)
+    completions = ['.'] + iseq_list
+    Trepan::Complete.complete_token(completions, prefix)
+  end
+
+  include Trepanning
+
   def run(args)
-    if 2 == args.size
-      iseq_name = '.'
-    else
-      iseq_name = args[2]
-    end
-    if '.' == iseq_name
+    args << '.' if 2 == args.size 
+    iseq_name = args[2]
+    if '*' == iseq_name
+      section 'Instruction Sequences:'
+      iseq_list.sort.each do |iseq|
+        msg "\t #{iseq}"
+      end
+      return
+    elsif '.' == iseq_name
       iseq = frame = @proc.frame.iseq
     elsif !(matches = find_iseqs(ISEQS__, iseq_name)).empty?
       # FIXME: do something if there is more than one
@@ -78,14 +94,20 @@ if __FILE__ == $0
 
   require_relative '../../mock'
   require_relative '../../subcmd'
-  name = File.basename(__FILE__, '.rb')
 
   # FIXME: DRY the below code
   dbgr, cmd = MockDebugger::setup('info')
   subcommand = Trepan::Subcommand::InfoIseq.new(cmd)
   testcmdMgr = Trepan::Subcmd.new(subcommand)
 
-  subcommand.run_show_bool
-  name = File.basename(__FILE__, '.rb')
-  subcommand.summary_help(name)
+  def five; 5; end
+
+  [%w(info iseq nothere),
+   %w(info file .),
+   %w(info file *),
+  ].each do |args|
+    subcommand.run(args)
+    puts '-' * 40
+  end
+  p subcommand.complete('')
 end

data/processor/command/info_subcmd/program.rb

@@ -42,12 +42,6 @@ if __FILE__ == $0
   name = File.basename(__FILE__, '.rb')
 
   # FIXME: DRY the below code
-  dbgr, cmd = MockDebugger::setup('info')
-  subcommand = Trepan::Subcommand::InfoProgram.new(cmd)
-  testcmdMgr = Trepan::Subcmd.new(subcommand)
-
-  name = File.basename(__FILE__, '.rb')
-  subcommand.run([name])
-  subcommand.summary_help(name)
-  puts
+  cmd = MockDebugger::sub_setup(Trepan::Subcommand::InfoProgram, false)
+  cmd.run(cmd.prefix)
 end

data/processor/command/info_subcmd/registers.rb

@@ -6,21 +6,23 @@ require_relative '../base/subsubmgr'
 class Trepan::SubSubcommand::InfoRegisters < Trepan::SubSubcommandMgr
   unless defined?(HELP)
     Trepanning::Subcommand.set_name_prefix(__FILE__, self)
-    HELP         = 
-'List of contents for the registers of the current stack frame.
+    HELP = <<-EOH
+#{CMD} [lfp|pc|sp]
+
+List of contents for the registers of the current stack frame.
 If a register name given, only only that register is show.
 
 Examples:
-  info registers     # show all registers
-  info register pc   # show only the pc register
-  info reg sp        # show all stack pointer registers
-  info reg sp 1 3    # show sp(1) and sp(3)
-  info reg sp size   # show sp size
-  info reg lfp       # show lfp(0)
-'
-
+#{CMD}     # show all registers
+#{CMD} pc   # show only the pc register
+info reg sp        # show all stack pointer registers
+info reg sp 1 3    # show sp(1) and sp(3)
+info reg sp size   # show sp size
+info reg lfp       # show lfp(0)
+    EOH
     MIN_ABBREV   = 'reg'.size  # Note we have "info return"
     NEED_STACK   = true
+    SHORT_HELP   = 'List of register values of the current stack frame'
   end
 
   def run(args)

data/processor/command/info_subcmd/registers_subcmd/.gitignore

@@ -0,0 +1 @@
+/*~

data/processor/command/info_subcmd/ruby.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoRuby < Trepan::Subcommand
+  unless defined?(HELP)
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = <<-EOH
+#{CMD}
+
+Show Ruby version information such as you'd get from "ruby -v", which
+is really just the value of RUBY_RELEASE_DATE.
+
+See also constants: RUBY_DESCRIPTION, RUBY_VERSION, and RUBY_RELEASE_DATE."
+    EOH
+    MIN_ABBREV   = 'ru'.size
+    NEED_STACK   = false
+    SHORT_HELP   = 'Ruby version information'
+   end
+
+  # def parse_options(args) # :nodoc
+  #   options = {}
+  #   parser = OptionParser.new do |opts|
+  #     opts.on("-v", 
+  #             "--[no-]verbose", "show additional version information") do
+  #       |v| 
+  #       options[:verbose] = v
+  #     end
+  #   end
+  #   parser.parse(args)
+  #   return options
+  # end
+
+  def run(args)
+    # options = parse_options(args[2..-1])
+    msg RUBY_DESCRIPTION
+    # if options[:verbose]
+    #   msg "Options:"
+    #   msg "  Interpreter type: #{Rubinius::INTERPRETER}"
+    #   if jit = Rubinius::JIT
+    #     msg "  JIT enabled: #{jit.join(', ')}"
+    #   else
+    #     msg "  JIT disabled"
+    #   end
+    # end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  $0 = __FILE__ + 'notagain' # So we don't run this again
+  require_relative '../../mock'
+  cmd = MockDebugger::sub_setup(Trepan::Subcommand::InfoRuby, false)
+  cmd.run(cmd.prefix)
+  %w(-v --verbose --no-verbose).each do |opt|
+    puts '-' * 10 + " #{opt}"
+    cmd.run(cmd.prefix + [opt])
+  end
+end

data/processor/command/irb.rb

@@ -7,7 +7,7 @@ class Trepan::Command::IRBCommand < Trepan::Command
   unless defined?(HELP)
     NAME         = File.basename(__FILE__, '.rb')
     HELP = <<-HELP
-          #{NAME} [-d]\tstarts an Interactive Ruby (IRB) session.
+#{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. 
@@ -64,10 +64,33 @@ Here then is a loop to query VM stack values:
     $trepan_irb_statements = nil
     $trepan_command = nil
 
-    conf = {:BACK_TRACE_LIMIT => settings[:maxstack]}
+    conf = {:BACK_TRACE_LIMIT => settings[:maxstack],
+            :RC => true}
+
+    # ?? Should we set GNU readline to what we have,
+    # or let IRB make its own determination? 
+
+    # Save the Readline history and set the Readline completion function 
+    # to be IRB's function 
+    if Trepan::GNU_readline? 
+      @proc.intf.save_history if @proc.intf.respond_to?(:save_history)
+      require 'irb/completion'
+      Readline.completion_proc = IRB::InputCompletor::CompletionProc
+    end
+
+    # And just when you thought, we'd never get around to 
+    # actually running irb...
     cont = IRB.start_session(@proc.frame.binding, @proc, conf)
-    trap('SIGINT', save_trap) # Restore old trap
+    trap('SIGINT', save_trap) # Restore our old interrupt function.
+
+    # Restore the debuggers' Readline history and the Readline completion 
+    # function
+    if Trepan::GNU_readline? && @proc.dbgr.completion_proc
+      @proc.intf.read_history if @proc.intf.respond_to?(:read_history)
+      Readline.completion_proc = @proc.dbgr.completion_proc 
+    end
 
+    # Respect any backtrace limit set in irb.
     back_trace_limit = IRB.CurrentContext.back_trace_limit
     if settings[:maxstack] !=  back_trace_limit
       msg("\nSetting debugger's BACK_TRACE_LIMIT (%d) to match irb's last setting (%d)" % 

data/processor/command/kill.rb

@@ -1,19 +1,21 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 require_relative 'base/cmd'
+require_relative '../../app/complete'
 class Trepan::Command::KillCommand < Trepan::Command
 
   unless defined?(HELP)
     NAME = File.basename(__FILE__, '.rb')
     HELP = <<-HELP
-#{NAME} [signal-number|signal-name|unconditionally]
+#{NAME} [signal-number|signal-name]
 
 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.
+If you are in interactive mode, you are prompted to confirm killing.
+However when this command is aliased from a command ending in !, no 
+questions are asked.
 
 Examples:
 
@@ -22,28 +24,37 @@ Examples:
   #{NAME} KILL # same as above
   #{NAME} kill # same as above
   #{NAME} -9   # same as above
-  #{NAME} 9    # same as above
+  #{NAME}  9   # same as above
+  #{NAME}! 9   # same as above
     HELP
 
+    ALIASES      = %w(kill!)
     CATEGORY     = 'running'
     MAX_ARGS     = 1  # Need at most this many
     SHORT_HELP  = 'Send this process a POSIX signal (default "9" is "kill -9")'
   end
+  
+  def complete(prefix)
+    completions = Signal.list.keys + 
+      Signal.list.values.map{|i| i.to_s} + 
+      Signal.list.values.map{|i| (-i).to_s} 
+    Trepan::Complete.complete_token(completions, prefix)
+  end
     
   # This method runs the command
   def run(args) # :nodoc
+    unconditional = ('!' == args[0][-1..-1])
     if args.size > 1
       sig = Integer(args[1]) rescue args[1]
       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
-#       FIXME: reinstate
-#       if 'KILL' == sig || Signal['KILL'] == sig
-#           @proc.intf.finalize
-#       end
+      if 'KILL' == sig || Signal['KILL'] == sig
+        @proc.intf.finalize
+      end
     else
-      if not confirm('Really kill?', false)
+      if not (unconditional || confirm('Really quit?', false))
         msg('Kill not confirmed.')
         return
       else 

data/processor/command/list.rb

@@ -146,7 +146,7 @@ disabled.
 
       else
         modfunc, container, first = @proc.parse_position(args[0])
-        if first == nil and modfunc == nil
+        if first == nil and container == nil
           # error should have been shown previously
           return nil, nil, nil
         end

data/processor/command/macro.rb

@@ -1,48 +1,63 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 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
+    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. 
+
+The macro should return either a String or an Array of Strings which
+is substituted for the command.  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.
 
-Define NAME as a debugger macro. Debugger macros get a list of arguments
-and should return a command string to use in its place.
+If instead, Array of Strings is returned, then the first string is
+unshifted from the array and executed. The remaning 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 a contrived example that shows how to issue 'finish' if we are in 
-method 'gcd' and 'step' otherwise:
+Here is an example. The below creates a macro called finish+ which
+issues two commands 'finish' followed by 'step':
 
-  macro step_unless_gcd Proc.new{|*args| \"$trepan_frame.method == 'gcd' ? 'finish' : 'step'\"}
+  macro fin+ Proc.new{|*args| %w(finish step)}
 
-Here is another real example. I use the following to debug a
-debugger command, assuming 'set debug dbgr' is set:
+Here is another example using arguments. I use the following to debug
+a debugger command:
 
-  macro dbgcmd Proc.new{|*args| \"debug $trepan_cmdproc.commands['\#{args[0]}'].run(\#{args.inspect})\"}
+  macro dbgcmd Proc.new{|*args| ["set debug dbgr", "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'.
+With the above, 'dbgcmd list 5' will ultimately expand to: 
+  set debug dbgr
+  debug $trepan_cmdproc.commands['list'].run(['5'])
+
+and will debug the debugger's 'list' command on the command 'list 5'.
 
 See also 'show macro'.
-"
+    HELP
 
     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])
+    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[macro_name] = proc_obj
-        msg "Macro \"#{macro_name}\" defined."
+        @proc.macros[cmd_name] = [proc_obj, cmd_argstr]
+        msg "Macro \"#{cmd_name}\" defined."
       else
-        errmsg "Expecting a Proc object; got: #{proc_argstr}"
+        errmsg "Expecting a Proc object; got: #{cmd_argstr}"
       end
     end
   end
@@ -52,8 +67,7 @@ if __FILE__ == $0
   require_relative '../mock'
   dbgr, cmd = MockDebugger::setup
   cmdproc = dbgr.core.processor
-  ["#{cmd.name} foo Proc.new{|x, y| x+y}",
-   "#{cmd.name} bad x+1",
+  ["#{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

data/processor/command/pr.rb

@@ -24,7 +24,7 @@ See 'set max string' to change the string truncation limit.
   end
   
   def run(args)
-    msg @proc.debug_eval(@proc.cmd_argstr, @proc.settings[:maxstring])
+    @proc.eval_code(@proc.cmd_argstr, @proc.settings[:maxstring])
   end
 end
         

data/processor/command/reload.rb

@@ -3,12 +3,16 @@
 require_relative 'base/submgr'
 
 class Trepan::Command::ReloadCommand < Trepan::SubcommandMgr
+  # Silence already initialized constant .. warnings
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
   NAME          = File.basename(__FILE__, '.rb')
   ALIASES       = %w(rel)
   HELP = 'Reload information'
   CATEGORY      = 'data'
   NEED_STACK    = false
   SHORT_HELP    = 'Reload information'
+  $VERBOSE      = old_verbose 
   def initialize(proc)
     super
   end