rb8-trepanning 0.1.3

data/processor/command/break.rb

@@ -0,0 +1,114 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::BreakCommand < Trepan::Command
+
+  ALIASES      = %w(b)
+  CATEGORY     = 'breakpoints'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP         = <<-HELP
+#{NAME} LOCATION [ {if|unless} CONDITION ]
+
+Set a breakpoint. In the second form where CONDITIOn is given, the
+condition is evaluated in the context of the position. We stop only If
+CONDITION evalutes to non-false/nil and the "if" form used, or it is
+false and the "unless" form used.\
+
+Examples:
+   #{NAME}
+   #{NAME} 10               # set breakpoint on line 10
+   #{NAME} 10 if 1 == a     # like above but only if a is equal to 1
+   #{NAME} 10 unless 1 == a # like above but only if a is equal to 1
+   #{NAME} me.rb:10
+   #{NAME} Kernel.pp # Set a breakpoint at the beginning of Kernel.pp
+
+See also condition, continue and "help location".
+      HELP
+  SHORT_HELP   = 'Set a breakpoint at a point in a method'
+
+  # This method runs the command
+  def run(args, temp=false)
+
+    arg_str = args.size == 1 ? @proc.frame.line.to_s : @proc.cmd_argstr
+    cm, file, line, position_type, expr, negate = 
+      @proc.breakpoint_position(arg_str, true)
+    if file.nil?
+      unless @proc.context
+        errmsg 'We are not in a state that has an associated file.'
+        return 
+      end
+      file = @proc.frame.file
+      if line.nil? 
+        # Set breakpoint at current line
+        line = @proc.frame.line
+      end
+    end
+
+    if line
+      if LineCache.cache(file, settings[:reload_source_on_change])
+        last_line = LineCache.size(file)
+        if line > last_line
+          errmsg("There are only %d lines in file \"%s\"." % [last_line, 
+                 @proc.canonic_file(file)]) 
+          return
+        end
+        unless LineCache.trace_line_numbers(file).member?(line)
+          errmsg('Line %d is not a stopping point in file "%s".' % 
+                 [line, @proc.canonic_file(file)])
+          return
+        end
+      else
+        errmsg('No source file named %s' % @proc.canonic_file(file))
+        return unless confirm('Set breakpoint anyway?', false)
+      end
+      
+      unless @proc.context
+        errmsg 'We are not in a state we can add breakpoints.'
+        return 
+      end
+
+      expr = "!(#{expr})" if negate
+      if temp
+        @proc.state.context.set_breakpoint(file, line, expr)
+        msg("Temporary breakpoint set at file %s, line %d" % [file, line])
+      else        
+        b = Debugger.add_breakpoint file, line, expr
+        msg("Breakpoint %d file %s, line %d" % 
+            [b.id, @proc.canonic_file(file), line])
+      end
+    #   unless syntax_valid?(expr)
+    #     errmsg("Expression \"#{expr}\" syntactically incorrect; breakpoint disabled.\n")
+    #     b.enabled = false
+    #   end
+    # else
+    #   method = line.intern.id2name
+    #   b = Debugger.add_breakpoint class_name, method, expr
+    #   print "Breakpoint %d at %s::%s\n", b.id, class_name, method.to_s
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  # require_relative '../../lib/trepanning'
+  def run_cmd(cmd, args) 
+    cmd.proc.instance_variable_set('@cmd_argstr', args[1..-1].join(' '))
+    cmd.run(args)
+  end
+
+  run_cmd(cmd, [cmd.name, 2])
+  # run_cmd(cmd, [cmd.name])
+  # run_cmd(cmd, [cmd.name, __LINE__.to_s])
+
+  # def foo
+  #   5 
+  # end
+  # run_cmd(cmd, [cmd.name, 'foo', (__LINE__-2).to_s])
+  # run_cmd(cmd, [cmd.name, 'foo'])
+  # run_cmd(cmd, [cmd.name, "MockDebugger::setup"])
+  # require 'irb'
+  # run_cmd(cmd, [cmd.name, "IRB.start"])
+  # run_cmd(cmd, [cmd.name, 'foo93'])
+end

data/processor/command/catch.rb

@@ -0,0 +1,71 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../stepping'
+
+class Trepan::Command::CatchCommand < Trepan::Command
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} EXCEPTION-NAME
+#{NAME} EXCEPTION-NAME off
+#{NAME} 
+#{NAME} off
+
+The first form intercepts EXCEPTION-NAME when.
+The second form removes the debugger handling for EXCEPTION-NAME.
+The third form is the the same as "info catch".  
+The last form deletes all debugger catchpoints.
+
+Examples:
+   #{NAME}       # same as "info catch"
+   #{NAME} ZeroDivisionError  # Handle dividing by zero exceptions.
+   #{NAME} off   # Turns off all debugger exception handling
+
+See also "info catch" and post-mortem debugging.
+    HELP
+
+    ALIASES      = %w()
+    CATEGORY     = 'running'
+    MAX_ARGS     = 2  # Need at most this many
+    NEED_RUNNING = true
+    SHORT_HELP   = 'Catch exceptions'
+  end
+
+  # This is the method that runs the command
+  def run(args)
+    case args.size
+    when 1
+      @proc.commands['info'].run(%W(info catch))
+    when 2
+      exception = args[1]
+      if args[1] == 'off'
+        Debugger.catchpoints.clear if 
+          confirm('Delete all catchpoints?', false)
+      else
+        unless @proc.debug_eval_no_errmsg("#{exception}.is_a?(Class)")
+          msg "Warning #{exception} is not known to be a Class"
+        end
+        Debugger.add_catchpoint(exception)
+        msg "Catch exception %s." % exception
+      end
+    when 3
+      exception = args[1]
+      if Debugger.catchpoints.member?(exception)
+        Debugger.catchpoints.delete(exception)
+        msg "Catch for exception %s removed." % exception
+      else
+        errmsg "Catch for exception %s not found." % exception
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, 'ZeroDivisionError'])
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, 'ZeroDivisionError', 'off'])
+end

