rbx-trepanning 0.0.5-universal-rubinius-1.2.1

data/processor/command/display.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+class Trepan::Command::DisplayCommand < Trepan::Command
+
+  unless defined?(HELP)
+    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
+octal, 'f' for float or 's' for string.
+
+For now, display expressions are only evaluated when in the same
+instruction sequence as the frame that was in effect when the display
+expression was set.  This is a departure from gdb and we may allow for
+more flexibility in the future to specify whether this should be the
+case or not.
+
+With no argument, evaluate and display all currently requested
+auto-display expressions.  Use "undisplay" to cancel display
+requests previously made.
+    HELP
+    
+    CATEGORY      = 'data'
+    NEED_STACK    = false
+    SHORT_HELP    = 'Display expressions when entering debugger'
+  end
+  
+  def run(args)
+
+    if args.size == 1
+      # Display anything active
+      @proc.run_eval_display
+    else
+      if %w(/c /x /o /f /s).member?(args[1])
+        if 2 == args.size
+          errmsg("Expecting an expression after the format")
+          return
+        end
+        format = args[1]
+        expr   = args[2..-1].join(' ')
+      else
+        format = nil
+        expr = args[1..-1].join(' ')
+      end
+
+      dp = @proc.displays.add(@proc.frame, expr, format)
+      unless dp
+        errmsg('Error evaluating "%s" in the current frame' % expr)
+        return
+      end
+      msg(dp.to_s(@proc.frame))
+      @proc.cmdloop_prehooks.insert_if_new(5, *@proc.display_hook)
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  def run_cmd(cmd, args)
+    cmd.run(args)
+    puts '==' * 10
+  end
+
+  # 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
+  vm_locations  = Rubinius::VM.backtrace(0, true)
+  cmd.proc.instance_variable_set('@frame ',
+                                 Trepan::Frame.new(self, 0, vm_locations[0]))
+
+  run_cmd(cmd, [cmd.name, 'e'])
+end

data/processor/command/down.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'up'
+
+# Debugger "down" command. Is the same as the "up" command with the 
+# direction (set by DIRECTION) reversed.
+class Trepan::Command::DownCommand < Trepan::Command::UpCommand
+
+  # Silence already initialized constant .. warnings
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
+  HELP = 
+"d(own) [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'.
+"
+
+  ALIASES       = %w(d)
+  NAME          = File.basename(__FILE__, '.rb')
+  SHORT_HELP    = 'Move frame in the direction of the caller of the last-selected frame'
+  $VERBOSE      = old_verbose 
+
+  def initialize(proc)
+    super
+    @direction = -1 # +1 for up.
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  # def sep ; puts '=' * 40 end
+  # cmd.run [cmd.name]
+  # %w(-1 0 1 -2).each do |count| 
+  #   puts "#{cmd.name} #{count}"
+  #   cmd.run([cmd.name, count])
+  #   sep 
+  # end
+  # def foo(cmd, cmd.name)
+  #   puts "#{cmd.name}"
+  #   cmd.run([cmd.name])
+  #   sep
+  #   puts "#{cmd.name} -1"
+  #   cmd.run([cmd.name, '-1'])
+  # end
+  # foo(cmd, cmd.name)
+end

data/processor/command/eval.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::EvalCommand < Trepan::Command
+
+  NAME          = File.basename(__FILE__, '.rb')
+  CATEGORY      = 'data'
+  HELP    = <<-HELP
+#{NAME} [STRING]
+
+Run code in the context of the current frame.
+
+The value of the expression is stored into a global variable so it
+may be used again easily. The name of the global variable is printed
+next to the inspect output of the value.
+
+If no string is given we run the string from the current source code
+about to be run
+
+#{NAME} 1+2  # 3
+#{NAME} @v
+#{NAME}      # Run current source-code line
+
+See also 'set autoeval'
+      HELP
+
+  NAME          = File.basename(__FILE__, '.rb')
+  NEED_STACK    = true
+  SHORT_HELP    = 'Run code in the current context'
+  def run(args)
+    if args.size == 1
+      loc = @proc.source_location_info
+      opts = {:reload_on_change => @proc.reload_on_change}
+      loc, junk, text = @proc.loc_and_text(loc, opts)
+      msg "eval: #{text}"
+    else
+      text = @proc.cmd_argstr
+    end
+    @proc.eval_code(text, settings[:maxstring])
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  arg_str = '1 + 2'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  puts "eval #{arg_str} is: #{cmd.run([cmd.name, arg_str])}"
+end

