trepanning 0.0.4

data/processor/command/disassemble.rb

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../../app/disassemble'
+require_relative '../../app/file'
+
+class Trepan::Command::DisassembleCommand < Trepan::Command
+    include Trepan::Disassemble
+    include Trepanning
+
+  unless defined?(HELP)
+    HELP = 
+"disassemble [thing] [full]
+
+With no argument, disassemble the current frame.  With a method,
+disassemble that method. '.' can be used to indicate the instruction
+sequence for the current frame.
+
+By default, just this instruction sequence is disassembled, not others
+which may be accessed off of this one, including any catch table the
+instruction sequence might have. If 'full' is given, all instruction
+sequences are include.
+
+Examples:
+
+  disassemble 
+  disas .       # Same as above
+  disas . full  # At least the instruction sequence above but maybe more
+  disas require_relative # disassemble method 'require_relative'
+ "
+
+    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
+
+  # FIXME: put in processor/data.rb? 
+
+  def marked_disassemble(iseq, include_children)
+    iseqs = include_children ? iseq.child_iseqs : [iseq]
+      iseqs.each do |iseq|
+      ary = mark_disassembly(iseq.disasm_nochildren, 
+                             @proc.frame.iseq.equal?(iseq),
+                             @proc.frame.pc_offset,
+                             iseq.brkpts)
+      msg ary
+    end
+  end
+
+  # Run command. 
+  def run(args)
+
+    obj = nil
+    include_children = 
+      if args.size > 1 && args[-1] == 'full'
+        args.pop
+        true
+      else
+        false
+      end
+    if args.size == 1 || '.' == args[1]
+      # Form is: "disassemble" or "disassemble ."
+      if @proc.frame.type == 'CFUNC'
+        errmsg "Can't handle C functions yet."
+        return
+      elsif @proc.frame.iseq
+        marked_disassemble(@proc.frame.iseq, include_children)
+        return
+      end
+    else 
+      if !(matches = find_iseqs(ISEQS__, args[1])).empty?
+        # FIXME: do something if there is more than one
+        iseq = matches[0]
+      else        
+        iseq = @proc.object_iseq(args[1])
+      end
+      marked_disassemble(iseq, include_children) if iseq
+      return
+    end
+    errmsg("Sorry can't handle right now.")
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require 'thread_frame'
+
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  def small_fn(cmd, name)
+    cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+    cmd.run [name]
+  end
+  small_fn(cmd, name)
+  p = Proc.new do 
+    |x,y| x + y
+  end
+  cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+  cmd.run([name, 'p'])
+end

data/processor/command/display.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+
+class Trepan::Command::DisplayCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = <<EOH
+display [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.
+EOH
+    
+    CATEGORY      = 'data'
+    NAME          = File.basename(__FILE__, '.rb')
+    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 'thread_frame'
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+
+  def run_cmd(cmd, args)
+    cmd.run(args)
+    puts '==' * 10
+  end
+
+  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])
+  e = 5
+  run_cmd(cmd, [name, 'e'])
+end

data/processor/command/down.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+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 'thread_frame'
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+
+  def sep ; puts '=' * 40 end
+  cmd.run [name]
+  %w(-1 0 1 -2).each do |count| 
+    puts "#{name} #{count}"
+    cmd.run([name, count])
+    sep 
+  end
+  def foo(cmd, name)
+    cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+    puts "#{name}"
+    cmd.run([name])
+    sep
+    puts "#{name} -1"
+    cmd.run([name, '-1'])
+  end
+  foo(cmd, name)
+end

