trepanning 0.0.4

data/processor/command/base/subsubmgr.rb

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'subcmd'
+require_relative '../../subcmd'
+require_relative '../../help'
+
+class Trepan::SubSubcommandMgr < Trepan::Subcommand
+
+  include Trepan::Help
+
+  unless defined?(CATEGORY)
+    CATEGORY      = 'status'
+    MIN_ARGS      = 0
+    MAX_ARGS      = nil
+    NAME          = '?' # FIXME: Need to define this, but should 
+                        # pick this up from class/file name.
+    NEED_STACK    = false
+  end
+
+  attr_accessor :pname
+  attr_accessor :subcmds  # Array of instantiated Trepan::Subcommand objects
+
+  # Initialize show subcommands. Note: instance variable name
+  # has to be setcmds ('set' + 'cmds') for subcommand completion
+  # to work.
+  # FIXME: do we need proc still? 
+  def initialize(proc, parent)
+    name     = obj_const(self, :NAME)
+    @name    = name.to_sym
+    @subcmds = Trepan::Subcmd.new(self)
+    @parent  = parent
+    @pname   = parent.name
+    @proc    = parent.proc
+
+    # Set class constant SHORT_HELP to be the first line of HELP
+    # unless it has been defined in the class already.
+    # The below was the simplest way I could find to do this since
+    # we are the super class but want to set the subclass's constant.
+    # defined? didn't seem to work here.
+    c = self.class.constants
+    self.class.const_set('SHORT_HELP', 
+                         self.class.const_get('HELP')) if
+      c.member?(:HELP) and !c.member?(:SHORT_HELP)
+    
+    load_debugger_subsubcommands(name, self)
+  end
+
+  # Create an instance of each of the debugger subcommands. Commands
+  # are found by importing files in the directory 'name' + 'sub'. Some
+  # files are excluded via an array set in initialize.  For each of
+  # the remaining files, we import them and scan for class names
+  # inside those files and for each class name, we will create an
+  # instance of that class. The set of TrepanCommand class instances
+  # form set of possible debugger commands.
+  def load_debugger_subsubcommands(name, obj)
+
+    # Initialization
+    cmd_names     = []
+    cmd_dir = File.dirname(__FILE__)
+    subcmd_dir = File.join(cmd_dir, '..', @pname + '_subcmd', name + '_subcmd')
+    files = Dir.glob(File.join(subcmd_dir, '*.rb'))
+    files.each do |rb| 
+      cmd_names << name.capitalize + File.basename(rb, '.rb').capitalize
+      require rb
+    end if File.directory?(subcmd_dir)
+
+    subcommands = {}
+    cmd_names.each do |subname|
+      cmd_name = "#{pname}#{subname.downcase}"
+      subclass_name = "#{@pname.capitalize}#{subname}"
+      next unless 
+        Trepan::SubSubcommand.constants.member?(subclass_name.to_sym)
+      cmd = self.instance_eval("Trepan::SubSubcommand::" + subclass_name + 
+                               ".new(self, @parent, '#{cmd_name}')")
+      @subcmds.add(cmd, cmd_name)
+    end
+  end
+
+  # Give help for a command which has subcommands. This can be
+  # called in several ways:
+  #        help cmd
+  #        help cmd subcmd
+  #        help cmd commands
+  #
+  #  Our shtick is to give help for the overall command only if 
+  #  subcommand or 'commands' is not given. If a subcommand is given and
+  #  found, then specific help for that is given. If 'commands' is given
+  #  we will list the all the subcommands.
+  def help(args)
+    if args.size <= 3
+      # "help cmd". Give the general help for the command part.
+      doc = self.class.const_get(:HELP)
+      if doc
+       return doc
+      else
+        errmsg('Sorry - author mess up. ' + 
+               'No help registered for command' + 
+               @name)
+        return nil
+      end
+    end
+
+    prefix      = my_const(:PREFIX)
+    subcmd_name = args[prefix.size+1]
+    prefix_str  = prefix.join(' ')
+
+    if '*' == subcmd_name
+      help_text  = ["List of subcommands for '%s':" % prefix_str]
+      cmd_names = @subcmds.list.map{|c| c[prefix_str.size-1..-1]}
+      help_text << columnize_commands(cmd_names)
+      return help_text
+    end
+
+    # "help cmd subcmd". Give help specific for that subcommand if
+    # the command matches uniquely, or show a list of matching 
+    # subcommands
+    keyprefix_str  = prefix.join('')
+    key_str        = keyprefix_str + subcmd_name
+    cmd = @subcmds.lookup(key_str, false)
+    if cmd
+      doc = obj_const(cmd, :HELP)
+      if doc
+        return doc
+      else
+        errmsg('Sorry - author mess up. ' + 
+               'No help registered for subcommand: ' + 
+               subcmd_name + ', of command: ' + 
+               @name)
+        return nil
+      end
+    else
+      matches = @subcmds.list.grep(/^#{key_str}/).sort
+      if matches.empty?
+        errmsg("No #{name} subcommands found matching /^#{subcmd_name}/. Try \"help #{@name}\".")
+        return nil
+      elsif 1 == matches.size
+        args[-1] = matches[0].to_s[keyprefix_str.size..-1]
+        help(args)
+      else
+        help_text = ["Subcommands of \"#{@name}\" matching /^#{subcmd_name}/:"]
+        help_text << columnize_commands(matches.sort)
+        return help_text
+      end
+    end
+  end
+
+  def run(args)
+    args = @parent.last_args if args.size == 0
+    if args.size < 3 || args.size == 3 && args[-1] == '*'
+      summary_list(obj_const(self, :NAME), @subcmds)
+      return false
+    end
+
+    subcmd_prefix = args[0..2].join('')
+    # We were given: cmd subcmd ...
+    # Run that.
+    subcmd = @subcmds.lookup(subcmd_prefix)
+    if subcmd
+      subcmd.run(args[2..-1])
+    else
+      undefined_subcmd(obj_const(self, :PREFIX).join(' '), args[-1])
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  cmds = dbgr.core.processor.commands
+  cmd  = cmds['info']
+  Trepan::SubSubcommandMgr.new(dbgr.core.processor, cmd)
+  puts cmd.help(%w(help info registers))
+  puts '=' * 40
+  puts cmd.help(%w(help info registers *))
+  puts '=' * 40
+  # FIXME
+  # require_relative '../../lib/trepanning'
+  # Trepan.debug(:set_restart => true)
+  # puts cmd.help(%w(help info registers p.*))
+end

data/processor/command/break.rb

@@ -0,0 +1,85 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../breakpoint'
+require_relative '../../app/breakpoint'
+class Trepan::Command::BreakCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+'break [line number|offset]
+
+With a line number argument, set a break there in the current
+instruction sequence.  With an offset (a number prefaced with an "O")
+set a breakpoint at that instruction offset.
+
+Examples:
+   break
+   break 10    # set breakpoint on line 10
+   break o20   # set breakpoint VM Instruction Sequence offset 20
+'
+
+    ALIASES      = %w(b)
+    CATEGORY     = 'breakpoints'
+    NAME         = File.basename(__FILE__, '.rb')
+    SHORT_HELP  = 'Set a breakpoint'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    # FIXME: handle more conditions
+    # a line number
+    if args.size == 1
+      # usage is "break"  which means break right here
+      # FIXME: should handle condition
+      bp = @proc.breakpoint_offset(@proc.frame.pc_offset, 
+                                   @proc.frame.iseq) 
+    else
+      position, iseq, use_offset, condition, name = 
+        @proc.breakpoint_position(args[1..-1])
+      return false unless position && iseq
+      bp = 
+        if use_offset
+          @proc.breakpoint_offset(position, iseq)
+        else
+          @proc.breakpoint_line(position, iseq)
+        end
+    end
+    if bp
+      bp.condition = condition
+
+      mess = "Breakpoint %d set at " % bp.id
+
+      line_loc = "line %s in %s" % 
+        [bp.source_location.join(', '),
+         @proc.canonic_container(bp.iseq.source_container).join(' ')]
+
+      vm_loc = "VM offset %d of instruction sequence \"%s\"" % 
+        [bp.offset, bp.iseq.name]
+      
+      loc, other_loc =
+        if 'line' == bp.type
+          [line_loc, vm_loc]
+        else # 'offset' == bp.type
+          [vm_loc, line_loc]
+        end
+      msg(mess + loc + ",\n\t" + other_loc + ".")
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  cmd.run([name])
+  cmd.run([name, __LINE__.to_s])
+  require 'thread_frame'
+  tf = RubyVM::ThreadFrame.current
+  pc_offset = tf.pc_offset
+  cmd.run([name, "O#{pc_offset}"])
+  def foo
+    5 
+  end
+  cmd.run([name, 'foo', (__LINE__-2).to_s])
+  cmd.run([name, 'foo'])
+end

data/processor/command/condition.rb

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../breakpoint'
+require_relative '../../app/breakpoint'
+require_relative '../../app/condition'
+
+class Trepan::Command::ConditionCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+'condition BP_NUMBER CONDITION
+
+BP_NUMBER is a breakpoint number.  CONDITION is an expression which
+must evaluate to True before the breakpoint is honored.  If CONDITION
+is absent, any existing condition is removed; i.e., the breakpoint is
+made unconditional.
+
+Examples:
+   condition 5 x > 10  # Breakpoint 5 now has condition x > 10
+   condition 5         # Remove above condition
+'
+
+    ALIASES       = %w(cond)
+    CATEGORY      = 'breakpoints'
+    MIN_ARGS      = 1
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = false
+    SHORT_HELP    = 'Specify breakpoint number N to break only if COND is true'
+  end
+
+  include Trepan::Condition
+
+  def run(args)
+    bpnum = @proc.get_an_int(args[1])
+    bp = @proc.breakpoint_find(bpnum)
+    return unless bp
+    
+    if args.size > 2
+      condition = args[2..-1].join(' ')
+      return unless valid_condition?(condition)
+    else
+      condition = 'true'
+      msg('Breakpoint %d is now unconditional.' % bp.id)
+    end
+    bp.condition = condition
+  end
+end
+
+if __FILE__ == $0
+  require 'thread_frame'
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+  
+  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', 'x' '>' '10'])
+  cmd.run([name, '1'])
+end

data/processor/command/continue.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../running'
+require_relative '../../app/breakpoint' # FIXME: possibly temporary
+class Trepan::Command::ContinueCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+'continue [offset|line number]
+
+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. Offset are numbers preficed with an "O" otherwise
+the parameter is taken as a line number.
+
+Examples:
+   continue
+   continue 10    # continue to line 10
+   continue o20   # continue to VM Instruction Sequence offset 20
+'
+
+    ALIASES      = %w(c)
+    CATEGORY     = 'running'
+    MAX_ARGS     = 1  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_RUNNING = true
+    SHORT_HELP   = 'Continue execution of debugged program'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    if args.size == 1
+      # Form is: "continue"
+      @proc.continue
+    else
+      # FIXME: handle more general condition parameter rather than just
+      # a line number
+      position, iseq, use_offset, condition = 
+        @proc.breakpoint_position(args[1..-1])
+      return false unless position && iseq
+      bp = 
+        if use_offset
+          @proc.breakpoint_offset(position, iseq, true)
+        else
+          @proc.breakpoint_line(position, iseq, true)
+        end
+      return unless bp
+      @proc.continue
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  p cmd.run([name])
+end

data/processor/command/debug.rb

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'thread_frame'
+require_relative 'base/cmd'
+
+class Trepan::Command::DebugCommand < Trepan::Command
+  unless defined?(HELP)
+    HELP =
+"debug RUBY-CODE
+
+Enter the debugger recursively on RUBY-CODE."
+
+    CATEGORY      = 'data'
+    MIN_ARGS      = 1
+    MAX_ARG       = nil
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = false
+    SHORT_HELP    = 'recursive debugging of an expression'
+
+    EXTRA_DEBUG_SETUP_CALLS = 4
+  end
+
+  def run(args)
+    th         = Thread.current
+    frame      = @proc.frame  # gets messed up in recursive call
+    arg_str    = args[1..-1].join(' ')
+    hidelevels = @proc.hidelevels[th]
+
+    stack_diff = RubyVM::ThreadFrame.current.stack_size - frame.stack_size 
+
+    # Ignore tracing in support routines:
+    tf = @proc.dbgr.trace_filter 
+    [self.method(:run), @proc.method(:debug_eval),
+     @proc.method(:debug_eval_with_exception),
+     @proc.method(:get_binding_and_filename),
+     @proc.method(:fake_eval_filename)].each do |m|
+      tf << m unless tf.member?(m)
+    end
+
+    @proc.hidelevels[th] += stack_diff + EXTRA_DEBUG_SETUP_CALLS
+
+    # Values we need to save before munging them
+    old_tracing            = th.tracing
+    old_exec_event_tracing = th.exec_event_tracing
+    old_mutex              = @proc.core.mutex 
+    old_next_level         = @proc.next_level
+    old_step_count         = @proc.core.step_count
+
+    msg 'ENTERING NESTED DEBUGGER'
+
+    # Things we need to do to allow entering the debugger again
+    @proc.debug_nest      += 1
+    @proc.core.mutex       = Mutex.new
+    th.tracing             = false
+    th.exec_event_tracing  = false
+    @proc.core.step_count  = 0
+    @proc.next_level       = 32000
+
+    RubyVM::ThreadFrame.current.trace_off = false
+    retval = @proc.debug_eval(arg_str)
+
+    # Restore munged values
+    th.exec_event_tracing  = old_exec_event_tracing
+    th.tracing             = old_tracing
+    @proc.core.mutex       = old_mutex
+    @proc.frame_setup(frame)
+    @proc.hidelevels[th]   = hidelevels
+    @proc.core.step_count  = old_step_count
+    @proc.next_level       = old_next_level
+    @proc.print_location
+    @proc.debug_nest      -= 1
+    msg 'LEAVING NESTED DEBUGGER'
+    msg "R=> #{retval.inspect}"
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  name = File.basename(__FILE__, '.rb')
+  cmd.proc.hidelevels[Thread.current] = 0
+  cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+  cmd.run([name, 'x = 1; y = 2'])
+end

data/processor/command/delete.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+require_relative '../breakpoint'
+require_relative '../../app/breakpoint'
+class Trepan::Command::DeleteCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+      'delete [bpnumber [bpnumber...]]  - Delete some breakpoints.
+
+Arguments are breakpoint numbers with spaces in between.  To delete
+all breakpoints, give no argument.  those breakpoints.  Without
+argument, clear all breaks (but first ask confirmation).
+    
+See also the "clear" command which clears breakpoints by line/file
+number.
+'
+
+    CATEGORY      = 'breakpoints'
+    NAME          = File.basename(__FILE__, '.rb')
+    SHORT_HELP    = 'Delete some breakpoints'
+  end
+  
+  def run(args)
+    if args.size == 1
+      if confirm('Delete all breakpoints?', false)
+        @proc.brkpts.reset
+        return
+      end
+    end
+    first = args.shift
+    args.each do |num_str|
+      i = @proc.get_an_int(num_str)
+      success = @proc.delete_breakpoint_by_number(num_str.to_i, false) if i
+      msg('Deleted breakpoint %d.' % i) if success
+    end
+  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 = dbgr.core.processor.commands
+  break_cmd = cmds['break']
+  break_cmd.run(['break', cmdproc.frame.source_location[0].to_s])
+  # require_relative '../../lib/trepanning'
+  # Trepan.debug(:set_restart => true)
+  cmd.run([name, '1'])
+end

data/processor/command/directory.rb

@@ -0,0 +1,43 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+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'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  cmd.run([name])
+  cmd.run([name, '/tmp'])
+end

data/processor/command/disable.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+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
+  HELP = 
+      'disable [display] bpnumber [bpnumber ...]
+    
+Disables the breakpoints given as a space separated list of breakpoint
+numbers. See also "info break" to get a list.
+'
+
+  CATEGORY      = 'breakpoints'
+  NAME          = File.basename(__FILE__, '.rb')
+  SHORT_HELP    = 'Disable some breakpoints'
+
+  $VERBOSE      = old_verbose 
+
+  def initialize(proc)
+    super
+    @enable_parm = false # true if enable 
+  end
+  
+  def run(args)
+    if args.size == 1
+      errmsg('No breakpoint number given.')
+      return
+    end
+#   if args[1] == 'display'
+#     display_enable(args[2:], 0)
+#   end
+    first = args.shift
+    args.each do |num_str|
+      i = @proc.get_an_int(num_str)
+      success = @proc.en_disable_breakpoint_by_number(i, @enable_parm) if i
+      msg("Breakpoint %s #{@name}d." % i) if success
+    end
+  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])
+  # require_relative '../../lib/trepanning'
+  # Trepan.debug(:set_restart => true)
+  cmd.run([name, '1'])
+end