data/processor/command/exit.rb

@@ -0,0 +1,62 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+class Trepan::Command::ExitCommand < Trepan::Command
+
+  unless defined?(HELP)
+    ALIASES      = %w(quit q q! quit! exit!)
+    HELP = 
+      'exit [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.
+
+If you are in interactive mode, you are prompted to confirm
+quitting. However if you do not want to be prompted, add ! the end.
+(vim/vi/ed users can use alias q!).
+
+See also "kill".'
+
+    CATEGORY     = 'support'
+    MAX_ARGS     = 2  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    SHORT_HELP  = 'Exit program via "exit!()"'
+  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..-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
+
+    # FIXME: funnel to sort of more general finalize routine
+    @proc.dbgr.intf[-1].close
+
+    # No graceful way to stop threads...
+    # A little harsh, but for now let's go with this.
+    exit! exitrc
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  fork { cmd.run([cmd.name]) }
+  cmd.run([cmd.name, '10'])
+end

data/processor/command/finish.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+class Trepan::Command::FinishCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME}
+#{NAME}+
+
+Continue execution until leaving the current method.  Sometimes this
+is called 'step out'.
+
+Normally, stopping occurs just before the return on or yield out of a
+method. However sometimes one wants go to the calling method or place
+just beyond the current method.For this, suffix the command or an
+alias of it with a plus sign. The disadvantange of this is that you
+will no longer be in the scope of the method and so you won't be able
+to see variables of that method.
+
+Examples:
+  #{NAME}
+  #{NAME}+ 
+
+See also commands:
+'continue', 'break', 'next', 'nexti', 'step' for other ways to continue.
+    HELP
+    ALIASES      = %w(fin finish+ fin+)
+    CATEGORY     = 'running'
+    # execution_set = ['Running']
+    MAX_ARGS     = 1   # Need at most this many. 
+    NEED_STACK   = true
+    SHORT_HELP   = 'Step to end of current method (step out)'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    opts = @proc.parse_next_step_suffix(args[0])
+    if args.size == 1
+      # Form is: "finish" which means "finish 1"
+      level_count = 0
+    else
+      count_str = args[1]
+      count_opts = {
+        :msg_on_error => 
+        "The '#{NAME}' command argument must eval to an integer. Got: %s" % 
+        count_str,
+        :min_value => 1
+      }
+      count = @proc.get_an_int(count_str, count_opts)
+      return unless count
+      # step 1 is core.level_count = 0 or "stop next event"
+      level_count = count - 1  
+    end
+    if 0 == level_count and %w(return c-return).member?(@proc.event)
+      errmsg "You are already at the requested return event."
+    else
+      @proc.finish(level_count, opts)
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  [%W(#{cmd.name}), %w(fin 2-1), %w(n foo)].each do |c|
+    cmd.proc.instance_variable_set('@return_to_program', false)
+    cmd.run(c)
+    puts 'return_to_program: %s' % cmd.proc.instance_variable_get('@return_to_program')
+    puts 'step_count: %s' % cmd.proc.instance_variable_get('@step_count')
+  end
+  [%w(fin), [cmd.name]].each do |c|
+    cmd.proc.leave_cmd_loop = false
+    result = cmd.run(c)
+    puts cmd.proc.different_pos
+  end
+end

data/processor/command/frame.rb

@@ -0,0 +1,89 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::FrameCommand < Trepan::Command
+  CATEGORY     = 'stack'
+  HELP         = <<-HELP
+frame [frame-number]
+    
+Change the current frame to frame `frame-number' if specified, or the
+most-recent frame, 0, if no frame number specified.
+
+A negative number indicates the position from the other or
+least-recently-entered end.  So 'frame -1' moves to the oldest frame.
+Any variable or expression that evaluates to a number can be used as a
+position, however due to parsing limitations, the position expression
+has to be seen as a single blank-delimited parameter. That is, the
+expression '(5*3)-1' is okay while '( (5 * 3) - 1 )' isn't.
+
+Examples:
+   frame     # Set current frame at the current stopping point
+   frame 0   # Same as above
+   frame 5-5 # Same as above. Note: no spaces allowed in expression 5-5
+   frame 1   # Move to frame 1. Same as: frame 0; up
+   frame -1  # The least-recent frame
+
+See also 'up', 'down', and  'backtrace'.
+      HELP
+  NAME         = File.basename(__FILE__, '.rb')
+  SHORT_HELP   = 'Make a specific frame in the call stack the current frame'
+  
+  def run(args)
+
+    if args.size == 1
+      # Form is: "frame" which means "frame 0"
+      position_str = '0'
+    elsif args.size == 2
+      # Form is: "frame position"
+      position_str = args[1]
+    # elsif args.size == 3
+    #   # Form is: frame <position> <thread> 
+    #   name_or_id = args[1]
+    #   thread_str = args[2]
+    #   th = @proc.get_thread_from_string(thread_str)
+    #   if th
+    #     @proc.frame_setup(th.threadframe)
+    #     return
+    #   else
+    #     # FIXME: Give suitable error message was given
+    #   end
+    # else
+    #   # Form should be: "frame thread" which means
+    #   # "frame thread 0"
+    #   position_str = '0'
+    #   ## FIXME:
+    #   ## @proc.find_and_set_debugged_frame(frame, thread_id)
+    end
+
+    stack_size = @proc.dbgr.vm_locations.size
+    if stack_size == 0
+      errmsg('No frames recorded.')
+      return false
+    end
+    opts={
+      :msg_on_error => 
+      "The '#{NAME}' command requires a frame number. Got: #{position_str}",
+      :min_value => -stack_size,
+      :max_value => stack_size-1
+    }
+    frame_num = @proc.get_an_int(position_str, opts)
+    return false unless frame_num
+    
+    @proc.adjust_frame(frame_num, true)
+    return true
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  # def sep ; puts '=' * 40 end
+  # %w(0 1 -2).each {|count| cmd.run([cmd.name, count]); sep }
+  # def foo(cmd, cmd.name)
+  #   cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+  #   %w(0 -1).each {|count| cmd.run([cmd.name, count]); sep }
+  # end
+  # foo(cmd, cmd.name)
+end

data/processor/command/help.rb

@@ -0,0 +1,251 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../../app/complete'
+class Trepan::Command::HelpCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [command [subcommand]|expression]
+
+Without argument, print the list of available debugger commands.
+
+When an argument is given, it is first checked to see if it is command
+name. 'help where' gives help on the 'where' debugger command.
+
+If the environment variable $PAGER is defined, the file is
+piped through that command.  You'll notice this only for long help
+output.
+
+Some commands like 'info', 'set', and 'show' can accept an
+additional subcommand to give help just about that particular
+subcommand. For example 'help info line' give help about the
+info line command.
+
+See also 'examine' and 'whatis'.
+    HELP
+
+    ALIASES       = %w(?)
+    CATEGORIES    = {
+    'breakpoints' => 'Making the program stop at certain points',
+    'data'        => 'Examining data',
+    'files'       => 'Specifying and examining files',
+    'running'     => 'Running the program', 
+    'status'      => 'Status inquiries',
+    'support'     => 'Support facilities',
+    'stack'       => 'Examining the call stack'
+    }
+    CATEGORY      = 'support'
+    NEED_STACK    = false
+    SHORT_HELP    = 'Print commands or give help for command(s)'
+  end
+
+  def complete(prefix)
+    matches = Trepan::Complete.complete_token(CATEGORIES.keys + 
+                                              %w(* syntax all) + 
+                                          @proc.commands.keys, prefix)
+    aliases = Trepan::Complete.complete_token_filtered(@proc.aliases, prefix, 
+                                                       matches)
+    (matches + aliases).sort
+  end    
+
+  def complete(prefix)
+    matches = Trepan::Complete.complete_token(CATEGORIES.keys + 
+                                              %w(* syntax all) + 
+                                          @proc.commands.keys, prefix)
+    aliases = Trepan::Complete.complete_token_filtered(@proc.aliases, prefix, 
+                                                       matches)
+    (matches + aliases).sort
+  end    
+
+  def complete_token_with_next(prefix)
+    complete(prefix).map do |cmd| 
+      [cmd, @proc.commands.member?(cmd) ? @proc.commands[cmd] : nil]
+    end
+  end
+
+  # List the command categories and a short description of each.
+  def list_categories
+    section 'Classes of commands:'
+    CATEGORIES.keys.sort.each do |cat|
+      msg("%-13s -- %s" % [cat, CATEGORIES[cat]])
+    end
+    final_msg = '
+Type "help" followed by a class name for a list of commands in that class.
+Type "help syntax" for information on debugger command syntax.
+Type "help aliases" for a list of current aliases
+Type "help macros" for a list of current macros
+Type "help *" for the list of all commands, macros and aliases.
+Type "help all" for the list of all commands.
+Type "help REGEXP" for the list of commands matching /^#{REGEXP}/
+Type "help CLASS *" for the list of all commands in class CLASS.
+Type "help" followed by command name for full documentation.
+'
+    msg(final_msg)  
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    if args.size > 1
+      cmd_name = args[1]
+      if cmd_name == '*'
+        section 'All command names:'
+        msg columnize_commands(@proc.commands.keys.sort)
+        show_aliases  unless @proc.aliases.empty?
+        show_macros unless @proc.macros.empty?
+      elsif cmd_name =~ /^aliases$/i
+        show_aliases
+      elsif cmd_name =~ /^macros$/i
+        show_macros
+      elsif cmd_name =~ /^syntax$/i
+        show_command_syntax
+      elsif cmd_name =~ /^all$/i
+        CATEGORIES.sort.each do |category|
+          show_category(category[0], [])
+        end
+      elsif CATEGORIES.member?(cmd_name)
+        show_category(args[1], args[2..-1])
+      elsif @proc.commands.member?(cmd_name) or @proc.aliases.member?(cmd_name)
+        real_name = 
+          if @proc.commands.member?(cmd_name) 
+            cmd_name
+          else
+            @proc.aliases[cmd_name]
+          end
+        cmd_obj = @proc.commands[real_name]
+        help_text = 
+          cmd_obj.respond_to?(:help) ? cmd_obj.help(args) : 
+          cmd_obj.class.const_get(:HELP)
+        if help_text
+          msg(help_text) 
+          if cmd_obj.class.constants.member?('ALIASES') and
+              args.size == 2
+            msg "Aliases: #{cmd_obj.class.const_get(:ALIASES).join(', ')}"
+          end
+        end
+      elsif @proc.macros.member?(cmd_name)
+        msg "#{cmd_name} is a macro which expands to:"
+        msg "  #{@proc.macros[cmd_name]}", {:unlimited => true}
+      else
+        matches = @proc.commands.keys.grep(/^#{cmd_name}/).sort rescue []
+        if matches.empty?
+          errmsg("No commands found matching /^#{cmd_name}/. Try \"help\".")
+        else
+          section "Command names matching /^#{cmd_name}/:"
+          msg columnize_commands(matches.sort)
+        end
+      end
+    else
+      list_categories
+    end
+  end
+
+  def show_aliases
+    section 'All alias names:'
+    msg columnize_commands(@proc.aliases.keys.sort)
+  end
+
+  # Show short help for all commands in `category'.
+  def show_category(category, args)
+      
+    if args.size == 1 && args[0] == '*'
+      section "Commands in class %s:" % category
+      
+      cmds = @proc.commands.keys.select do |cmd_name|
+        category == @proc.commands[cmd_name].category
+      end.sort
+      width = settings[:maxwidth]
+      return columnize_commands(cmds)
+    end
+        
+    msg('')
+    section "Command class: %s" % category
+    msg('')
+    @proc.commands.keys.sort.each do |name|
+      next if category != @proc.commands[name].category
+      msg("%-13s -- %s" % [name, @proc.commands[name].short_help])
+    end
+  end
+
+  def show_command_syntax
+    section "Debugger command syntax"
+    msg <<-EOS
+Command tokenization syntax is very simple-minded. 
+
+If a line starts with #, the command is ignored. 
+If a line starts with !, the line is eval'd. 
+
+If the command you want eval'd uses the Ruby ! initally, add that
+after the first !.
+
+Commands are split at whereever ;; appears. This process disregards
+any quotes or other symbols that have meaning in Ruby. The strings
+after the leading command string are put back on a command queue. 
+
+Within a single command, tokens are then white-space split. Again,
+this process disregards quotes or symbols that have meaning in Ruby.
+Some commands like 'eval' and 'macro' have access to the untokenized
+string entered and make use of that rather than the tokenized list.
+
+The leading token is first looked up in the macro table. If it
+found there, the expansion is replaces the current command and possibly
+other commands pushed onto a command queue.  Next the leading token is
+looked up in the debugger alias table and the name may be substituted
+there. Finally, the leading token is looked up in the debugger alias
+table. If a match is found, the command name and arguments are
+dispatched to the command object that process the command.
+
+If the command is not found and "auto eval" is set on, then the
+command is eval'd in the context that the program is currently stopped
+at. If "auto eval" is not set on, then we display an error message
+that the entered string is "undefined".
+
+If you want irb-like command-processing, it's possible to go into an
+irb shell with the "irb" command. It is also possible to arrange going
+into an irb shell every time you enter the debugger.
+
+Examples:
+
+# This line does nothing. It is a comment
+s    # by default, this is an alias for the "step" command
+!s   # shows the value of variable step. 
+!!s  # Evaluates !s (or "not s"). The first ! is indicates evaluate.
+info program;; list # Runs two commands "info program" and "list"
+pr  "hi ;;-)"  # Syntax error since ;; splits the line and " is not closed.
+!puts "hi ;;-)" # One way to do the above.
+
+See also "alias", "irb", "set auto eval", and "set auto irb".
+    EOS
+  end
+
+  def show_macros
+    section 'All macro names:'
+    msg columnize_commands(@proc.macros.keys.sort)
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  cmd.run %W(#{cmd.name} help)
+  puts '=' * 40
+  cmd.run %W(#{cmd.name} *)
+  puts '=' * 40
+  cmd.run %W(#{cmd.name} fdafsasfda)
+  puts '=' * 40
+  cmd.run [cmd.name]
+  puts '=' * 40
+  cmd.run %W(#{cmd.name} support)
+  puts '=' * 40
+  cmd.run %W(#{cmd.name} support *)
+  puts '=' * 40
+  cmd.run %W(#{cmd.name} s.*)
+  puts '=' * 40
+  cmd.run %W(#{cmd.name} s<>)
+  puts '=' * 40
+  p cmd.complete('br')
+end