rbx-trepanning 0.2.0-universal-rubinius-2.0

data/processor/command/base/subsubmgr.rb

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+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)
+      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
+
+  # Return an Array of subcommands that can start with +arg+. If none
+  # found we just return +arg+.
+  def complete(prefix)
+    prior = self.prefix.join('').size
+    last_args = @subcmds.list.map{|str| str[prior..-1]}
+    Trepan::Complete.complete_token(last_args, prefix)
+  end
+
+  def complete_token_with_next(prefix)
+    Trepan::Complete.complete_token_with_next(@subcmds.subcmds, prefix,
+                                              self.prefix.join(''))
+  end
+
+  def run(args)
+    args = @parent.last_args if args.size == 0
+    if args.size < 3 || args.size == 3 && args[2] == '*'
+      summary_list(obj_const(self, :NAME), @subcmds)
+      return false
+    end
+
+    subcmd_prefix = obj_const(self, :PREFIX).join('')
+    # We were given: cmd subcmd ...
+    # Run that.
+    subcmd = @subcmds.lookup(subcmd_prefix + args[2])
+    if subcmd
+      subcmd.run(args[2..-1])
+    else
+      undefined_subcmd(obj_const(self, :PREFIX).join(' '), args[2])
+    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.debugger
+  # puts cmd.help(%w(help info registers p.*))
+end

data/processor/command/break.rb

@@ -0,0 +1,78 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+
+class Trepan::Command::BreakCommand < Trepan::Command
+
+  ALIASES      = %w(b brk)
+  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} @20   # set breakpoint VM Instruction Sequence offset 20
+   #{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, line, ip, condition, negate = 
+      @proc.breakpoint_position(arg_str, true)
+    if cm
+      event = temp ? 'tbrkpt' : 'brkpt'
+      opts={:event => event, :temp => temp, :condition => condition, 
+            :negate => negate}
+      bp = @proc.set_breakpoint_method(cm, line, ip, opts)
+      bp.set_temp! if temp
+      return bp
+    end
+  end
+  
+  def ask_deferred(klass_name, which, name, line)
+    if confirm('Would you like to defer this breakpoint to later?', false)
+      @proc.dbgr.add_deferred_breakpoint(klass_name, which, name, line)
+      msg 'Deferred breakpoint created.'
+    else
+      msg 'Not confirmed.'
+    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])
+  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/complete.rb

@@ -0,0 +1,39 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+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(d 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/condition.rb

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../breakpoint'
+require_relative '../../app/breakpoint'
+require_relative '../../app/condition'
+
+class Trepan::Command::ConditionCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} 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:
+   #{NAME} 5 x > 10  # Breakpoint 5 now has condition x > 10
+   #{NAME} 5         # Remove above condition
+
+See also "break", "enable" and "disable".
+    HELP
+
+    ALIASES       = %w(cond)
+    CATEGORY      = 'breakpoints'
+    MIN_ARGS      = 1
+    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_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  cmd.run([cmd.name, '1'])
+  cmdproc = dbgr.processor
+  cmds = cmdproc.commands
+  break_cmd = cmds['break']
+  break_cmd.run([break_cmd.name, __LINE__.to_s])
+  cmd.run([cmd.name, '1', 'x' '>' '10'])
+  cmd.run([cmd.name, '1'])
+end

data/processor/command/continue.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+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. Offset are numbers prefixed with an "@" otherwise
+the parameter is taken as a line number.
+
+Examples:
+   #{NAME}
+   #{NAME} 10    # continue to line 10
+   #{NAME} @20   # continue to VM Instruction Sequence offset 20
+   #{NAME} gcd   # continue to first instruction of method gcd
+   #{NAME} IRB.start @7 # continue to IRB.start offset 7
+
+See also 'step', 'next', 'finish', 'nexti' commands and "help location".
+    HELP
+
+    ALIASES      = %w(c cont)
+    CATEGORY     = 'running'
+    MAX_ARGS     = 2  # 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
+      cm, line, ip, condition, negate = 
+        @proc.breakpoint_position(@proc.cmd_argstr, false)
+      if cm
+        opts={:event => 'tbrkpt', :temp => true}
+        bp = @proc.set_breakpoint_method(cm, line, ip, opts)
+        bp.set_temp!
+      else
+        errmsg "Trouble setting temporary breakpoint"
+        return 
+      end
+    end
+    @proc.continue('continue')
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  p cmd.run([cmd.name])
+end

data/processor/command/delete.rb

@@ -0,0 +1,44 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+
+class Trepan::Command::DeleteBreakpontCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [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.
+    HELP
+
+    CATEGORY      = 'breakpoints'
+    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|
+      opts = {:msg_on_error => '%s must be a number' % num_str}
+      i = @proc.get_an_int(num_str, opts)
+      if i 
+        success = @proc.delete_breakpoint_by_number(num_str.to_i, false) if i
+        msg('Deleted breakpoint %d.' % i) if success
+      end
+    end
+  end
+end
+

data/processor/command/directory.rb

@@ -0,0 +1,51 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+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} ~/.rvm/src/rbx-head  # Adds an rvm-like directory to path
+   #{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] = '$rbx:$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,71 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../../app/util'
+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
+
+  Trepan::Util.suppress_warnings {
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [display] NUM1 [NUM2 ...]
+
+Disables the breakpoints or display given as a space separated list of
+numbers. 
+
+See also "enable" and "info break".
+  HELP
+
+    CATEGORY      = 'breakpoints'
+    SHORT_HELP    = 'Disable some breakpoints or displays'
+  }
+
+  def initialize(proc)
+    super
+    @enable_parm = false # true if enable 
+  end
+  
+  def run(args)
+    if args.size == 1
+      errmsg('No breakpoint or display number given.')
+      return
+    end
+  if args[1] == 'display'
+    args.shift
+    first = args.shift
+    args.each do |num_str|
+      i = @proc.get_an_int(num_str)
+      success = @proc.en_disable_display_by_number(i, @enable_parm) if i
+      msg("Display %s #{@name}d." % i) if success
+    end
+  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'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.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
+  cmd.run([cmd.name, '1'])
+end