rbx-trepanning 0.0.1-universal-rubinius

data/processor/command/base/submgr.rb

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd'
+require_relative '../../subcmd'
+require_relative '../../help'
+
+class Trepan::SubcommandMgr < Trepan::Command
+
+  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 :subcmds   # Array of instaniated Trepan::Subcommand objects
+  attr_reader   :name      # Name of command
+  attr_reader   :last_args # Last arguments seen
+
+  # Initialize show subcommands. Note: instance variable name
+  # has to be setcmds ('set' + 'cmds') for subcommand completion
+  # to work.
+  def initialize(proc)
+    @name    = obj_const(self, :NAME)
+    @subcmds = Trepan::Subcmd.new(self)
+    @proc    = proc
+    load_debugger_subcommands(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_subcommands(parent)
+
+    # Initialization
+    cmd_names     = []
+    subcmd_names  = []
+    cmd_dir = File.dirname(__FILE__)
+    subcmd_dir = File.join(cmd_dir, '..', name + '_subcmd')
+    files = Dir.glob(File.join(subcmd_dir, '*.rb'))
+    files.each do |rb| 
+      basename = File.basename(rb, '.rb')
+      if File.directory?(File.join(File.dirname(rb), basename + '_subcmd'))
+        subcmd_names << name.capitalize + basename.capitalize
+      else
+        cmd_names << name.capitalize + basename.capitalize
+      end
+      require rb
+    end if File.directory?(subcmd_dir)
+
+    subcommands = {}
+    cmd_names.each do |name|
+      next unless Trepan::Subcommand.constants.member?(name)
+      subcmd_class = "Trepan::Subcommand::#{name}.new(self)"
+      cmd = self.instance_eval(subcmd_class)
+      cmd_name = cmd.name
+      @subcmds.add(cmd)
+    end
+    subcmd_names.each do |name|
+      next unless Trepan::SubSubcommand.constants.member?(name)
+      subcmd_class = "Trepan::SubSubcommand::#{name}.new(self, parent)"
+      begin
+        cmd = self.instance_eval(subcmd_class)
+      rescue
+        puts "Subcmd #{name} is bad"
+      end
+      cmd_name = cmd.name
+      @subcmds.add(cmd)
+    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 <= 2
+      # "help cmd". Give the general help for the command part.
+      doc = my_const(:HELP)
+      if doc
+       return doc
+      else
+        errmsg('Sorry - author mess up. ' + 
+               'No help registered for command' + 
+               @name)
+        return nil
+      end
+    end
+
+    subcmd_name = args[2]
+
+    if '*' == subcmd_name
+      help_text = ["List of subcommands for command '%s':" % @name]
+      help_text << columnize_commands(@subcmds.list)
+      return help_text
+    end
+
+    # "help cmd subcmd". Give help specific for that subcommand.
+    cmd = @subcmds.lookup(subcmd_name, false)
+    if cmd
+      if cmd.respond_to?(:help)
+        return cmd.help(args)
+      else
+        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
+      end
+    else
+      matches = @subcmds.list.grep(/^#{subcmd_name}/).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
+        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)
+    @last_args = args
+    if args.size < 2 || args.size == 2 && args[-1] == '*'
+      summary_list(obj_const(self, :NAME), @subcmds)
+      return false
+    end
+
+    subcmd_prefix = args[1]
+    # We were given: cmd subcmd ...
+    # Run that.
+    subcmd = @subcmds.lookup(subcmd_prefix)
+    if subcmd
+      subcmd.run(args)
+    else
+      undefined_subcmd(@name, subcmd_prefix)
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  # cmds = dbgr.core.processor.commands
+  # cmd  = cmds['set']
+  # Trepan::SubcommandMgr.new(dbgr.core.processor)
+  # puts cmd.help(%w(help set))
+  # puts '=' * 40
+  # # require_relative '../../../lib/trepanning)
+  # # Trepan.debug(:set_restart => true)
+  # puts cmd.help(%w(help set *))
+  # puts '=' * 40
+  # puts cmd.help(%w(help set d.*))
+end

data/processor/command/base/subsubcmd.rb

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# A base class for debugger subcommands of subcommands.
+#
+# Note: don't end classname with Command (capital C as in SubCommand),
+# since main will think this a command name like QuitCommand 
+#                                                    ^   
+
+# Base Class for Trepan subcommands. We pull in some helper
+# functions for command from module cmdfns.
+
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd'
+require_relative 'subcmd'
+
+class Trepan
+
+  class SubSubcommand  < Subcommand
+    def initialize(cmd, parent, name)
+      @cmd    = cmd
+      @name   = name
+      @parent = parent
+      @proc   = parent.proc
+    end
+
+    def settings
+      @parent.settings
+    end
+
+    def string_in_show
+      help_constant_sym = if self.class.constants.member?('SHORT_HELP') 
+                            :SHORT_HELP 
+                          else :HELP
+                          end
+      str = my_const(help_constant_sym)
+      %w(Show Set).each do |word|
+        if 0 == str.index(word)
+          str = str[word.size+1 ..-1].capitalize
+          break
+        end
+      end
+      str
+    end
+
+    # Set a Boolean-valued debugger setting. 
+    def run_set_bool(args, default=true)
+      set_val = args.size < 2 ? 'on' : args[1]
+      setting = @name.gsub(/^(set|show)/,'')
+      begin
+        settings[setting.to_sym] = @proc.get_onoff(set_val)
+        run_show_bool(string_in_show)
+      rescue NameError, TypeError
+      end
+    end
+
+    def run_show_bool(what=nil)
+      setting = @name.gsub(/^(set|show)/,'')
+      val = show_onoff(settings[setting.to_sym])
+      what = setting unless what
+      msg('%s is %s.' % [what.chomp, val])
+    end
+
+  end
+
+  class SetBoolSubSubcommand < SubSubcommand
+    def run(args)
+      run_set_bool(args)
+    end
+
+    def save_command
+      val     = settings[subcmd_setting_key] ? 'on' : 'off'
+      ["#{subcmd_prefix_string} #{val}"]
+    end
+  end
+
+  class ShowBoolSubSubcommand < SubSubcommand
+    def run(args)
+      run_show_bool(string_in_show)
+    end
+  end
+
+  class ShowIntSubSubcommand < SubSubcommand
+    def run(args)
+      run_show_int
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  require_relative '../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, info_cmd = MockDebugger::setup('info')
+  testcmdMgr = Trepan::Subcmd.new(info_cmd)
+  cmd_name   = 'testing'
+  infox_cmd  = Trepan::SubSubcommand.new(info_cmd.proc,
+                                         info_cmd,
+                                         cmd_name)
+  infox_cmd.settings
+end

data/processor/command/base/subsubmgr.rb

@@ -0,0 +1,184 @@
+# -*- 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'
+
+require 'rubygems'; require 'require_relative'
+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
+
+  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,100 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::SetBreakpointCommand < Trepan::Command
+
+  ALIASES      = %w(b brk)
+  CATEGORY     = 'breakpoints'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP         = <<-HELP
+#{NAME} 
+#{NAME} [line number|offset]
+#{NAME} Class[.#]method[:line-or-offset]
+
+Sets a breakpoint. In the first form, a breakpoint is set at the
+current line you are stopped at. In the second form, you give a line
+number or an offset.  An offset is a number that is prefaced with 'O'
+or 'o' and represents a Rubinius VM PC offset. 
+
+The current method name is used for the start of the search. If a line
+number is given and the line number is not found in that method,
+enclosing scopes are searched for the line.
+
+The last form is the most explicit. Use '#' to specify an instance
+method and '.' to specify a class method. If a line number or offset
+is omitted, we use the first line of the method.
+
+Examples:
+
+  #{NAME}     # set breakpoint at the current line
+  #{NAME} 5   # set breakpoint on line 5
+  #{NAME} O5  # set breakpoint at offset 5
+  #{NAME} o5  # same as above
+  #{NAME} Array#pop::3 # Set break at instance method 'pop' in Array, line 3
+  #{NAME} Trepan.start:3  # Set break in class method 'start' of Trepan, line 3
+  #{NAME} Trepan.start:o3 # Same as above but at offset 3, not line 3.
+  #{NAME} Trepan.start    # Set break in class method 'start' of Trepan
+
+See also 'tbreak', 'info breakpoint', and 'delete'. 
+      HELP
+  SHORT_HELP   = 'Set a breakpoint at a point in a method'
+
+  def run(args, temp=false)
+    arg_str = args[1..-1].join(' ')
+
+    describe, klass_name, which, name, line, ip = 
+      @proc.breakpoint_position(args[1..-1])
+    event = temp ? 'tbrkpt' : 'brkpt'
+    opts={:event => event, :temp => temp}      
+    if name.kind_of?(Rubinius::CompiledMethod)
+      bp = @proc.set_breakpoint_method(describe, name, line, ip, opts)
+    else
+      return unless klass_name
+    
+      begin
+        klass = @proc.debug_eval(klass_name, settings[:maxstring])
+      rescue NameError
+        errmsg "Unable to find class/module: #{klass_name}"
+        ask_deferred klass_name, which, name, line
+        return
+      end
+      
+      begin
+        if which == "#"
+          method = klass.instance_method(name)
+        else
+          method = klass.method(name)
+        end
+      rescue NameError
+        errmsg "Unable to find method '#{name}' in #{klass}"
+        ask_deferred klass_name, which, name, line
+        return
+      end
+
+      bp = @proc.set_breakpoint_method(arg_str.strip, method, line, ip, opts)
+    end
+      
+    bp.set_temp! if temp
+    return bp
+  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
+  cmd.run([cmd.name])
+  # require 'trepanning'
+  # Trepan.start(:set_restart => true)
+  cmd.run([cmd.name, __LINE__.to_s])
+  cmd.run([cmd.name, 'foo'])
+end

data/processor/command/continue.rb

@@ -0,0 +1,82 @@
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../stepping'
+
+class Trepan::Command::ContinueCommand < Trepan::Command
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP         = <<-HELP
+#{NAME} [breakpoint position]
+
+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', and 'nexti' commands.
+      HELP
+  ALIASES      = %w(c cont)
+  CATEGORY     = 'running'
+  MAX_ARGS     = 1
+  NEED_RUNNING = true
+  SHORT_HELP   = 'Continue execution of the debugged program'
+
+  # This is the method that runs the command
+  def run(args)
+
+    ## FIXME: DRY this code, tbreak and break.
+    unless args.size == 1
+      describe, klass_name, which, name, line, ip = 
+        @proc.breakpoint_position(args[1..-1])
+      unless describe
+        errmsg "Can't parse temporary breakpoint location"
+        return 
+      end
+      if name.kind_of?(Rubinius::CompiledMethod)
+        bp = @proc.set_breakpoint_method(describe, name, line, ip,
+                                         {:temp=>true, :event =>'tbrkpt'})
+        unless bp
+          errmsg "Trouble setting temporary breakpoint"
+          return 
+        end
+      else
+        return unless klass_name
+        begin
+          klass = @proc.debug_eval(klass_name, settings[:maxstring])
+        rescue NameError
+          errmsg "Unable to find class/module: #{klass_name}"
+          return
+        end
+        
+        begin
+          if which == "#"
+            method = klass.instance_method(name)
+          else
+            method = klass.method(name)
+          end
+        rescue NameError
+          errmsg "Unable to find method '#{name}' in #{klass}"
+          return
+        end
+        arg_str = args[1..-1].join(' ')
+        bp = @proc.set_breakpoint_method(arg_str.strip, method, line, nil,
+                                         {:temp=>true, :event =>'tbrkpt'})
+        unless bp
+          errmsg "Trouble setting temporary breakpoint"
+          return 
+        end
+      end
+    end
+    @proc.continue('continue')
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+end

data/processor/command/delete.rb

@@ -0,0 +1,30 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::DeleteBreakpontCommand < Trepan::Command
+  CATEGORY     = 'breakpoints'
+  NAME         = File.basename(__FILE__, '.rb')
+  SHORT_HELP   = 'Delete a breakpoint'
+  HELP         = <<-HELP
+Specify the breakpoint by number, use 'info break' to see the numbers
+      HELP
+
+  def run(args)
+    if args.size != 2
+      errmsg 'Please specify which breakpoint by number'
+      return
+    end
+    
+    begin
+      i = Integer(args[1])
+    rescue ArgumentError
+      errmsg "'#{args}' is not a number"
+      return
+    end
+    
+    if @proc.delete_breakpoint_by_number(i)
+      msg('Deleted breakpoint %d.' % i)
+    end
+  end
+end
+