trepanning 0.1.6 → 1.93.32

data/processor/command/step.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2015 Rocky Bernstein <rockyb@rubyforge.net>
 require_relative '../command'
 require_relative '../../app/condition'
 class Trepan::Command::StepCommand < Trepan::Command
@@ -7,66 +7,75 @@ class Trepan::Command::StepCommand < Trepan::Command
   unless defined?(HELP)
     NAME = File.basename(__FILE__, '.rb')
     HELP = <<-HELP
-#{NAME}[+|=|-|<|>|!|<>] [into] [EVENT-NAME...] [count]
-#{NAME} until EXPRESSION
-#{NAME} thread
-#{NAME} to METHOD-NAME
-#{NAME} over 
-#{NAME} out
+**#{NAME}**[**+**|**=**|**-**|**<**|**>**|**!**|**<>**] [**into**] [*event-name*...] [*count*]
+
+**#{NAME} until** *expression*
+
+**#{NAME} thread**
+
+**#{NAME} to** *method-name*
+
+**#{NAME} over**
+
+**#{NAME} out**
 
 Execute the current line, stopping at the next event.  Sometimes this
 is called 'step into'.
 
-With an integer argument, step that many times.  With an 'until'
+With an integer argument, step that many times.  With an *until*
 expression that expression is evaluated and we stop the first time it
 is true.
 
-EVENT-NAME... is list of an event name which is one on 'call',
-'return', 'line', 'exception' 'c-call', 'c-return' or 'c-exception'.
+*event-name*... is list of an event name which is one on *call*,
+*return*, *line*, *exception* *c-call*, *c-return* or *c-exception*.
 If specified, only those stepping events will be considered. If no
 list of event names is given, then any event triggers a stop when the
 count is 0.
 
-There is however another way to specify an *single* EVENT-NAME, by
-suffixing one of the symbols '<', '>', or '!' after the command or on
-an alias of that.  A suffix of '+' on a command or an alias forces a
-move to another position, while a suffix of '-' disables this
-requirement.  A suffix of '>' will continue until the next
-call. ('finish' will run run until the return for that call.)
+There is however another way to specify an single *event-name*, by
+suffixing one of the symbols `<`, `>`, or `!` after the command or on
+an alias of that.  A suffix of `+` on a command or an alias forces a
+move to another position, while a suffix of `-` disables this
+requirement.  A suffix of `>'`will continue until the next
+call. (`finish` will run run until the return for that call.)
 
 If no suffix is given, the debugger setting 'different' determines
 this behavior.
 
-Examples: 
-  #{NAME}        # step 1 event, *any* event obeying 'set different' setting
-  #{NAME} 1      # same as above
-  #{NAME}+       # same but force stopping on a new line
-  #{NAME}=       # same but force stopping on a new line a new frame added
-  #{NAME}-       # same but force stopping on a new line a new frame added
-  #{NAME} 5/5+0  # same as above
-  #{NAME} line   # step only line events
-  #{NAME} call   # step only call call events
-  #{NAME}>       # step call and c-call events
-  #{NAME}<       # step only return and c-return events
-  #{NAME} call line   # step line *and* call events
-  #{NAME}<>      # same as step call c-call return c-return 
-  #{NAME} until a > b
-  #{NAME} over   # same as 'next'
-  #{NAME} out    # same as 'finish'
-  #{NAME} thread # step stopping only in the current thread. Is the same
-                 # as step until Thread.current.object_id == #object_id
-
-Related and similar is the 'next' (step over) and 'finish' (step out)
+Examples:
+--------
+
+    #{NAME}        # step 1 event, *any* event obeying 'set different' setting
+    #{NAME} 1      # same as above
+    #{NAME}+       # same but force stopping on a new line
+    #{NAME}=       # same but force stopping on a new line a new frame added
+    #{NAME}-       # same but force stopping on a new line a new frame added
+    #{NAME} 5/5+0  # same as above
+    #{NAME} line   # step only line events
+    #{NAME} call   # step only call call events
+    #{NAME}>       # step call and c-call events
+    #{NAME}<       # step only return and c-return events
+    #{NAME} call line   # step line *and* call events
+    #{NAME}<>      # same as step call c-call return c-return
+    #{NAME} until a > b
+    #{NAME} over   # same as 'next'
+    #{NAME} out    # same as 'finish'
+    #{NAME} thread # step stopping only in the current thread. Is the same
+                   # as step until Thread.current.object_id == #object_id
+
+Related and similar is the `next` (step over) and `finish` (step out)
 commands.  All of these are slower than running to a breakpoint.
 
