rb8-trepanning 0.1.3-universal-ruby-1.9.2

data/processor/command/down.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 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 = <<-HELP
+#{NAME} [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'.
+  HELP
+
+  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/edit.rb

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::EditCommand < Trepan::Command
+
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
+  NAME        = File.basename(__FILE__, '.rb')
+  HELP    = <<-HELP
+#{NAME} [[FILE] [LINE]]
+
+With no argument, edits file containing most recent line listed.
+The value of the environment variable EDITOR is used for the
+editor to run. If no EDITOR environment variable is set /bin/ex
+is used. The editor should support line and file positioning via
+   editor-name +line file-name
+(Most editors do.)
+
+Examples:
+#{NAME}            # Edit current location
+#{NAME} 7          # Edit current file at line 7
+#{NAME} test.rb    # Edit test.rb, line 1
+#{NAME} test.rb 10 # Edit test.rb  line 10
+      HELP
+
+  ALIASES       = %w(e)
+  CATEGORY      = 'files'
+  NEED_STACK    = false
+  SHORT_HELP    = 'Invoke an editor on some source code'
+  MAX_ARGS      = 2
+  $VERBOSE      = old_verbose 
+
+  # FIXME: redo with locations and kparse.
+  def run(args)
+    case args.size
+    when 1
+      unless @proc.context
+        errmsg "We are not in a state that has an associated file."
+        return 
+      end
+      file = @proc.frame.file
+      line = @proc.frame.line
+    when 2
+      line = Integer(args[1]) rescue nil
+      if line 
+        unless @proc.context
+          errmsg "We are not in a state that has an associated file."
+          return 
+        end
+        file = @proc.frame.file
+      else 
+        file = args[1]
+        line = 1
+      end
+    when 3
+      line, file =  args[2], args[1]
+    else
+      errmsg "edit needs at most 2 args." 
+    end
+    editor = ENV['EDITOR'] || '/bin/ex'
+    if File.readable?(file)
+      file = File.basename(file) if settings[:basename]
+      edit_cmd = "#{editor} +#{line} \"#{file}\""
+      msg "Running #{edit_cmd}..."
+      system(edit_cmd)
+      msg "Warning: return code was #{$?.exitstatus}" if $?.exitstatus != 0
+    else
+      errmsg "File \"#{file}\" is not readable."
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run [cmd.name] if ARGV.size > 0
+end

data/processor/command/enable.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+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
+  NAME        = File.basename(__FILE__, '.rb')
+  HELP        = <<-HELP
+#{NAME} BPNUM1 [BPNUM2 ...]
+    
+Enables breakpoints BPNUM1. Breakpoints numbers are given as a space-
+separated list numbers. 
+
+See also "info break" to get a list of breakpoints.
+  HELP
+
+  ALIASES       = %w(en)
+  SHORT_HELP    = 'Enable some breakpoints'
+  $VERBOSE      = old_verbose 
+
+  def run(args)
+    if args.size == 1
+      errmsg('No breakpoint number given.')
+      return
+    end
+    enable_disable_breakpoints("Disable", args[1..-1])
+  end
+
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, '1'])
+  cmds = cmd.proc.commands
+  break_cmd = cmds['break']
+  puts "To be continued..."
+  # break_cmd.run(['break', cmdproc.frame.source_location[0].to_s])
+  # cmd.run([cmd.name, '1'])
+end

