rbx-trepanning 0.2.0-universal-rubinius-2.0

data/processor/list.rb

@@ -0,0 +1,123 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Trepan command list validation routines.  A String type is
+# usually passed in as the argument to validation routines.
+
+require 'rubygems'
+require 'require_relative'
+
+require_relative './validate'
+
+class Trepan
+  class CmdProcessor < VirtualCmdProcessor
+
+    # If last is less than first, assume last is a count rather than an
+    # end line number. If last is negative, range is [first+last..first].
+    def adjust_last(first, last)
+      last < first ? first + last - 1 : last
+    end
+
+    # Parse a list command. On success return:
+    #   - compiled method
+    #   - the line number - a Fixnum
+    #   - file name
+    #   - last line
+    def parse_list_cmd(position_str, listsize, center_correction=0)
+      cm = nil
+      if position_str.empty?
+        filename = frame.file
+        first = [1, frame.line - center_correction].max
+      else
+        list_cmd_parse = parse_list(position_str,
+                                    :file_exists_proc => file_exists_proc)
+        return [nil] * 4 unless list_cmd_parse
+        last = list_cmd_parse.num
+        position = list_cmd_parse.position
+
+        if position.is_a?(String)
+          if position == '-'
+            return no_frame_msg_for_list unless frame.line
+            first = [1, frame.line - 2*listsize - 1].max
+          elsif position == '.'
+            return no_frame_msg_for_list unless frame.line
+            if (second = list_cmd_parse.num)
+              first = frame.line 
+              last = adjust_last(first, second)
+            else
+              first = [1, frame.line - center_correction].max
+              last = first + listsize - 1
+            end
+          end
+          filename = frame.file
+          cm = frame.method
+        else
+          cm, filename, offset, offset_type = 
+            parse_position(position)
+
+          return [nil] * 4 unless filename
+          if offset_type == :line
+            first = offset
+          elsif cm
+            first, vm_offset = 
+              position_to_line_and_offset(cm, filename, position, 
+                                          offset_type)
+            unless first
+              errmsg("Unable to get location in #{meth_or_frame}")
+              return [nil] * 4 
+            end
+          elsif !offset 
+            first = 1
+          else
+            errmsg("Unable to parse list position #{position_str}")
+            return [nil] * 4
+          end
+        end
+      end
+      if last
+        first, last = [first + last, first] if last < 0
+        last = adjust_last(first, last)
+      else
+        first = [1, first - center_correction].max 
+        last = first + listsize - 1 unless last
+      end
+      LineCache::cache(filename) unless LineCache::cached?(filename)
+      return [cm, filename, first, last]
+    end
+    
+    def no_frame_msg_for_list
+      errmsg("No Ruby program loaded.")
+      return [nil] * 4
+    end
+    
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative 'mock'
+  require_relative 'frame'
+  dbgr, cmd = MockDebugger::setup('exit', false)
+  cmdproc  = cmd.proc
+  cmdproc.frame_initialize
+  cmdproc.instance_variable_set('@settings', 
+                                Trepan::CmdProcessor::DEFAULT_SETTINGS)
+  def foo; 5 end
+  def cmdproc.errmsg(msg)
+    puts msg
+  end
+  puts '-' * 20
+  p cmdproc.parse_list_cmd('.', 10)
+  p cmdproc.parse_list_cmd('-', 10)
+  p cmdproc.parse_list_cmd('foo', 10)
+  p cmdproc.parse_list_cmd('@0', 10)
+  p cmdproc.parse_list_cmd("#{__LINE__}", 10)
+  p cmdproc.parse_list_cmd("#{__FILE__}   @0", 10)
+  p '-' * 40
+  # require_relative '../lib/trepanning'; debugger
+  p cmdproc.parse_list_cmd("#{__FILE__}:#{__LINE__}", 10)
+  p cmdproc.parse_list_cmd("#{__FILE__} #{__LINE__}", 10)
+  p '-' * 40
+  p cmdproc.parse_list_cmd("cmdproc.errmsg", 10)
+  p cmdproc.parse_list_cmd("cmdproc.errmsg:@0", 10)
+  p cmdproc.parse_list_cmd("cmdproc.errmsg:@0", -10)
+end

data/processor/load_cmds.rb