-See also the commands:
-'skip', 'jump' (there's no 'hop' yet), 'continue', 'return' and
-'finish' for other ways to progress execution.
+See also:
+---------
+`skip`, `jump` (there's no 'hop' yet), `continue`, `return` and
+`finish` for other ways to progress execution.
     HELP
 
-    ALIASES      = %w(s step+ step- step< step> step<> step! s> s< s+ s- 
+    ALIASES      = %w(s step+ step- step< step> step<> step! s> s< s+ s-
                       s<> s! s=)
     CATEGORY     = 'running'
+    NEED_STACK   = true
     NEED_RUNNING = true
     SHORT_HELP   = 'Step program (possibly entering called functions)'
 
@@ -116,15 +125,15 @@ See also the commands:
       else
         count_str = args[1]
         int_opts = {
-          :msg_on_error => 
-          "The 'step' command argument must eval to an integer. Got: %s" % 
+          :msg_on_error =>
+          "The 'step' command argument must eval to an integer. Got: %s" %
           count_str,
           :min_value => 1
         }.merge(opts)
         count = @proc.get_an_int(count_str, int_opts)
         return unless count
         # step 1 is core.step_count = 0 or "stop next event"
-        step_count = count - 1  
+        step_count = count - 1
       end
     end
     @proc.step(step_count, opts, condition)

data/processor/command/tbreak.rb

@@ -1,20 +1,25 @@
 require_relative './../command'
 require_relative 'break'
 
-class Trepan::Command::SetTempBreakpointCommand < 
+class Trepan::Command::SetTempBreakpointCommand <
     Trepan::Command::BreakCommand
   ALIASES      = []
   CATEGORY     = 'breakpoints'
   NAME         = File.basename(__FILE__, '.rb')
   HELP         = <<-HELP
+**#{NAME}**
+**#{NAME}** *location* [ {if|unless} *condition* ]
+#{NAME}
+
 Same as break, but the breakpoint is deleted when it is hit.
 
-See also "break".
+See also:
+---------
+`condition`, `continue`, `help syntax location`, and `break`
       HELP
   SHORT_HELP   = 'Set a temporary breakpoint'
-  
+
   def run(args)
     super args, true
   end
 end
-

data/processor/command/unalias.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010-2011, 2015 Rocky Bernstein <rockyb@rubyforge.net>
 require_relative '../command'
 require_relative '../../app/complete'
 
@@ -6,26 +6,28 @@ class Trepan::Command::UnaliasCommand < Trepan::Command
 
   unless defined?(HELP)
     HELP = <<-HELP
-unalias ALIAS
+**unalias** *alias*
 
-Remove alias ALIAS
+Remove alias *alias*.
 
-See also 'alias'.
+See also:
+---------
+`alias` and `show alias`.
 HELP
 
     CATEGORY      = 'support'
     MIN_ARGS      = 1
     # MAX_ARGS      = 1  # Need at most this many
     NAME          = File.basename(__FILE__, '.rb')
-    NEED_STACK    = true
+    NEED_STACK    = false
     SHORT_HELP    = 'Remove an alias'
   end
-  
+
   def complete(prefix)
     Trepan::Complete.complete_token(@proc.aliases.keys, prefix)
   end
 
-  # Run command. 
+  # Run command.
   def run(args)
     args[1..-1].each do |arg|
       if @proc.aliases.member?(arg)

data/processor/command/undisplay.rb

@@ -1,19 +1,23 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010-2011, 2015 Rocky Bernstein <rockyb@rubyforge.net>
 require_relative '../command'
 
 # undisplay display-number...
 class Trepan::Command::UndisplayCommand < Trepan::Command
-    
+
   unless defined?(HELP)
     NAME = File.basename(__FILE__, '.rb')
     HELP = <<EOH
-#{NAME} DISPLAY_NUMBER ...
+**#{NAME}** *display-number* ...
+
 Cancel some expressions to be displayed when program stops.
 Arguments are the code numbers of the expressions to stop displaying.
 No argument means cancel all automatic-display expressions.
-"delete display" has the same effect as this command.
-Use "info display" to see current list of display numbers.
+
+See also:
+---------
+`delete display` has the same effect as this command.
+Use `info display` to see current list of display numbers.
 EOH
 
     CATEGORY      = 'data'
@@ -26,7 +30,7 @@ EOH
   end
 
   def run(args)
-    
+
     if args.size == 1
       if confirm('Delete all displays?', false)
         @proc.displays.clear
@@ -37,7 +41,7 @@ EOH
     args[1..-1].each do |arg|
       opts = {:msg_on_error => '%s must be a display number' % arg}
       i = @proc.get_an_int(arg, opts)
-      if i 
+      if i
         unless @proc.displays.delete_index(i)
           errmsg("No display number %d." % i)
           return

data/processor/command/up.rb

@@ -1,21 +1,26 @@
-# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010-2011, 2013, 2015 Rocky Bernstein <rockyb@rubyforge.net>
 require_relative '../command'
 require_relative '../../app/util'
 
 # up command. Like 'down' but the direction (set by DIRECTION) is different.
 #
-# NOTE: The down command  subclasses this, so beware when changing! 
+# NOTE: The down command  subclasses this, so beware when changing!
 class Trepan::Command::UpCommand < Trepan::Command
 
   Trepan::Util.suppress_warnings {
     NAME        = File.basename(__FILE__, '.rb')
     HELP        = <<-HELP
-#{NAME} [count]
+**#{NAME}** [*count*]
 
 Move the current frame up in the stack trace (to an older frame). 0 is
-the most recent frame. If no count is given, move up 1.
+the most-recent frame. If no count is given, move up 1.
 
-See also 'down' and 'frame'.
+A negative number moves in the opposite direction.
+
+See also:
+---------
+
+`down`, `frame`.
   HELP
 
     CATEGORY      = 'stack'
@@ -23,20 +28,20 @@ See also 'down' and 'frame'.
     NEED_STACK    = true
     SHORT_HELP    = 'Move frame in the direction of the caller of the last-selected frame'
   }
-  
+
   require_relative '../../app/frame'
   include Trepan::Frame
 
   def complete(prefix)
     @proc.frame_complete(prefix, @direction)
   end
-  
+
   def initialize(proc)
     super
     @direction = +1 # -1 for down.
   end
 
-  # Run 'up' command. 
+  # Run 'up' command.
   def run(args)
 
     # FIXME: move into @proc and test based on NEED_STACK.
@@ -53,7 +58,7 @@ See also 'down' and 'frame'.
       count_str = args[1]
       name_or_id = args[1]
       opts = {
-        :msg_on_error => 
+        :msg_on_error =>
         "The '#{NAME}' command argument requires a frame number. Got: %s" % count_str,
         :min_value => low, :max_value => high
       }
@@ -72,20 +77,20 @@ if __FILE__ == $0
 
   def sep ; puts '=' * 40 end
   cmd.run [cmd.name]
-  %w(-1 0 1 -2).each do |count| 
+  %w(-1 0 1 -2).each do |count|
     puts "#{cmd.name} #{count}"
     cmd.run([cmd.name, count])
-    sep 
+    sep
   end
   def foo(cmd, name)
     cmd.proc.frame_setup(RubyVM::Frame::current)
     puts "#{name}"
     cmd.run([name])
     sep
-    %w(-2 -1).each do |count| 
+    %w(-2 -1).each do |count|
       puts "#{name} #{count}"
       cmd.run([name, count])
-      sep 
+      sep
     end
   end
   foo(cmd, cmd.name)

data/processor/command/watchg.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010-2011, 2015 Rocky Bernstein <rockyb@rubyforge.net>
 require_relative '../command'
 require_relative '../../app/complete'
 
@@ -8,29 +8,33 @@ class Trepan::Command::WatchgCommand < Trepan::Command
     NAME      = File.basename(__FILE__, '.rb')
     CATEGORY  = 'breakpoints'
     HELP         = <<-EOH
-#{NAME} GLOBAL_VARIABLE [on]
-#{NAME} GLOBAL_VARIABLE nostop
-#{NAME} GLOBAL_VARIABLE off
+**#{NAME}** *global-variable* [**on**]
+**#{NAME}** *global-variable** **nostop**
+**#{NAME}** *global-variable* **off**
 
-Use Kernel.trace_var to trace changes of global variable
-GLOBAL_VARIABLE.  If nostop is given, then we just print out the 
+Use *Kernel.trace_var* to trace changes of global variable
+*global-variable*.  If `nostop` is given, then we just print out the
 location and variable name but do not stop in the debugger.
 
-To remove a prior trace, add "off" to the end.
+To remove a prior trace, add `off` to the end.
 
 Note in contrast to other events, stopping for variable tracing occurs
 *after* the event, not before.
 
-NOTE: this command name will likely change in the future.
+*Note:* this command name will likely change in the future.
 
 Examples:
-#{NAME} $PROGRAM_NAME       # enter debugger if global $PROGRAM_NAME changes
-#{NAME} $PROGRAM_NAME on    # same as above
-#{NAME} $PROGRAN_NAME stop  # just print places the varaible is set
-                            # along with the location
-#{NAME} $PROGRAN_NAME off   # remove watching changes
+---------
 
-See also 'info breakpoints'
+    #{NAME} $PROGRAM_NAME       # enter debugger if global $PROGRAM_NAME changes
+    #{NAME} $PROGRAM_NAME on    # same as above
+    #{NAME} $PROGRAN_NAME stop  # just print places the varaible is set
+                                # along with the location
+    #{NAME} $PROGRAN_NAME off   # remove watching changes
+
+See also:
+---------
+`info breakpoints`
     EOH
 
     MAX_ARGS     = 3
@@ -54,8 +58,8 @@ See also 'info breakpoints'
           return
         end
       else
-        Kernel.trace_var(traced_sym, 
-                         lambda {|val| 
+        Kernel.trace_var(traced_sym,
+                         lambda {|val|
                            @proc.core.trace_var_processor(traced_var, val)})
       end
       @proc.traced_vars[traced_var] = action
@@ -111,4 +115,3 @@ if __FILE__ == $0
   $FOO=1
   cmd.run(%w(variable $FOO off))
 end
-

data/processor/complete.rb

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Part of Trepan::CmdProcess to handle command completion
+require_relative '../app/complete'
+require_relative 'virtual'
+
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  attr_reader   :leading_str     # leading part of string. Used in
+                                 # command completion
+
+  # Handle initial completion. We draw from the commands, aliases,
+  # and macros for completion. However we won't include aliases which
+  # are prefixes of other commands.
+  def complete(str, last_token)
+    @leading_str = str
+    next_blank_pos, token = Trepan::Complete.next_token(str, 0)
+    return [''] if token.empty? && !last_token.empty?
+    match_pairs = Trepan::Complete.complete_token_with_next(@commands,
+                                                            token)
+    match_hash = {}
+    match_pairs.each do |pair|
+      match_hash[pair[0]] = pair[1]
+    end
+    alias_pairs = Trepan::Complete.
+      complete_token_filtered_with_next(@aliases, token, match_hash,
+                                        @commands)
+    match_pairs += alias_pairs
+
+    macro_pairs = Trepan::Complete.
+      complete_token_filtered_with_next(@macros, token, match_hash,
+                                        @commands)
+    match_pairs += macro_pairs
+
+    if str[next_blank_pos..-1].empty?
+      return match_pairs.map{|pair| pair[0]}.sort
+    else
+      alias_pairs.each do |pair|
+        match_hash[pair[0]] = pair[1]
+      end
+    end
+    if match_pairs.size > 1
+      # FIXME: figure out what to do here.
+      # Matched multiple items in the middle of the string
+      # We can't handle this so do nothing.
+      return []
+      # return match_pairs.map do |name, cmd|
+      #   ["#{name} #{args[1..-1].join(' ')}"]
+      # end
+    end
+    # match_pairs.size == 1
+    next_complete(str, next_blank_pos, match_pairs[0][1], last_token)
+  end
+
+  def next_complete(str, next_blank_pos, cmd, last_token)
+    next_blank_pos, token = Trepan::Complete.next_token(str, next_blank_pos)
+    return [] if token.empty? && !last_token.empty?
+
+    if cmd.respond_to?(:complete_token_with_next)
+      match_pairs = cmd.complete_token_with_next(token)
+      return [] if match_pairs.empty?
+      if str[next_blank_pos..-1].rstrip.empty? &&
+          (token.empty? || token == last_token)
+        return match_pairs.map { |completion, junk| completion }
+      else
+        if match_pairs.size == 1
+          return next_complete(str, next_blank_pos, match_pairs[0][1],
+                               last_token)
+        else
+          # FIXME: figure out what to do here.
+          # Matched multiple items in the middle of the string
+          # We can't handle this so do nothing.
+          return []
+        end
+      end
+    elsif cmd.respond_to?(:complete)
+      matches = cmd.complete(token)
+      return [] if matches.empty?
+      if str[next_blank_pos..-1].rstrip.empty? &&
+          (token.empty? || token == last_token)
+        return matches
+      else
+        # FIXME: figure out what to do here.
+        # Matched multiple items in the middle of the string
+        # We can't handle this so do nothing.
+        return []
+      end
+    else
+      return []
+    end
+  end
+end
+
+if __FILE__ == $0
+
+  require_relative 'load_cmds'
+  class Trepan::CmdProcessor
+    def initialize(core, settings={})
+    end
+  end
+
+
+  cmdproc = Trepan::CmdProcessor.new(nil)
+
+  def cmdproc.errmsg(mess)
+    puts "** #{mess}"
+  end
+
+  def cmdproc.msg(mess)
+    puts mess
+  end
+
+  cmddir = File.join(File.dirname(__FILE__), 'command')
+  cmdproc.instance_variable_set('@settings', {})
+  cmdproc.load_cmds_initialize
+  p cmdproc.complete("d", 'd')
+  p cmdproc.complete("sho d", 'd')
+  p cmdproc.complete('', '')
+end