data/processor/command/complete.rb

@@ -0,0 +1,39 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../load_cmds'
+class Trepan::Command::CompleteCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME          = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} COMMAND-PREFIX
+
+List the completions for the rest of the line as a command.
+    HELP
+    CATEGORY      = 'support'
+    NEED_STACK    = false
+    SHORT_HELP    = 'List the completions for the rest of the line as a command'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    last_arg = @proc.cmd_argstr.end_with?(' ') ? '' : args[-1]
+    @proc.complete(@proc.cmd_argstr, last_arg).each do |match|
+      msg match
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  %w(k b bt).each do |prefix|
+    cmd.proc.instance_variable_set('@cmd_argstr', prefix)
+    cmd.run [cmd.name, prefix]
+    puts '=' * 40
+  end
+  cmd.run %w(#{cmd.name} fdafsasfda)
+  puts '=' * 40
+end

data/processor/command/continue.rb

@@ -0,0 +1,57 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../stepping'
+
+class Trepan::Command::ContinueCommand < Trepan::Command
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [LOCATION]
+
+Leave the debugger loop and continue execution. Subsequent entry to
+the debugger however may occur via breakpoints or explicit calls, or
+exceptions.
+
+If a parameter is given, a temporary breakpoint is set at that position
+before continuing. 
+
+Examples:
+   #{NAME}
+   #{NAME} 10    # continue to line 10
+
+See also 'step', 'next', 'finish', 'nexti' commands and "help location".
+    HELP
+
+    ALIASES      = %w(c cont)
+    CATEGORY     = 'running'
+    MAX_ARGS     = 1  # Need at most this many
+    NEED_RUNNING = true
+    SHORT_HELP   = 'Continue execution of the debugged program'
+  end
+
+  # This is the method that runs the command
+  def run(args)
+
+    ## FIXME: DRY this code, tbreak and break.
+    unless args.size == 1
+      filename = @proc.frame.file
+      line_number = @proc.get_an_int(args[1])
+      return unless line_number
+      unless LineCache.trace_line_numbers(filename).member?(line_number)
+        errmsg("Line %d is not a stopping point in file \"%s\".\n" %
+               [line_number, filename])
+        return
+      end
+      @proc.state.context.set_breakpoint(filename, line_number)
+    end
+    @proc.continue
+    @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/directory.rb

@@ -0,0 +1,50 @@
+# 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
+#{NAME} [DIR]
+
+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.
+
+Examples:
+   #{NAME} # reset to $cdir:$cwd
+      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
+      path = File.expand_path(args[1])
+      settings[:directory] = "#{path}:#{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: #{settings[:directory]}"
+      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/disable.rb

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+# require_relative '../breakpoint'
+# require_relative '../../app/breakpoint'
+
+# disable breakpoint command. The difference however is that the
+# parameter to @proc.en_disable_breakpoint_by_number is different (set
+# as ENABLE_PARM below).
+#
+# NOTE: The enable command  subclasses this, so beware when changing! 
+class Trepan::Command::DisableCommand < Trepan::Command
+
+  # Silence already initialized constant .. warnings
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
+  NAME = File.basename(__FILE__, '.rb')
+  HELP = <<-HELP
+#{NAME} bpnumber [bpnumber ...]
+    
+Disables the breakpoints given as a space separated list of breakpoint
+numbers. See also "info break" to get a list.
+  HELP
+
+  CATEGORY      = 'breakpoints'
+  SHORT_HELP    = 'Disable some breakpoints'
+
+  $VERBOSE      = old_verbose 
+
+  def initialize(proc)
+    super
+    @enable_parm = false # true if enable 
+  end
+  
+  def enable_disable_breakpoints(is_enable, args)
+    breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+    largest = breakpoints.inject(0) do |largest, b| 
+      largest = b.id if b.id > largest
+    end
+    if 0 == largest
+      errmsg "No breakpoints have been set.\n"
+      return
+    end
+    args.each do |num_str|
+      pos = @proc.get_an_int(num_str)
+      return nil unless pos
+      breakpoints.each do |b|
+        if b.id == pos 
+          enabled = ("Enable" == is_enable)
+          if enabled
+            unless syntax_valid?(b.expr)
+              errmsg("Expression \"#{b.expr}\" syntactically incorrect; breakpoint remains disabled.\n")
+              break
+            end
+          end
+          b.enabled = ("Enable" == is_enable)
+          break
+        end
+      end
+    end
+  end
+
+  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
+  puts "To be continued..."
+# 
+#  break_cmd = cmds['break']
+#  break_cmd.run(['break', cmdproc.frame.line])
+#  cmd.run([cmd.name, '1'])
+end

data/processor/command/display.rb

@@ -0,0 +1,78 @@
+# -*- 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
+  run_cmd(cmd, [cmd.name, 'e'])
+end