@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010-2011, 2013 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
+  class CmdProcessor < 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.
+        # In rubinius 2.0.0.rc1 (1.8.7 93c75658...) $0 is nil
+        # and this can cause an error when one restores $0 below.
+        # See https://github.com/rubinius/rubinius/issues/2450
+        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')
+          aliases= klass.const_get('ALIASES')
+          aliases.each {|a| @aliases[a] = cmd_name}
+        end
+        @commands[cmd_name] = cmd
+      end
+    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
+
+    # 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
+
+    # 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
+end
+if __FILE__ == $0
+  class Trepan::CmdProcessor
+    def initialize(core, settings={})
+    end
+  end
+
+  cmdproc = Trepan::CmdProcessor.new(nil)
+  cmddir = File.join(File.dirname(__FILE__), 'command')
+  cmdproc.instance_variable_set('@settings', {})
+  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')
+  p cmdproc.complete("sho d", 'd')
+  p cmdproc.complete('', '')
+end

data/processor/location.rb

@@ -0,0 +1,228 @@
+# Copyright (C) 2010-2011, 2013 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; 
+require 'pathname'  # For cleanpath
+require 'linecache'
+require 'require_relative'
+require_relative 'disassemble'
+require_relative 'msg'
+require_relative 'frame'
+require_relative '../app/file'
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+    unless defined?(EVENT2ICON)
+      # Event icons used in printing locations.
+      EVENT2ICON = {
+        'brkpt'          => 'xx',
+        'tbrkpt'         => 'x1',
+        'c-call'         => 'C>',
+        'c-return'       => '<C',
+        'step-call'      => '->',
+        'call'           => '->',
+        'class'          => '::',
+        'coverage'       => '[]',
+        'debugger-call'  => ':o',
+        'end'            => '-|',
+        'line'           => '--',
+        'raise'          => '!!',
+        'return'         => '<-',
+        'start'          => '>>',
+        'switch'         => 'sw',
+        'trace-var'      => '$V',
+        'unknown'        => '?!',
+        'vm'             => 'VM',
+        'vm-insn'        => '..',
+      } 
+    end
+
+  def canonic_file(filename, resolve=true)
+    # For now we want resolved filenames 
+    if @settings[:basename] 
+      return File.basename(filename)
+    end
+    if resolve
+      try_filename = LineCache::map_file(filename)
+      filename = try_filename || filename
+      if !File.exist?(filename) 
+        if (try_filename = find_load_path(filename))
+          return try_filename
+        elsif (try_filename = resolve_file_with_dir(filename))
+          return try_filename
+        else
+          return File.expand_path(Pathname.new(filename).cleanpath.to_s).
+            gsub(/\.rbc$/, '.rb')
+        end
+      end
+    end
+    return filename.gsub(/\.rbc$/, '.rb')
+  end
+
+  # Return the text to the current source line.
+  # FIXME: loc_and_text should call this rather than the other
+  # way around.
+  def current_source_text
+    opts = {:reload_on_change => settings[:reload]}
+    loc, junk, text = loc_and_text(source_location_info, opts)
+    text
+  end
+  
+  def resolve_file_with_dir(path_suffix)
+    settings[:directory].split(/:/).each do |dir|
+      dir = 
+        if '$cwd' == dir
+          Dir.pwd
+        elsif '$cdir' == dir
+          Rubinius::OS_STARTUP_DIR
+        elsif '$rbx' == dir
+          compiler_file = '/lib/compiler/compiler.rb'
+          compiler_rb_path = 
+            $LOADED_FEATURES.find{|f| f.end_with?(compiler_file)}
+          if compiler_rb_path
+            compiler_rb_path[0...-(compiler_file.size)]
+          else
+            nil
+          end
+        else
+          dir
+        end
+      next unless dir && File.directory?(dir)
+      try_file = File.join(dir, path_suffix)
+      return try_file if File.readable?(try_file)
+    end
+    nil
+  end
+  
+  # Get line +line_number+ from file named +filename+. Return "\n"
+  # there was a problem. Leading blanks are stripped off.
+  def line_at(filename, line_number, 
+              opts = {
+                :reload_on_change => @settings[:reload],
+                :output => @settings[:highlight]
+              })
+    # We use linecache first to give precidence to user-remapped
+    # file names
+    line = LineCache::getline(filename, line_number, opts)
+    unless line
+      # Try using search directories (set with command "directory")
+      if filename[0..0] != File::SEPARATOR
+        try_filename = resolve_file_with_dir(filename) 
+        if try_filename && 
+            line = LineCache::getline(try_filename, line_number, opts) 
+          LineCache::remap_file(filename, try_filename)
+        end
+      end
+    end
+    return nil unless line
+    return line.lstrip.chomp
+  end
+  
+  def loc_and_text(loc, opts=
+                   {:reload_on_change => @settings[:reload],
+                     :output => @settings[:highlight]
+                   })
+    
+    vm_location = @frame.vm_location
+    filename = vm_location.method.active_path
+    line_no  = @frame.line
+    static   = vm_location.constant_scope
+    opts[:compiled_method] = top_scope(@frame.method)
+    
+    if @frame.eval?
+      file = LineCache::map_script(static.script)
+      text = LineCache::getline(static.script, line_no, opts)
+      loc += " remapped #{canonic_file(file)}:#{line_no}"
+    else
+      text = line_at(filename, line_no, opts)
+      map_file, map_line = LineCache::map_file_line(filename, line_no)
+      if [filename, line_no] != [map_file, map_line]
+        loc += " remapped #{canonic_file(map_file)}:#{map_line}"
+      end
+    end
+    [loc, line_no, text]
+  end
+  
+  def format_location(event=@event, frame=@frame, frame_index=@frame_index)
+    text      = nil
+    ev        = if event.nil? || 0 != frame_index
+                  '  ' 
+                else
+                  (EVENT2ICON[event] || event)
+                end
+    
+    @line_no  = frame.line
+    
+    loc = source_location_info
+    loc, @line_no, text = loc_and_text(loc)
+    ip_str = frame.method ? " @#{frame.next_ip}" : ''
+    
+    "#{ev} (#{loc}#{ip_str})"
+  end
+  
+  # FIXME: Use above format_location routine
+  def print_location
+    text      = nil
+    ev        = if @event.nil? || 0 != @frame_index
+                  '  ' 
+                else
+                  (EVENT2ICON[@event] || @event)
+                end
+    
+    @line_no  = @frame.line
+    
+    loc = source_location_info
+    loc, @line_no, text = loc_and_text(loc)
+    ip_str = frame.method ? " @#{frame.next_ip}" : ''
+    
+    msg "#{ev} (#{loc}#{ip_str})"
+    
+    # if %w(return c-return).member?(@core.event)
+    #   retval = Trepan::Frame.value_returned(@frame, @core.event)
+    #   msg 'R=> %s' % retval.inspect 
+    # end
+    
+    if text && !text.strip.empty?
+      old_maxstring = @settings[:maxstring]
+      @settings[:maxstring] = -1
+      msg text
+      @settings[:maxstring] = old_maxstring
+      @line_no -= 1
+    else
+      show_bytecode
+    end
+  end
+  
+  def source_location_info
+    filename  = @frame.vm_location.method.active_path
+    canonic_filename = 
+      if @frame.eval?
+        'eval ' + safe_repr(@frame.eval_string.gsub("\n", ';').inspect, 20)
+      else
+        canonic_file(filename, false)
+      end
+    loc = "#{canonic_filename}:#{@frame.line}"
+    return loc
+  end 
+end
+
+if __FILE__ == $0 && caller.size == 0
+  # Demo it.
+  require_relative './mock'
+  dbgr = MockDebugger::MockDebugger.new
+  proc = Trepan::CmdProcessor.new(dbgr)
+  proc.settings = {:directory => '$rbx:$cdir:$cwd'}
+  proc.frame_initialize
+  frame = Trepan::Frame.new(self, 1, Rubinius::VM.backtrace(0)[0])
+  proc.instance_variable_set('@frame', frame)
+
+  puts proc.canonic_file(__FILE__)
+  puts proc.canonic_file('lib/compiler/ast.rb')
+  proc.settings[:basename] = true
+  puts proc.canonic_file(__FILE__)
+  puts proc.current_source_text
+  xx = eval <<-END
+     proc.frame_initialize
+     frame = Trepan::Frame.new(self, 1, Rubinius::VM.backtrace(0)[0])
+     proc.instance_variable_set('@frame', frame)
+     puts proc.current_source_text
+  END
+end