data/processor/command/enable.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'disable'
+
+# enable breakpoint command. Is like disable but the parameter
+# to @proc.en_disable_breakpoint_by_number is different (set as
+# ENABLE_PARM below).
+class Trepan::Command::EnableCommand < Trepan::Command::DisableCommand
+
+  # Silence already initialized constant .. warnings
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
+  HELP = 
+      'enable [display] bpnumber [bpnumber ...]
+    
+Enables the breakpoints given as a space separated list of breakpoint
+numbers. See also "info break" to get a list.
+'
+
+  ALIASES       = %w(en)
+  NAME          = File.basename(__FILE__, '.rb')
+  SHORT_HELP    = 'Enable some breakpoints'
+  $VERBOSE      = old_verbose 
+
+  def initialize(proc)
+    super
+    @enable_parm = true # true if enable 
+  end
+
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  cmd.run([name])
+  cmd.run([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'])
+end

data/processor/command/exit.rb

@@ -0,0 +1,54 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+class Trepan::Command::ExitCommand < Trepan::Command
+
+  unless defined?(HELP)
+    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.
+
+See also the commands "quit" and "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'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  name = File.basename(__FILE__, '.rb')
+  fork { cmd.run([name]) }
+  cmd.run([name, '10'])
+end

data/processor/command/finish.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+
+class Trepan::Command::FinishCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"finish [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
+guarentee 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, 'finish', 'step' and 'next' may slow a program down
+while 'break' will have less overhead.
+"
+    ALIASES      = %w(fin)
+    CATEGORY     = 'running'
+    # execution_set = ['Running']
+    MAX_ARGS     = 1   # Need at most this many. 
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    SHORT_HELP   = 'Step program without entering called functions'
+  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 'next' 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'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  [%w(finish 1), %w(fin 2-1), %w(n foo)].each do |c|
+    cmd.proc.next_level = 0
+    cmd.proc.leave_cmd_loop = false
+    result = cmd.run(c)
+    puts 'Run result: %s' % result
+    puts 'level_count %d, leave_cmd_loop: %s' % [cmd.proc.next_level,
+                                                cmd.proc.leave_cmd_loop]
+  end
+  [%w(fin), %w(finish)].each do |c|
+    cmd.proc.next_level = 0
+    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,117 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../../app/frame'
+
+class Trepan::Command::FrameCommand < Trepan::Command
+
+  include Trepan::Frame
+
+  unless defined?(HELP)
+    HELP = 
+"frame [thread-Name] [frame-number]
+    
+Change the current frame to frame `frame-number' if specified, or the
+most-recent frame, 0, if no frame number specified.
+
+If a thread name or thread number is given, change the current frame
+to a frame in that thread. Dot (.) can be used to indicate the name of
+the current frame the debugger is stopped in.
+
+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 .   # Same as above. 'current thread' is explicit.
+   frame . 0 # Same as above.
+   frame 1   # Move to frame 1. Same as: frame 0; up
+   frame -1  # The least-recent frame
+   frame MainThread 0 # Switch to frame 0 of thread MainThread
+   frame MainThread   # Same as above
+   frame -2434343 0   # Use a thread number instead of name
+
+See also 'up', 'down' 'where' and 'info thread'.
+"
+
+    CATEGORY      = 'stack'
+    MAX_ARGS      = 2  # Need at most this many
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = true
+    SHORT_HELP    = 'Select and print a stack frame'
+  end
+  
+  # The simple case: thread frame switching has been done or is
+  # not needed and we have an explicit position number as a string
+  def one_arg_run(position_str)
+    stack_size = @proc.top_frame.stack_size - @proc.hide_level
+    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
+      
+    # FIXME: move into @proc and test based on NEED_STACK.
+    if not @proc.top_frame
+      errmsg('No frames recorded.')
+      return false
+    end
+        
+    @proc.adjust_frame(frame_num, true)
+    return true
+  end
+
+  # Run a frame command. This routine is a little complex
+  # because we allow a number parameter variations.
+  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
+    one_arg_run(position_str)
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require 'thread_frame'
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+
+  def sep ; puts '=' * 40 end
+  %w(0 1 -2).each {|count| cmd.run([name, count]); sep }
+  def foo(cmd, name)
+    cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+    %w(0 -1).each {|count| cmd.run([name, count]); sep }
+  end
+  foo(cmd, name)
+end

data/processor/command/help.rb

@@ -0,0 +1,146 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+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'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+
+  cmd.run %w(help help)
+  puts '=' * 40
+  cmd.run %w(help *)
+  puts '=' * 40
+  cmd.run %w(help fdafsasfda)
+  puts '=' * 40
+  cmd.run %w(help)
+  puts '=' * 40
+  cmd.run %w(help support)
+  puts '=' * 40
+  cmd.run %w(help support *)
+
+  puts '=' * 40
+  cmd.run %w(help s.*)
+  puts '=' * 40
+  cmd.run %w(help s<>)
+end