rb8-trepanning 0.1.3-universal-ruby-1.9.2

data/processor/help.rb

@@ -0,0 +1,92 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+module Trepan
+  # class SubHelp
+  #   def initialize(name, dir)
+  #     @name = name
+  #     @dir  = dir
+  #     load_sub_help_files(dir)
+  #   end
+
+  #   def load_sub_help_files(dir)
+  #     Dir.glob(dir, '*.txt').each do |txt| 
+  #       basename = File.basename(txt, '.txt')
+  #       @list << basename
+  #     end
+  #   end if File.directory?(dir)
+
+  #   def summary_help
+  #     section "List of #{@name} help"
+  #     msg @list
+  #   end
+  # end
+
+  module Help
+
+    def abbrev_stringify(name, min_abbrev)
+      "(#{name[0..min_abbrev-1]})#{name[min_abbrev..-1]}"
+    end
+
+    def summary_help(subcmd)
+      # 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 = subcmd.class.constants
+      if c.member?('HELP') and !c.member?('SHORT_HELP')
+        short_help = subcmd.class.const_get('HELP').split("\n")[0].chomp('.')
+        subcmd.class.const_set(:SHORT_HELP, short_help)
+      end
+      
+      '  %-12s -- %s' %
+          [abbrev_stringify(obj_const(subcmd, :NAME), 
+                            obj_const(subcmd, :MIN_ABBREV)),
+           obj_const(subcmd, :SHORT_HELP)]
+    end
+
+    # We were given cmd without a subcommand; cmd is something
+    # like "show", "info" or "set". Generally this means list
+    # all of the subcommands.
+    def summary_list(name, subcmds)
+      msg "List of #{name} commands (with minimum abbreviation in parenthesis):"
+      subcmds.list.each do |subcmd_name|
+        # Some commands have lots of output.
+        # they are excluded here because 'in_list' is false.
+        msg summary_help(subcmds.subcmds[subcmd_name])
+      end
+    end
+
+
+    # Error message when subcommand asked for but doesn't exist
+    def undefined_subcmd(cmd, subcmd)
+      errmsg(('Undefined "%s" subcommand: "%s". ' + 
+              "Try \"help %s *.\"") % [cmd, subcmd, cmd])
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  class TestClass
+    include Trepan::Help
+    HELP       = 'TestClass HELP.
+
+Long description goes here.'
+    MIN_ABBREV = 1
+    NAME       = File.basename(__FILE__)
+    def obj_const(obj, name)
+      obj.class.const_get(name) 
+    end
+    def msg(mess)
+      puts mess
+    end
+    def errmsg(mess)
+      puts "***#{mess}"
+    end
+    def initialize
+      puts summary_help(self)
+      undefined_subcmd('foo', 'bar')
+    end
+  end
+  TestClass.new
+end

data/processor/helper.rb

