rbx-trepanning 0.0.5-universal-rubinius-1.2.1

data/processor/command/alias.rb

@@ -0,0 +1,55 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+class Trepan::Command::AliasCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} ALIAS COMMAND
+
+Add an alias for a COMMAND
+
+See also 'unalias'.
+    HELP
+
+    CATEGORY      = 'support'
+    MAX_ARGS      = 2  # Need at most this many
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = true
+    SHORT_HELP    = 'Add an alias for a debugger command'
+  end
+  
+  # Run command. 
+  def run(args)
+    if args.size == 1
+      @proc.commands['show'].run(%w(show alias))
+    elsif args.size == 2
+      @proc.commands['show'].run(%W(show alias #{args[1]}))
+    else
+      junk, al, command = args
+      old_command = @proc.aliases[al]
+      if @proc.commands.member?(command)
+        @proc.aliases[al] = command
+        if old_command
+          msg("Alias '#{al}' for command '#{command}' replaced old " + 
+              "alias for '#{old_command}'.")
+        else
+          msg "New alias '#{al}' for command '#{command}' created."
+        end
+      else
+        errmsg "You must alias to a command name, and '#{command}' isn't one."
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run %W(#{cmd.name} yy foo)
+  cmd.run [cmd.name]
+  cmd.run %W(cmd.name yy next)
+end

data/processor/command/backtrace.rb

@@ -0,0 +1,76 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::BacktraceCommand < Trepan::Command
+  ALIASES      = %w(bt where)
+  CATEGORY     = 'stack'
+  MAX_ARGS     = 2 # Need at most this many
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP = <<-HELP
+#{NAME} [full] [COUNT]
+
+Print a backtrace of all stack frames, or innermost COUNT frames.  Use
+of the 'full' qualifier also prints the values of the local variables.
+
+Passing "full" will also show the values of all locals variables in
+each frame.
+
+Normally outer frames which constitute debugger overhead are hidden
+from view. However if a count is given and it runs into those hidden
+frames, they will be shown.
+
+Examples:
+
+#{NAME}  
+#{NAME} full   # show 
+#{NAME} 2 
+#{NAME} 3 full  
+#{NAME} full 3 # same as above
+#{NAME} 1000   # probably will show any outer hidden frames
+
+See also 'set hidelevel'.
+      HELP
+  NEED_STACK   = true
+  SHORT_HELP   =  'Show the current call stack'
+  
+  def run(args)
+    verbose_ary, count_ary = args[1..-1].partition {|item| item =~ /full/i}
+    verbose = !verbose_ary.empty?
+
+    if count_ary.size > 1
+      errmsg "Expecting only at most one parameter other than 'full'"
+      return
+    end
+    
+    if 1 == count_ary.size
+      begin
+        count = Integer(count_ary[0])
+      rescue
+        errmsg "Expecting count to be an integer; got #{count_ary[0]}"
+        return
+      end
+    elsif 0 == count_ary.size
+      count = proc.stack_size
+    else
+      errmsg "Wrong number of parameters. Expecting at most 2."
+      return
+    end
+    
+    @proc.dbgr.each_frame(@proc.top_frame) do |frame|
+      if count and frame.number >= count
+        msg "(More stack frames follow...)" if count != proc.stack_size
+        return 
+      end
+
+      prefix = (frame == @proc.frame) ? '-->' : '   '
+      msg "%s #%d %s" % [prefix, frame.number, 
+                         frame.describe(:show_ip => verbose)]
+      
+      if verbose
+        frame.local_variables.each do |local|
+          msg "       #{local} = #{frame.run(local.to_s).inspect}"
+        end
+      end
+    end
+  end
+end

data/processor/command/base/cmd.rb

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Base class of all commands. Code common to all commands is here.
+# Note: don't end classname with Command (capital C) since main
+# will think this a command name like QuitCommand 
+require 'rubygems'; require 'require_relative'
+require 'columnize'
+require_relative '../../../app/complete'
+
+class Trepan
+  class Command
+    attr_accessor :core, :proc
+
+    unless defined?(MIN_ARGS)
+      MIN_ARGS      = 0      # run()'s args array must be at least this many
+      MAX_ARGS      = nil    # run()'s args array must be at least this many
+      NEED_STACK    = false  # We'll say that commands which need a stack
+                             # to run have to declare that and those that
+                             # don't don't have to mention it.
+    end
+
+    def initialize(proc)
+      @name = my_const(:NAME)
+      @proc = proc
+    end
+
+    def category
+      my_const(:CATEGORY)
+    end
+
+    # List commands arranged in an aligned columns
+    def columnize_commands(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ' ' * 4, 
+                           true, true, ' ' * 2).chomp
+    end
+
+    def columnize_numbers(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ', ',
+                           false, false, ' ' * 2).chomp
+    end
+
+    # FIXME: probably there is a way to do the delegation to proc methods
+    # without having type it all out.
+
+    def confirm(message, default)
+      @proc.confirm(message, default)
+    end
+
+    def errmsg(message, opts={})
+      @proc.errmsg(message, opts)
+    end
+
+    def obj_const(obj, name)
+      obj.class.const_get(name) 
+    end
+
+    def msg(message, opts={})
+      @proc.msg(message, opts)
+    end
+
+    # Convenience short-hand for @dbgr.intf[-1].msg_nocr
+    def msg_nocr(msg, opts={})
+      @proc.msg_nocr(msg, opts)
+    end
+
+    def my_const(name)
+      # 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
+      if c.member?('HELP') and !c.member?('SHORT_HELP')
+        short_help = self.class.const_get(:HELP).split("\n")[0].chomp('.')
+        self.class.const_set(:SHORT_HELP, short_help)
+      end
+      self.class.const_get(name)
+    end
+
+    def name
+      self.class.const_get(:NAME)
+    end
+
+    # The method that implements the debugger command.
+    def run(*args)
+      raise RuntimeError, 'You need to define this method elsewhere'
+    end
+
+    def section(message, opts={})
+      @proc.section(message, opts)
+    end
+
+    def settings
+      @proc.settings
+    end
+
+    def short_help
+      help_constant_sym = if self.class.constants.member?('SHORT_HELP') 
+                            :SHORT_HELP 
+                          else :HELP
+                          end
+      my_const(help_constant_sym)
+    end
+
+    # Define a method called 'complete' on the singleton class.
+    def self.completion(ary) 
+      self.send(:define_method, 
+                :complete, 
+                Proc.new {|prefix| 
+                  Trepan::Complete.complete_token(ary, prefix) })
+    end
+
+    # From reference debugger
+    def run_code(str)
+      @proc.dbgr.current_frame.run(str)
+    end
+
+    def current_method
+      @proc.frame.method
+    end
+
+    def current_frame
+      @proc.frame
+    end
+
+    def variables
+      @proc.variables
+    end
+
+    def listen(step=false)
+      @proc.listen(step)
+    end
+
+  end
+end
+if __FILE__ == $0
+  class Trepan
+    class CmdProcessor
+      def initialize(dbgr)
+      end
+      def confirm(message, default)
+        p ['confirm: ', message, default]
+      end
+      def errmsg(message, opts)
+        p ['err:', message, opts]
+      end
+      def msg(message, opts)
+        p [message, opts]
+      end
+      def msg_nocr(message, opts)
+        p ['nocr: ', message, opts]
+      end
+      def section(message, opts)
+        p ['section: ', message, opts]
+      end
+    end
+    class Command::Test < Trepan::Command
+      NAME = 'test'
+      CATEGORY = 'testcategory'
+      completion %w(a aa ab ba aac)
+    end
+  end
+  proc = Trepan::CmdProcessor.new(nil)
+  cmd = Trepan::Command::Test.new(proc)
+  %w(confirm errmsg msg msg_nocr section).each do |meth|
+    cmd.send(meth, 'test', nil)
+  end
+  p cmd.complete('aa')
+  cmd.instance_variable_set('@completions', %w(aardvark apple))
+  p cmd.complete('aa')
+end

data/processor/command/base/subcmd.rb

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# A base class for debugger subcommands.
+#
+# Note: don't end classname with Command (capital C) 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'
+
+class Trepan
+
+  class Subcommand  < Command
+
+    NotImplementedMessage = 
+      "This method must be overridden in a subclass" unless 
+      defined?(NotImplementedMessage)
+
+    attr_reader :name
+
+    unless defined?(IN_LIST)
+      IN_LIST    = true  # Show item in help list of commands
+      RUN_CMD    = true  # Run subcommand for those subcommands like "show"
+      # which append current settings to list output.
+      MIN_ABBREV = 1
+      NEED_STACK = false
+      NAME       = 'your_command_name'
+    end
+
+
+    # cmd contains the command object that this
+    # command is invoked through.  A debugger field gives access to
+    # the stack frame and I/O.
+    def initialize(cmd)
+      @cmd = cmd
+
+      # Convenience class access. We don't expect that any of these
+      # will change over the course of the program execution like
+      # errmsg(), msg(), and msg_nocr() might. (See the note below
+      # on these latter 3 methods.)
+      # 
+      @core     = cmd.core
+      @proc     = cmd.proc
+      # @dbgr = cmd.dbgr
+
+      # By default the name of the subcommand will be the name of the
+      # last part of module (e.g. "args" in "info.args" or "basename"
+      # in "shows.basename"). However it *is* possible for one to change
+      # that -- perhaps one may want to put several subcommands into 
+      # a single file. So in those cases, one will have to set @name
+      # accordingly by other means.
+      @name  = my_const(:NAME).to_sym
+
+    end
+
+    # Convenience short-hand for @proc.confirm
+    def confirm(msg, default=false)
+      return(@proc.confirm(msg, default))
+    end
+
+    def prefix
+      my_const('PREFIX')
+    end
+
+    # Set a Boolean-valued debugger setting. 
+    def run_set_bool(args, default=true)
+      onoff_arg = args.size < 3 ? 'on' : args[2]
+      begin
+        settings[subcmd_setting_key] = @proc.get_onoff(onoff_arg)
+        run_show_bool
+      rescue NameError, TypeError
+      end
+    end
+
+    # set an Integer-valued debugger setting. 
+    def run_set_int(arg, msg_on_error, min_value=nil, max_value=nil)
+      if arg.strip.empty?
+        errmsg('You need to supply a number.')
+        return
+      end
+      val = @proc.get_an_int(arg, 
+                             :max_value => max_value,
+                             :min_value => min_value, 
+                             :msg_on_error => msg_on_error
+                             )
+      if val
+        settings[subcmd_setting_key] = val
+        run_show_int
+      end
+    end
+
+    # Generic subcommand showing a boolean-valued debugger setting.
+    def run_show_bool(what=nil)
+      val = show_onoff(settings[subcmd_setting_key])
+      what = @name unless what
+      msg("%s is %s." % [what, val])
+    end
+
+    # Generic subcommand integer value display
+    def run_show_int(what=nil)
+      val = settings[subcmd_setting_key]
+      what = self.class.const_get(:PREFIX)[1..-1].join(' ') unless what
+      msg("%s is %d." % [what, val])
+    end
+
+    # Generic subcommand value display. Pass in a hash which may
+    # which optionally contain:
+    #
+    #   :name - the String name of key in settings to use. If :value
+    #           (described below) is set, then setting :name does
+    #           nothing.
+    #
+    #   :what - the String name of what we are showing. If none is
+    #           given, then we use the part of the SHORT_HELP string.
+    # 
+    #   :value - a String value associated with "what" above. If none
+    #            is given, then we pick up the value from settings.
+    # 
+    def run_show_val(opts={})
+      what = opts.member?(:what)  ? opts[:what]  : string_in_show
+      name = opts.member?(:name)  ? opts[:name]  : @name
+      val  = opts.member?(:value) ? opts[:value] : settings[name] 
+      msg("%s is %s." % [what, val])
+    end
+
+    def save_command_from_settings
+      ["#{subcmd_prefix_string} #{settings[subcmd_setting_key]}"]
+    end
+
+    def settings
+      @proc.settings
+    end
+        
+    def subcmd_prefix_string
+      self.class.const_get(:PREFIX).join(' ')
+    end
+
+    def subcmd_setting_key
+      self.class.const_get(:PREFIX)[1..-1].join('').to_sym
+    end
+
+    # Return 'on' for true and 'off' for false, and ?? for anything else.
+    def show_onoff(bool)
+      case(bool)
+      when true;  return 'on'
+      when false; return 'off'
+      when nil;   return 'unset'
+      else        return '??'
+      end
+    end
+
+    def string_in_show
+      my_const(:SHORT_HELP)['Show '.size .. -1].capitalize
+    end
+
+    def summary_help(subcmd_name)
+      msg_nocr("%-12s: %s" % [subcmd_name, my_const(:SHORT_HELP)])
+    end
+  end
+
+  class SetBoolSubcommand < Subcommand
+    completion %w(on off)
+
+    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 ShowBoolSubcommand < Subcommand
+    def run(args)
+      run_show_bool(string_in_show)
+    end
+  end
+
+  class ShowIntSubcommand < Subcommand
+    def run(args)
+      doc = 
+        if self.respond_to?(:short_help)
+          short_help
+        else
+          my_const(:HELP)[5..-2].capitalize
+        end
+      run_show_int(doc)
+    end
+  end
+
+end
+
+module Trepanning
+  module Subcommand
+    module_function
+    def set_name_prefix(__file__, klass)
+      dirname    = File.basename(File.dirname(File.expand_path(__file__)))
+      name = File.basename(__file__, '.rb')
+      klass.const_set('NAME', name)
+      klass.const_set('PREFIX', %W(#{dirname[0...-'_subcmd'.size]} #{name}))
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  # cmds = dbgr.core.processor.commands
+  # p cmds.keys
+  # subcmd = Trepan::Subcommand.new(cmds['exit'])
+  # def subcmd.msg(message)
+  #   puts message
+  # end
+  # def subcmd.errmsg(message)
+  #   puts message
+  # end
+  # p subcmd.settings
+  # p subcmd.show_onoff(subcmd.settings[:autoeval])
+  # subcmd.run_set_int('', 'Just a test')
+  class Trepan::Subcommand::Foo < Trepan::Subcommand
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+  end
+end