rbx-trepanning 0.0.1-universal-rubinius

data/processor/command/directory.rb

@@ -0,0 +1,43 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+class Trepan::Command::DirectoryCommand < Trepan::Command
+
+  unless defined?(HELP)
+    ALIASES      = %w(dir)
+    CATEGORY     = 'files'
+    MAX_ARGS     = 1  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+Add directory DIR to beginning of search path for source files.
+DIR can also be $cwd for the current working directory, or $cdir for the
+directory in which the debugged file start.
+With no argument, reset the search path to $cdir:$cwd, the default.
+
+This command may be useful for debugging into Rubinius methods such as
+kernel/common/module.rb if have the source code somewhere.
+      HELP
+    SHORT_HELP  = 
+      'Add directory DIR to beginning of search path for source files'
+  end
+    
+  # This method runs the command
+  def run(args) # :nodoc
+    if args.size > 1
+      settings[:directory] = "#{args[1]}:#{settings[:directory]}"
+      msg "Source directories searched: #{settings[:directory]}"
+    else
+      if confirm('Reintialize source path to empty?', false)
+        settings[:directory] = '$cdir:$cwd'
+        msg 'Source directories searched: $cdir:$cwd'
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, '/tmp'])
+end

data/processor/command/disassemble.rb

@@ -0,0 +1,103 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+require_relative '../../app/iseq'
+
+class Trepan::Command::DisassembleCommand < Trepan::Command
+  NAME         = File.basename(__FILE__, '.rb')
+  ALIASES      = %w(dis)
+  CATEGORY     = 'data'
+  HELP         = <<-HELP
+#{NAME} [all|method]
+
+Disassembles Rubinius VM instructions. By default, the bytecode for the
+current line is disassembled only.
+
+If a method name is given, disassemble just that method. If the
+argument is 'all', the entire method is shown as bytecode.
+
+Examples:
+   #{NAME}              # dissasemble VM for current line
+   #{NAME} all          # disassemble entire current method
+   #{NAME} [1,2].max    # disassemble max method of Array
+   #{NAME} Object.is_a? # disassemble Object.is_a?
+   #{NAME} is_a?        # same as above (probably)
+
+    HELP
+
+  NEED_STACK   = true
+  SHORT_HELP   = 'Show the bytecode for the current method'
+
+  def disassemble_method(cm)
+    frame_ip = (@proc.frame.method == cm) ? @proc.frame.next_ip : nil
+    lines = cm.lines
+    next_line_ip = 0
+    next_i = 1
+    cm.decode.each do |insn|
+      show_line = 
+        if insn.ip >= next_line_ip
+          next_line_ip = lines.at(next_i+1)
+          line_no = lines.at(next_i)
+          next_i += 2
+          true
+        else
+          false
+        end
+          
+      prefix = Trepanning::ISeq::disasm_prefix(insn.ip, frame_ip, cm)
+      str = "#{prefix} #{insn}"
+      if show_line
+        str += 
+          if insn.instance_variable_get('@comment')
+            ' '
+          elsif str[-1..-1] !~/\s/
+            '    '
+          else
+            ''
+          end
+        str += "# line: #{line_no}"  
+      end
+      msg str
+    end
+  end
+
+  # Run command. 
+  def run(args)
+    if 1 == args.size
+      @proc.show_bytecode
+    elsif 'all' == args[1]
+      # FIXME: first msg is a section command.
+      msg "Bytecode for #{@proc.frame.vm_location.describe}"
+      disassemble_method(current_method)
+    else
+      cm = @proc.parse_method(args[1])
+      if cm
+        # FIXME: first msg is a section command.
+        msg "Bytecode for method #{args[1]}"
+        disassemble_method(cm.executable)
+      else
+        errmsg "Method #{args[1]} not found"
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  def foo(cmd)
+    puts "#{cmd.name}"
+    cmd.run([cmd.name])
+    puts '=' * 40
+    puts "#{cmd.name} all"
+    cmd.run([cmd.name, 'all'])
+    puts '=' * 40
+    p cmd.proc.frame.vm_location.describe
+    cmd.run([cmd.name, 'foo'])
+    puts '=' * 40
+    # require_relative '../../lib/trepanning'
+    # debugger
+    cmd.run([cmd.name, 'self.setup'])
+  end
+  foo(cmd)
+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,31 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::EvalCommand < Trepan::Command
+
+  CATEGORY      = 'data'
+  HELP    = <<-HELP
+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.
+      HELP
+
+  NAME          = File.basename(__FILE__, '.rb')
+  NEED_STACK    = true
+  SHORT_HELP    = 'Run code in the current context'
+  def run(args)
+    @proc.debug_eval(@proc.cmd_argstr, @proc.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)
+  dbgr.instance_variable_set('@cmd_argstr', arg_str)
+
+  ## cmd.run([cmd.name, arg_str])
+end

data/processor/command/exit.rb

@@ -0,0 +1,58 @@
+# 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
+    # 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,78 @@
+# -*- 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} [levels]
+
+Continue execution until leaving the current function. 
+Sometimes this is called 'step out'.
+
+When `levels' is specified, that many frame levels need to be
+popped. The default is 1.  Note that 'yield' and exceptions raised my
+reduce the number of stack frames. Also, if a thread is switched, we
+stop ignoring levels.
+
+'next>' is similar in that it stops at a return, but it doesn't
+guarantee 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, '#{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. 
+    NEED_STACK   = true
+    SHORT_HELP   = 'Step to end of current method (step out)'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    opts = {}
+    if args.size == 1
+      # Form is: "finish" which means "finish 1"
+      level_count = 0
+    else
+      count_str = args[1]
+      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, 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} 1), %w(fin 2-1), %w(n foo)].each do |c|
+    cmd.proc.leave_cmd_loop = false
+    result = cmd.run(c)
+    puts 'Run result: %s' % result
+    puts 'leave_cmd_loop: %s' % cmd.proc.leave_cmd_loop
+  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,146 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+class Trepan::Command::HelpCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"help [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'.
+"
+
+
+    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'
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = false
+    SHORT_HELP    = 'Print commands or give help for command(s)'
+  end
+
+  # List the command categories and a short description of each.
+  def list_categories
+    msg("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 *" 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 == '*'
+        msg("All command names:")
+        msg columnize_commands(@proc.commands.keys.sort)
+      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
+      else 
+        matches = @proc.commands.keys.grep(/^#{cmd_name}/).sort rescue []
+        if matches.empty?
+          errmsg("No commands found matching /^#{cmd_name}/. Try \"help\".")
+        else
+          msg("Command names matching /^#{cmd_name}/:")
+          msg columnize_commands(matches.sort)
+        end
+      end
+    else
+      list_categories
+    end
+    return false  # Don't break out of cmd loop
+  end
+
+  # Show short help for all commands in `category'.
+  def show_category(category, args)
+      
+    if args.size == 1 && args[0] == '*'
+      msg("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("%s." % CATEGORIES[category])
+    msg("List of commands:\n")
+    @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
+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<>)
+end

data/processor/command/info.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/submgr'
+
+class Trepan::Command::InfoCommand < Trepan::SubcommandMgr
+  unless defined?(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.
+'
+
+    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'
+  dbgr, cmd = MockDebugger::setup
+end