data/processor/command/eval.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+require_relative '../../app/util'
+
+class Trepan::Command::EvalCommand < Trepan::Command
+
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
+  NAME          = File.basename(__FILE__, '.rb')
+  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. If the command ends ? (via an alias) and no string is
+given we will the following translations occur:
+
+   {if|elsif|unless} expr [then]  => expr
+   {until|while} expr [do]        => expr
+   return expr                    => expr
+   case expr                      => expr
+   def fn(params)                 => [params]
+   var = expr                     => expr
+
+The above is done via regular expression. No fancy parsing is done, say,
+to look to see if expr is split across a line or whether var an assigment
+might have multiple variables on the left-hand side.
+
+Examples:
+
+#{NAME} 1+2  # 3
+#{NAME} @v
+#{NAME}      # Run current source-code line
+#{NAME}?     # but strips off leading 'if', 'while', ..
+             # from command 
+
+See also 'set autoeval'. The command helps one predict future execution.
+See 'set buffer trace' for showing what may have already been run.
+      HELP
+
+  ALIASES       = %w(eval? ev? ev)
+  CATEGORY      = 'data'
+  NEED_STACK    = true
+  SHORT_HELP    = 'Run code in the current context'
+  $VERBOSE      = old_verbose 
+
+  def complete(prefix)
+    if prefix.empty? 
+      if @proc.leading_str.start_with?('eval?')
+        Trepan::Util.extract_expression(@proc.current_source_text)
+      else
+        @proc.current_source_text 
+      end
+    else
+      prefix
+    end
+  end
+
+  def run(args)
+    if args.size == 1
+      text  = @proc.current_source_text.chomp
+      ## FIXME turn into a subroutine and use in complete.
+      if  '?' == args[0][-1..-1] 
+        text = Trepan::Util::extract_expression(text)
+        msg "eval: #{text}"
+      end
+    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])}"
+  arg_str = 'return "foo"'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  puts "eval? #{arg_str} is: #{cmd.run([cmd.name + '?'])}"
+end

data/processor/command/exit.rb

@@ -0,0 +1,66 @@
+# 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)
+    NAME         = File.basename(__FILE__, '.rb')
+    ALIASES      = %w(quit q q! quit! exit!)
+    HELP = <<-HELP
+#{NAME} [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, and confirm is not set off, 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" and "set confirm".'
+    HELP
+
+    CATEGORY     = 'support'
+    MAX_ARGS     = 2  # Need at most this many
+    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: Is this the best/most general way?
+    ##  @proc.finalize
+    ## @proc.dbgr.intf[-1].finalize
+
+    # 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
+  puts "before #{cmd.name}"
+  fork { cmd.run([cmd.name]) }
+  puts "before #{cmd.name} 10"
+  cmd.run([cmd.name, '10'])
+end

data/processor/command/finish.rb

@@ -0,0 +1,59 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+class Trepan::Command::FinishCommand < Trepan::Command
+
+  unless defined?(HELP)
+    ALIASES      = %w(fin)
+    CATEGORY     = 'running'
+    NAME         = File.basename(__FILE__, '.rb')
+    HELP         = <<-HELP
+#{NAME} [FRAME_NUM]
+
+Execute until selected stack frame returns.
+
+If no frame number is given, we run until the currently selected frame
+returns.  The currently selected frame starts out the most-recent
+frame or 0 if no frame positioning (e.g "up", "down" or "frame") has
+been performed. If a frame number is given we run until that frame
+returns.
+      HELP
+    NEED_RUNNING = true
+    SHORT_HELP   = 'Step into next method call or to next line'
+  end
+
+  # self.allow_in_post_mortem = false
+  # self.need_context         = true
+    
+  def run(args)
+    state = @proc.state
+    context = @proc.context
+    max_frame = context.stack_size - state.frame_pos
+    if args.size == 1
+      frame_pos = state.frame_pos
+    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 => 0,
+        :max_valiue => context.stack_size - state.frame_pos
+      }
+      count = @proc.get_an_int(count_str, count_opts)
+      return unless count
+      frame_pos = count - 1  
+    end
+    context.stop_frame = frame_pos
+    state.frame_pos = 0
+    state.proceed
+    @proc.leave_cmd_loop = true
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+end

data/processor/command/frame.rb

@@ -0,0 +1,97 @@
+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 complete(prefix)
+    @proc.frame_complete(prefix, nil)
+  end
+  
+  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.frame.stack_size
+    if stack_size == 0
+      errmsg('No frames recorded.')
+      return false
+    end
+    low, high = @proc.frame_low_high(nil)
+    opts={
+      :msg_on_error => 
+      "The '#{NAME}' command requires a frame number. Got: #{position_str}",
+      :min_value => low, :max_value => high
+    }
+    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
+
+  puts "To be continued..."
+  # def sep ; puts '=' * 40 end
+  # require 'ruby-debug'
+  # %w(0 1 -2).each {|count| 
+  #   cmd.run([cmd.name, count.to_s]); sep 
+  # }
+  # def foo(cmd, name)
+  #   cmd.proc.frame_setup(Debugger.current_context, nil)
+  #   %w(0 -1).each {|count| cmd.run([cmd.name, count.to_s]); sep }
+  # end
+  # foo(cmd, cmd.name)
+end