@@ -0,0 +1,76 @@
+module Trepan
+
+  def inside_emacs?
+    ENV['EMACS'] || ENV['INSIDE_EMACS']
+  end
+  module_function :inside_emacs?
+  
+  module ParseFunctions
+    Position_regexp = '(?:(\d+)|(.+?)[:.#]([^.:\s]+))' unless 
+      defined? Position_regexp
+    
+
+    # Parse 'str' of command 'cmd' as an integer between
+    # min and max. If either min or max is nil, that
+    # value has no bound.
+    def get_int(str, cmd, min=nil, max=nil, default=1)
+      return default unless str
+      begin
+        int = Integer(str)
+        if min and int < min
+          print "%s argument '%s' needs to at least %s.\n" % [cmd, str, min]
+          return nil
+        elsif max and int > max
+          print "%s argument '%s' needs to at most %s.\n" % [cmd, str, max]
+          return nil
+        end
+        return int
+      rescue
+        print "%s argument '%s' needs to be a number.\n" % [cmd, str]
+        return nil
+      end
+    end
+
+    # Return true if arg is 'on' or 1 and false arg is 'off' or 0.
+    # Any other value raises RuntimeError.
+    def get_onoff(arg, default=nil, print_error=true)
+      if arg.nil? or arg == ''
+        if default.nil?
+          if print_error
+            print "Expecting 'on', 1, 'off', or 0. Got nothing.\n"
+            raise RuntimeError
+          end
+          return default
+        end
+      end
+      case arg.downcase
+      when '1', 'on'
+        return true
+      when '0', 'off'
+        return false
+      else
+        if print_error
+          print "Expecting 'on', 1, 'off', or 0. Got: %s.\n" % arg.to_s
+          raise RuntimeError
+        end
+      end
+    end
+
+    # Return 'on' or 'off' for supplied parameter. The parmeter should
+    # be true, false or nil.
+    def show_onoff(bool)
+      if not [TrueClass, FalseClass, NilClass].member?(bool.class)
+        return "??"
+      end
+      return bool ? 'on' : 'off'
+    end
+
+    # Return true if code is syntactically correct for Ruby.
+    def syntax_valid?(code)
+      eval("BEGIN {return true}\n#{code}", nil, "", 0)
+    rescue Exception
+      false
+    end 
+
+  end
+end

data/processor/hook.rb

@@ -0,0 +1,134 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'virtual'
+
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+  # Command processor hooks.
+  attr_reader   :autodis_hook
+  attr_reader   :autoirb_hook
+  attr_reader   :autolist_hook
+  attr_reader   :debug_dbgr_hook
+  attr_reader   :display_hook
+  attr_reader   :timer_hook
+  attr_reader   :trace_hook
+  attr_reader   :tracebuf_hook
+  attr_reader   :unconditional_prehooks
+  attr_reader   :cmdloop_posthooks
+  attr_reader   :cmdloop_prehooks
+  
+  # Used to time how long a debugger action takes
+  attr_accessor :time_last
+  
+  class Hook
+    attr_accessor :list
+    
+    def initialize(list=[])
+      @list = list
+    end
+    
+    def delete_by_name(delete_name)
+      @list.delete_if {|hook_name, priority, hook| hook_name == delete_name}
+    end
+    
+    def empty?
+      @list.empty?
+    end
+    
+    def insert(priority, name, hook)
+      insert_loc = @list.size  # at end
+      @list.each_with_index do |entry, index|
+        n, p, h = entry
+        if priority > p 
+          insert_loc = index
+          break
+        end
+      end
+      @list.insert(insert_loc, [name, priority, hook])
+    end
+    
+    def insert_if_new(priority, name, hook)
+      insert(priority, name, hook) unless
+        @list.find {|try_name, try_priority, try_hook| try_name == name}
+    end
+    
+    # Run each function in `hooks' with args
+    def run(*args)
+      @list.each do |name, priority, hook| 
+        hook.call(name, *args) 
+      end
+    end
+    
+    # Could add delete_at and delete if necessary.
+  end
+  
+  def hook_initialize(commands)
+    @cmdloop_posthooks      = Hook.new
+    @cmdloop_prehooks       = Hook.new
+    @unconditional_prehooks = Hook.new
+    
+    irb_cmd = commands['irb']
+    @autoirb_hook  = ['autoirb', 
+                      Proc.new{|*args| irb_cmd.run(['irb']) if irb_cmd}]
+    
+    @debug_dbgr_hook = ['dbgdbgr',
+                        Proc.new{|*args| 
+                          if settings[:debugdbgr]
+                            $trepan_cmdproc  = self
+                            $trepan_frame    = @frame
+                          else
+                            $trepan_cmdproc  = nil
+                            $trepan_frame    = nil
+                          end}]
+    
+    display_cmd = commands['display']
+    @display_hook   = ['display', 
+                       Proc.new{|*args| display_cmd.run(['display']) if display_cmd}]
+    
+    # FIXME: generalize for any command run 
+    dis_cmd = commands['disassemble']
+    @autodis_hook  = ['autodis', 
+                      Proc.new{|*args| dis_cmd.run(['disassemble']) if dis_cmd}]
+    
+    list_cmd = commands['list']
+    @autolist_hook  = ['autolist', 
+                       Proc.new{|*args| list_cmd.run(['list']) if list_cmd}]
+    
+    @timer_hook     = ['timer', 
+                       Proc.new{|*args|
+                         now = Time.now
+                         msg("%g seconds" % 
+                             (now - @time_last)) if @time_last
+                         @time_last = now
+                       }]
+    @timer_posthook = ['timer', Proc.new{|*args| @time_last = Time.now}]
+    @trace_hook     = ['trace', 
+                       Proc.new{|*args| print_location}]
+    @tracebuf_hook  = ['tracebuffer', 
+                       Proc.new{|*args| @eventbuf.append(@event, @frame, 
+                                                         nil)}]
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  hooks = Trepan::CmdProcessor::Hook.new
+  hooks.run(5)
+  hook1 = Proc.new {|name, a| puts "#{name} called with #{a}"}
+  hooks = Trepan::CmdProcessor::Hook.new()
+  hooks.insert(-1, 'hook1', hook1)
+  p hooks.list
+  hooks.insert_if_new(-1, 'hook1', hook1)
+  puts '-' * 30
+  p hooks.list
+  hooks.run(10)
+  puts '-' * 30
+  hooks.insert(-1, 'hook2', hook1)
+  hooks.run(20)
+  puts '-' * 30
+  hooks.delete_by_name('hook2')
+  hooks.run(30)
+  puts '-' * 30
+  hooks.delete_by_name('hook1')
+  hooks.run(30)
+  puts '-' * 30
+end

data/processor/load_cmds.rb

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net> 
+require 'tmpdir'
+
+# Part of Trepan::CmdProcess that loads up debugger commands from
+# builtin and user directories.  
+# Sets @commands, @aliases, @macros
+require 'rubygems'; require 'require_relative'
+require_relative '../app/complete'
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  attr_reader   :aliases         # Hash[String] of command names
+                                 # indexed by alias name
+  attr_reader   :commands        # Hash[String] of command objects
+                                 # indexed by name
+  attr_reader   :macros          # Hash[String] of Proc objects 
+                                 # indexed by macro name.
+  attr_reader   :leading_str     # leading part of string. Used in 
+                                 # command completion
+
+  # "initialize" for multi-file class. Called from main.rb's "initialize".
+  def load_cmds_initialize
+    @commands = {}
+    @aliases = {}
+    @macros = {}
+
+    cmd_dirs = [ File.join(File.dirname(__FILE__), 'command') ]
+    cmd_dirs <<  @settings[:user_cmd_dir] if @settings[:user_cmd_dir]
+    cmd_dirs.each do |cmd_dir| 
+      load_debugger_commands(cmd_dir) if File.directory?(cmd_dir)
+    end
+  end
+
+  # Loads in debugger commands by require'ing each ruby file in the
+  # 'command' directory. Then a new instance of each class of the 
+  # form Trepan::xxCommand is added to @commands and that array
+  # is returned.
+  def load_debugger_commands(file_or_dir)
+    if File.directory?(file_or_dir)
+      dir = File.expand_path(file_or_dir)
+      # change $0 so it doesn't get in the way of __FILE__ = $0
+      old_dollar0 = $0
+      $0 = ''
+      Dir.glob(File.join(dir, '*.rb')).each do |rb| 
+        # We use require so that multiple calls have no effect.
+        require rb
+      end
+      $0 = old_dollar0
+    elsif File.readable?(file_or_dir)
+      # We use load in case we are reloading. 
+      # 'require' would not be effective here
+      load file_or_dir
+    else
+      return false
+    end
+    # Instantiate each Command class found by the above require(s).
+    Trepan::Command.constants.grep(/.Command$/).each do |name|
+      klass = Trepan::Command.const_get(name)
+      cmd = klass.send(:new, self)
+
+      # Add to list of commands and aliases.
+      cmd_name = klass.const_get(:NAME)
+      if klass.constants.member?('ALIASES') || 
+          klass.constants.member?(:ALIASES)
+        aliases= klass.const_get('ALIASES') || klass.const_get(:ALIASES)
+        aliases.each {|a| @aliases[a] = cmd_name}
+      end
+      @commands[cmd_name] = cmd
+    end
+    return true
+  end
+
+  def load_debugger_command(command_file)
+    return unless File.readable?(command_file)
+    load command_file
+    Trepan::Command.constants.grep(/.Command$/).each do |command|
+      setup_command(command)
+    end
+  end
+
+  # Looks up cmd_array[0] in @commands and runs that. We do lots of 
+  # validity testing on cmd_array.
+  def run_cmd(cmd_array)
+    unless cmd_array.is_a?(Array)
+      errmsg "run_cmd argument should be an Array, got: #{cmd_array.class}"
+      return
+    end
+    if cmd_array.detect{|item| !item.is_a?(String)}
+      errmsg "run_cmd argument Array should only contain strings. " + 
+        "Got #{cmd_array.inspect}"
+      return
+    end
+    if cmd_array.empty?
+      errmsg "run_cmd Array should have at least one item. " + 
+        "Got: #{cmd_array.inspect}"
+      return
+    end
+    cmd_name = cmd_array[0]
+    if @commands.member?(cmd_name)
+      @commands[cmd_name].run(cmd_array)
+    end
+  end
+
+  def save_commands(opts)
+    save_filename = opts[:filename] || 
+      File.join(Dir.tmpdir, "trepanning-save-#{$$}.txt")
+    begin
+      save_file = File.open(save_filename, 'w')
+    rescue => exc
+      errmsg("Can't open #{save_filename} for writing.")
+      errmsg("System reports: #{exc.inspect}")
+      return nil
+    end
+    save_file.puts "#\n# Commands to restore trepanning environment\n#\n"
+    @commands.each do |cmd_name, cmd_obj|
+      cmd_obj.save_command if cmd_obj.respond_to?(:save_command)
+      next unless cmd_obj.is_a?(Trepan::SubcommandMgr)
+      cmd_obj.subcmds.subcmds.each do |subcmd_name, subcmd_obj|
+        save_file.puts subcmd_obj.save_command if 
+          subcmd_obj.respond_to?(:save_command)
+        next unless subcmd_obj.is_a?(Trepan::SubSubcommandMgr)
+        subcmd_obj.subcmds.subcmds.each do |subsubcmd_name, subsubcmd_obj|
+          save_file.puts subsubcmd_obj.save_command if 
+            subsubcmd_obj.respond_to?(:save_command)
+        end
+      end
+    end
+    save_file.puts "!FileUtils.rm #{save_filename.inspect}" if 
+      opts[:erase]
+    save_file.close
+
+    return save_filename
+  end
+
+  # Instantiate a Trepan::Command and extract info: the NAME, ALIASES
+  # and store the command in @commands.
+  def setup_command(command)
+    # Note: there is probably a non-eval way to instantiate the
+    # command, but I don't know it. And eval works.
+    klass = self.instance_eval("Trepan::Command::#{command}")
+    cmd = klass.send(:new, self)
+    
+    # Add to list of commands and aliases.
+    cmd_name = klass.const_get(:NAME)
+    if klass.constants.member?(:ALIASES)
+      aliases= klass.const_get(:ALIASES)  
+      aliases.each {|a| @aliases[a] = cmd_name}
+    end
+    @commands[cmd_name] = cmd
+  end
+
+  # Handle initial completion. We draw from the commands, aliases,
+  # and macros for completion. However we won't include aliases which
+  # are prefixes of other commands.
+  def complete(str, last_token)
+    @leading_str = str
+    next_blank_pos, token = Trepan::Complete.next_token(str, 0)
+    return [''] if token.empty? && !last_token.empty?
+    match_pairs = Trepan::Complete.complete_token_with_next(@commands,
+                                                            token)
+    match_hash = {}
+    match_pairs.each do |pair|
+      match_hash[pair[0]] = pair[1]
+    end
+    alias_pairs = Trepan::Complete.
+      complete_token_filtered_with_next(@aliases, token, match_hash,
+                                        @commands)
+    match_pairs += alias_pairs
+    if str[next_blank_pos..-1].empty?
+      return match_pairs.map{|pair| pair[0]}.sort
+    else
+      alias_pairs.each do |pair|
+        match_hash[pair[0]] = pair[1]
+      end
+    end
+    if match_pairs.size > 1
+      # FIXME: figure out what to do here.
+      # Matched multiple items in the middle of the string
+      # We can't handle this so do nothing.
+      return []
+      # return match_pairs.map do |name, cmd|
+      #   ["#{name} #{args[1..-1].join(' ')}"]
+      # end
+    end
+    # match_pairs.size == 1
+    next_complete(str, next_blank_pos, match_pairs[0][1], last_token)
+  end
+
+  def next_complete(str, next_blank_pos, cmd, last_token)
+    next_blank_pos, token = Trepan::Complete.next_token(str, next_blank_pos)
+    return [] if token.empty? && !last_token.empty?
+    
+    if cmd.respond_to?(:complete_token_with_next) 
+      match_pairs = cmd.complete_token_with_next(token)
+      return [] if match_pairs.empty?
+      if str[next_blank_pos..-1].rstrip.empty? && 
+          (token.empty? || token == last_token)
+        return match_pairs.map { |completion, junk| completion }
+      else
+        if match_pairs.size == 1
+          return next_complete(str, next_blank_pos, match_pairs[0][1], 
+                               last_token)
+        else
+          # FIXME: figure out what to do here.
+          # Matched multiple items in the middle of the string
+          # We can't handle this so do nothing.
+          return []
+        end
+      end
+    elsif cmd.respond_to?(:complete)
+      matches = cmd.complete(token)
+      return [] if matches.empty?
+      if str[next_blank_pos..-1].rstrip.empty? && 
+          (token.empty? || token == last_token)
+        return matches
+      else
+        # FIXME: figure out what to do here.
+        # Matched multiple items in the middle of the string
+        # We can't handle this so do nothing.
+        return []
+      end
+    else
+      return []
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../interface/user'  # user interface (includes I/O)
+  cmdproc = Trepan::CmdProcessor.new([], nil)
+  cmddir = File.join(File.dirname(__FILE__), 'command')
+  cmdproc.instance_variable_set('@settings', {})
+  cmdproc.interfaces = [Trepan::UserInterface.new(nil, nil,
+                                                  :history_save=>false)]
+  cmdproc.load_cmds_initialize
+  require 'columnize'
+  puts Columnize.columnize(cmdproc.commands.keys.sort)
+  puts '=' * 20
+  puts Columnize.columnize(cmdproc.aliases.keys.sort)
+  puts '=' * 20
+
+  def cmdproc.errmsg(mess)
+    puts "** #{mess}"
+  end
+
+  def cmdproc.msg(mess)
+    puts mess
+  end
+
+  cmdproc.run_cmd('foo')  # Invalid - not an Array
+  cmdproc.run_cmd([])     # Invalid - empty Array
+  cmdproc.run_cmd(['list', 5])  # Invalid - nonstring arg
+  p cmdproc.complete("d", 'd')
+  require 'ruby-debug'; Debugger.start; debugger
+  p cmdproc.complete("sho d", 'd')
+  p cmdproc.complete('', '')
+end