rbx-trepanning 0.2.0-universal-rubinius-2.0

data/processor.rb

@@ -0,0 +1,404 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# The main "driver" class for a command processor. Other parts of the 
+# command class and debugger command objects are pulled in from here.
+
+require 'set'
+
+require 'rubygems'; require 'require_relative'
+## %w(default display eventbuf eval load_cmds location frame hook msg 
+##    validate).each do
+%w(default breakpoint disassemble display eval eventbuf load_cmds location 
+   frame hook msg running stepping validate).each do
+  |mod_str|
+  require_relative "processor/#{mod_str}"
+end
+require_relative 'app/brkptmgr'
+
+class Trepan
+  class CmdProcessor < VirtualCmdProcessor
+
+    # SEE ALSO attr's in require_relative's of loop above.
+
+    attr_reader   :cmd_argstr      # Current command args, a String.
+                                   # This is current_command with the command
+                                   # name removed from the beginning.
+    attr_reader   :cmd_name        # command name before alias or macro resolution
+    attr_reader   :cmd_queue       # queue of commands to run
+    ## attr_reader   :core            # Trepan core object
+    attr_reader   :current_command # Current command getting run, a String.
+    attr_accessor   :dbgr          # Trepan instance (via
+                                   # Trepan::Core instance)
+                                   ## FIXME 1.9.2 has attr_reader !
+    attr_accessor :debug_nest      # Number of nested debugs. Used in showing
+                                   # prompt.
+    attr_accessor :different_pos   # Same type as settings[:different] 
+                                   # this is the temporary value for the
+                                   # next stop while settings is the default
+                                   # value to use.
+    attr_accessor :event           # Stop event
+    attr_reader   :intf            # Current interface
+                                   # Trepan::Core instance)
+    attr_accessor :leave_cmd_loop  # Commands set this to signal to leave
+                                   # the command loop (which often continues to 
+                                   # run the debugged program). 
+    attr_accessor :line_no         # Last line shown in "list" command
+    attr_accessor :next_level      # Fixnum. frame.stack_size has to
+                                   # be <= than this.  If next'ing,
+                                   # this will be > 0.
+    attr_accessor :next_thread     # Thread. If non-nil then in
+                                   # stepping the thread has to be
+                                   # this thread.
+    attr_accessor :pass_exception  # Pass an exception back 
+    attr_accessor :prompt          # String print before requesting input
+    attr_reader   :settings        # Hash[:symbol] of command
+                                   # processor settings
+    attr_reader   :step_bp
+
+    # The following are used in to force stopping at a different line
+    # number. FIXME: could generalize to a position object.
+    attr_accessor :last_pos       # Last position. 6-Tuple: of
+                                  # [location, container, stack_size, 
+                                  #  current_thread, pc_offset]
+
+
+    def initialize(dbgr, settings={})
+      @cmd_queue       = []
+      @dbgr            =  dbgr
+      @debug_nest      = 1
+      @hidelevels      = {}
+      @last_command    = nil
+      @last_pos        = [nil, nil, nil, nil, nil, nil]
+      @next_level      = 32000
+      @next_thread     = nil
+      @user_variables = 0
+      
+
+      start_cmds       = settings.delete(:start_cmds)
+      start_file       = settings.delete(:start_file)
+
+      @settings        = DEFAULT_SETTINGS.merge(settings)
+      @different_pos   = @settings[:different]
+
+      # FIXME: Rework using a general "set substitute file" command and
+      # a global default profile which gets read.
+      prelude_file = File.expand_path(File.join(File.dirname(__FILE__), 
+                                                %w(.. data prelude.rb)))
+
+      # Start with empty thread and frame info.
+      frame_teardown 
+
+      # Run initialization routines for each of the "submodule"s.
+      # load_cmds has to come first.
+      ## %w(load_cmds breakpoint display eventbuf frame running validate
+      ##   ).each do |submod|
+      %w(load_cmds breakpoint display eventbuf frame running 
+         stepping validate).each do 
+        |submod|
+        self.send("#{submod}_initialize")
+      end
+      hook_initialize(commands)
+      # unconditional_prehooks.insert_if_new(-1, *@trace_hook) if
+      # settings[:traceprint]
+    end
+
+    def compute_prompt
+      "(#{@settings[:prompt]}): "
+    end
+
+    def finalize
+      breakpoint_finalize
+      stepping_breakpoint_finalize
+    end
+
+    def canonic_container(container)
+      [container[0], canonic_file(container[1])]
+    end
+
+    def compute_prompt
+      "(#{@settings[:prompt]}): " 
+    end
+
+    # Check that we meed the criteria that cmd specifies it needs
+    def ok_for_running(cmd, name, nargs)
+      # TODO check execution_set against execution status.
+      # Check we have frame is not null
+      min_args = cmd.class.const_get(:MIN_ARGS)
+      if nargs < min_args
+        errmsg(("Command '%s' needs at least %d argument(s); " + 
+                "got %d.") % [name, min_args, nargs])
+        return false
+      end
+      max_args = cmd.class.const_get(:MAX_ARGS)
+      if max_args and nargs > max_args
+        errmsg(("Command '%s' needs at most %d argument(s); " + 
+                "got %d.") % [name, max_args, nargs])
+        return false
+      end
+      # if cmd.class.const_get(:NEED_RUNNING) && !...
+      #   errmsg "Command '%s' requires a running program." % name
+      #   return false
+      # end
+
+      if cmd.class.const_get(:NEED_STACK) && !@frame
+        errmsg "Command '%s' requires a running stack frame." % name
+        return false
+      end
+
+      return true
+    end
+
+    # Run one debugger command. True is returned if we want to quit.
+    def process_command_and_quit?()
+      intf_size = @dbgr.intf.size
+      @intf  = @dbgr.intf[-1]
+      return true if @intf.input_eof? && intf_size == 1
+      while intf_size > 1 || !@intf.input_eof?
+        begin
+          @current_command = 
+            if @cmd_queue.empty?
+              # Leave trailing blanks on for the "complete" command
+              read_command.chomp 
+            else
+              @cmd_queue.shift
+            end
+          if @current_command.empty? 
+            next unless @last_command && intf.interactive?;
+          end
+          next if @current_command[0..0] == '#' # Skip comment lines
+          break
+        rescue IOError, Errno::EPIPE => e
+          if intf_size > 1
+            @dbgr.intf.pop
+            intf_size = @dbgr.intf.size
+            @intf = @dbgr.intf[-1]
+            @last_command = nil
+            print_location
+          else
+            ## FIXME: think of something better.
+            quit('exit!')
+            return true
+          end
+        rescue Exception => exc
+          errmsg("Internal debugger error in read: #{exc.inspect}")
+          exception_dump(exc, @settings[:debugexcept], $!.backtrace)
+        end
+      end
+      run_command(@current_command)
+
+      # Save it to the history.
+      @intf.history_io.puts @last_command if @last_command && @intf.history_io
+    end
+
+    def after_cmdloop
+      @cmdloop_posthooks.run
+    end
+
+    def before_cmdloop
+
+      frame_setup
+
+      @unconditional_prehooks.run
+      if breakpoint?
+        delete_breakpoint(@brkpt) if @brkpt.temp?
+        @last_pos = [@frame.vm_location, @stack_size, @current_thread, @event] 
+      end
+
+      if stepping_skip? # || @stack_size <= @hide_level
+        if @next_thread
+          self.next(@step_count, :next_level => @next_level)
+        else
+          step(@return_to_program, @step_count, {}, @stop_condition)
+        end
+        return true
+      elsif @event == 'start'
+        step('step', 0)
+        return true
+      end
+
+      @prompt = compute_prompt
+
+      @leave_cmd_loop = false
+      print_location unless @settings[:traceprint]
+      # if 'trace-var' == @event 
+      #   msg "Note: we are stopped *after* the above location."
+      # end
+
+      @eventbuf.add_mark if @settings[:tracebuffer]
+      
+      @return_to_program = false
+      @cmdloop_prehooks.run
+      return false
+    end
+
+
+    # This is the main entry point.
+    def process_commands
+      skip_command = before_cmdloop
+      while not @leave_cmd_loop do
+        begin
+#          if settings[:traceprint]
+#            @return_to_program = 'step'
+#          else
+            if !skip_command 
+              break if process_command_and_quit?()
+            end
+#          end
+          if @return_to_program
+            after_cmdloop
+            if @step_count >= 0 && 'finish' != @return_to_program
+              @step_bp = step_over_by(1)
+              run_command('disassemble all') if settings[:debugstep]
+              dbgr.listen('step' == @return_to_program)
+            else
+              @step_bp = nil
+              dbgr.listen
+            end
+            skip_command = before_cmdloop
+          end
+        rescue SystemExit
+          @dbgr.stop
+          raise
+        rescue Exception => exc
+          # If we are inside the script interface errmsg may fail.
+          begin
+            errmsg("Internal debugger error: #{exc.inspect}")
+          rescue IOError
+            $stderr.puts "Internal debugger error: #{exc.inspect}"
+          end
+          exception_dump(exc, @settings[:debugexcept], $!.backtrace)
+        end
+      end
+      after_cmdloop
+    end
+
+    # Run current_command, a String. @last_command is set after the
+    # command is run if it is a command.
+    def run_command(current_command)
+      eval_command = 
+        if current_command[0..0] == '!'
+          current_command[0] = ''
+        else
+          false
+        end
+
+      unless eval_command
+        commands = current_command.split(';;')
+        if commands.size > 1
+          current_command = commands.shift
+          @cmd_queue.unshift *commands
+        end
+        args = current_command.split
+        # Expand macros. FIXME: put in a procedure
+        while true do
+          macro_cmd_name = args[0]
+          return false if args.size == 0
+          break unless @macros.member?(macro_cmd_name)
+          current_command = @macros[macro_cmd_name][0].call(*args[1..-1])
+          msg current_command.inspect if settings[:debugmacro]
+          if current_command.is_a?(Array) && 
+              current_command.all? {|val| val.is_a?(String)}
+            args = (first=current_command.shift).split
+            @cmd_queue += current_command
+            current_command = first
+          elsif current_command.is_a?(String)
+            args = current_command.split
+          else
+            errmsg("macro #{macro_cmd_name} should return an Array " +
+                   "of Strings or a String. Got #{current_command.inspect}")
+            return false
+          end
+        end
+
+        @cmd_name = args[0]
+        run_cmd_name = 
+          if @aliases.member?(@cmd_name)
+            @aliases[@cmd_name] 
+          else
+            @cmd_name
+          end
+        
+        run_cmd_name = uniq_abbrev(@commands.keys, run_cmd_name) if
+          !@commands.member?(run_cmd_name) && @settings[:abbrev]
+          
+        if @commands.member?(run_cmd_name)
+          cmd = @commands[run_cmd_name]
+          if ok_for_running(cmd, run_cmd_name, args.size-1)
+            @cmd_argstr = current_command[@cmd_name.size..-1].lstrip
+            cmd.run(args) 
+            @last_command = current_command
+          end
+          return false
+        end
+      end
+
+      # Eval anything that's not a command or has been
+      # requested to be eval'd
+      if settings[:autoeval] || eval_command
+        begin
+          eval_code(current_command, @settings[:maxstring])
+          return false
+        rescue NameError
+        end
+      end
+      undefined_command(cmd_name)
+      return false
+    end
+
+    # Error message when a command doesn't exist
+    def undefined_command(cmd_name)
+      begin 
+        errmsg('Undefined command: "%s". Try "help".' % cmd_name)
+      rescue
+        $stderr.puts 'Undefined command: "%s". Try "help".' % cmd_name
+      end
+    end
+
+    # FIXME: Allow access to both Trepan::CmdProcessor and Trepan
+    # for index [] and []=.
+    # If there is a Trepan::CmdProcessor setting that would take precidence.
+    # def settings
+    #   @settings.merge(@dbgr.settings) # wrong because this doesn't allow []=
+    # end
+  end
+end
+
+if __FILE__ == $0
+  $0 = 'foo' # So we don't get here again
+  require_relative 'lib/trepanning'
+  dbg =  Trepan.new(:nx => true)
+  cmdproc = dbg.instance_variable_get('@processor')
+  cmdproc.msg('I am main')
+  cmdproc.errmsg('Whoa!')
+  cmds = cmdproc.commands
+  p cmdproc.aliases
+  p cmdproc.commands.keys.sort
+  cmd_name, cmd_obj = cmds.first
+  puts cmd_obj.class.const_get(:HELP)
+  puts cmd_obj.class.const_get(:SHORT_HELP)
+
+  cmdproc.instance_variable_set('@current_thread', Thread.current)
+  puts cmdproc.compute_prompt
+  Thread.new{ puts cmdproc.compute_prompt }.join
+
+  x = Thread.new{ Thread.pass; x = 1 }
+  puts cmdproc.compute_prompt
+  x.join
+  cmdproc.debug_nest += 1
+  puts cmdproc.compute_prompt
+
+  # if ARGV.size > 0
+  #   cmdproc.msg('Enter "q" to quit')
+  #   cmdproc.process_commands
+  # else
+  #   $input = []
+  #   class << cmdproc
+  #     def read_command
+  #       $input.shift
+  #     end
+  #   end
+  #   $input = ['1+2']
+  #   cmdproc.process_command_and_quit?
+  #   $input = ['!s = 5']  # ! means eval line 
+  #   cmdproc.process_command_and_quit?
+  # end
+end

data/rbx-trepanning.gemspec

@@ -0,0 +1,39 @@
+# -*- Ruby -*-
+# -*- encoding: utf-8 -*-
+require 'rake'
+require 'rubygems' unless 
+  Object.const_defined?(:Gem)
+require File.dirname(__FILE__) + "/app/options"
+Gem::Specification.new do |s|
+  s.add_dependency('columnize')
+  s.add_development_dependency('diff-lcs') # For testing only
+  s.add_dependency('rbx-require-relative', '>=0.0.4')
+  s.add_dependency('rbx-linecache', '~>1.3')
+  s.add_dependency('coderay', '>=1.0')
+  s.authors      = ['R. Bernstein']
+  s.date         = Time.now
+  s.description = <<-EOF
+A modular, testable, Ruby debugger using some of good ideas from
+ruby-debug, other debuggers, and Ruby Rails.
+
+Some of the core debugger concepts have been rethought. As a result,
+some of this may be experimental.
+
+This version works only on Rubinus 1.2.1 or higher.
+EOF
+  ## s.add_dependency('diff-lcs') # For testing only
+  s.authors       = ['R. Bernstein']
+  s.email         = 'rockyb@rubyforge.net'
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ 
+    |f| File.basename(f) }
+  s.files         = `git ls-files`.split("\n")
+  s.homepage      = 'http://wiki.github.com/rocky/rbx-trepanning'
+  s.name          = 'rbx-trepanning'
+  s.license       = 'MIT'
+  s.platform      = Gem::Platform::new ['universal', 'rubinius', '1.2']
+  s.require_paths = ['lib']
+  # s.required_ruby_version = '~> 1.8.7'
+  s.summary      = 'Trepan Ruby Debugger for Rubinius 1.2.4 and higher'
+  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.version      = Trepan::VERSION
+end

data/sample/.gitignore

@@ -0,0 +1,2 @@
+/*.rbc
+/*~

data/sample/list-terminal-colors.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+# Run this program in a terminal window to see a list of terminal colors
+# the assignments are the defaults as of Jan 18, 2011, but you may want to 
+# double check.
+require 'rubygems'
+require 'coderay'
+require 'term/ansicolor'
+
+      TOKEN_COLORS = {
+        :annotation => '35',
+        :attribute_name => '33',
+        :attribute_name_fat => '33',
+        :attribute_value => '31',
+        :attribute_value_fat => '31',
+        :bin => '1;35',
+        :char => {:self => '36', :delimiter => '34'},
+        :class => '1;35',
+        :class_variable => '36',
+        :color => '32',
+        :comment => '37',
+        :complex => '34',
+        :constant => ['34', '4'],
+        :decoration => '35',
+        :definition => '1;32',
+        :directive => ['32', '4'],
+        :doc => '46',
+        :doctype => '1;30',
+        :doc_string => ['31', '4'],
+        :entity => '33',
+        :error => ['1;33', '41'],
+        :exception => '1;31',
+        :float => '1;35',
+        :function => '1;34',
+        :global_variable => '42',
+        :hex => '1;36',
+        :important => '1;31',
+        :include => '33',
+        :integer => '1;34',
+        :interpreted => '1;35',
+        :key => '35',
+        :label => '1;4',
+        :local_variable => '33',
+        :oct => '1;35',
+        :operator_name => '1;29',
+        :pre_constant => '1;36',
+        :pre_type => '1;30',
+        :predefined => ['4', '1;34'],
+        :preprocessor => '36',
+        :pseudo_class => '34',
+        :regexp => {
+          :content => '31',
+          :delimiter => '1;29',
+          :modifier => '35',
+          :function => '1;29'
+        },
+        :reserved => '1;31',
+        :shell => {
+          :self => '42',
+          :content => '1;29',
+          :delimiter => '37',
+        },
+        :string => {
+          :self => '32',
+          :modifier => '1;32',
+          :escape => '1;36',
+          :delimiter => '1;32',
+        },
+        :symbol => '1;32',
+        :tag => '34',
+        :tag_fat => '1;34',
+        :tag_special => ['34', '4'],
+        :type => '1;34',
+        :value => '36',
+        :variable => '34',
+        :insert => '42',
+        :delete => '41',
+        :change => '44',
+        :head => '45',
+      }
+      TOKEN_COLORS[:keyword] = TOKEN_COLORS[:reserved]
+      TOKEN_COLORS[:method] = TOKEN_COLORS[:function]
+      TOKEN_COLORS[:imaginary] = TOKEN_COLORS[:complex]
+      TOKEN_COLORS[:open] = TOKEN_COLORS[:close] = TOKEN_COLORS[:nesting_delimiter] = TOKEN_COLORS[:escape] = TOKEN_COLORS[:delimiter]
+
+# require 'trepanning'; debugger
+%w(annotation
+   attribute_name
+   attribute_name_fat
+   attribute_value
+   attribute_value_fat
+   bin
+   class
+   class_variable
+   color
+   comment
+   complex
+   constant
+   decoration
+   definition
+   doc
+   doctype
+   entity
+   exception
+   float
+   function
+   global_variable
+   hex
+   important
+   include
+   integer
+   interpreted
+   key
+   label
+   local_variable
+   oct
+   operator_name
+   pre_constant
+   pre_type
+   predefined
+   preprocessor
+   pseudo_class
+   reserved
+   symbol
+   tag
+   tag_fat
+   type
+   value
+   variable
+   insert
+   delete
+   change
+   head
+).each do |name|
+     puts "\e[#{TOKEN_COLORS[name.to_sym]}m#{name} - #{TOKEN_COLORS[name.to_sym].inspect}\e[0m"
+end
+%w(bold italic underline).each do |name|
+     attrib=Term::ANSIColor.send(name)
+     puts "#{attrib}#{name} - #{attrib.inspect}\e[0m"
+end

data/sample/rocky-dot-trepanxrc

@@ -0,0 +1,14 @@
+# Rocky's trepanx profile for Rubinius.
+
+# Place where I have Rubinius source (in rvm)
+dir /home/rocky-rvm/.rvm/src/rbx-head/
+
+set autoeval on   # Is default, but just in case
+# set terminal on   # turn on syntax highlight by default
+
+# My customization to the default syntax coloring
+load "#{ENV['HOME']}/.trepanx-colors.rb"
+
+# let me know that this ran...
+puts "Rocky's .trepanxrc loaded"
+

data/sample/rocky-trepanx-colors.rb

@@ -0,0 +1,46 @@
+# Terminal color settings I use. I doubt terminal colors are
+# standardized let alone what colors you want for the various
+# syntax elements. So you should adjust as desired.
+
+# Values are either a number string, e.g. '36' or a pair of number
+# semicolon and number, e.g. '3;36'.
+#
+# The first number before a semicolon is a font modifier from the
+# following table:
+#
+#    1 - bold 
+#    3 - italic
+#    4 - underline 
+
+require 'rubygems'
+require 'coderay'
+TERM_TOKEN_COLORS = {
+  :comment => '3;37',        # sienna #8b4726
+  :constant => '1;34',       # Bold Midnight Blue #191970
+  :class => '1;2',           # 
+  :doctype => '1;2',         # 
+  :global_variable => '36',  # yellow brownish 
+  :integer => '29',          # black #00000
+  :label => '4',             # black underline
+  :method => '34',           # blue #0000FF 
+  :pre_constant => '3;33',   # goldenrod4 #8b6914
+  :regexp => {
+    :content => '36',        # dark cyan #008b8b
+    :delimiter => '1;29',    # bold black
+    :modifier => '35',
+    :function => '1;29'
+  },
+  :string => {
+    :content => '1;37',      # ivory4 (grey) #8b8b83
+    :delimiter => '1;29',    # bold black
+  },
+  :reserved => '1;32',       # bold dark olive green #556b2f RGB: 85, 107, 47
+  :symbol   => '35',         # purple4 #551A8B RGB: 85, 26, 139
+}
+module CodeRay::Encoders
+  class Terminal < Encoder
+    TERM_TOKEN_COLORS.each_pair do |key, value|
+      TOKEN_COLORS[key] = value
+    end
+  end
+end

data/test/data/.gitignore

@@ -0,0 +1 @@
+/*~

data/test/data/enable.right

@@ -0,0 +1,36 @@
+gcd.rb:4
+def gcd(a, b)
+# # ********************************************************
+# # This tests the enable command.
+# # ********************************************************
+# set debuggertesting on
+Currently testing the debugger is on.
+# set callstyle last
+Frame call-display style is last.
+# set autoeval off
+autoeval is off.
+# break Object.gcd
+Breakpoint 1 at Object::gcd
+# # Should have a breakpoint 1
+# enable br 1
+# # Get help on enable
+# help enable
+Enable some things.
+This is used to cancel the effect of the "disable" command.
+-- 
+List of enable subcommands:
+--  
+enable breakpoints -- Enable specified breakpoints
+enable display -- Enable some expressions to be displayed when program stops
+# # Get help on just enable break
+# help enable break
+Enable specified breakpoints.
+Give breakpoint numbers (separated by spaces) as arguments.
+This is used to cancel the effect of the "disable" command.
+# # Plain enable should work
+# enable
+*** "enable" must be followed "display", "breakpoints" or breakpoint numbers.
+# # An invalid enable command
+# enable foo
+Enable breakpoints argument 'foo' needs to be a number.
+# quit

data/test/data/fname-with-blank.cmd

@@ -0,0 +1,6 @@
+# *******************************************************************
+# Just to see that we can load a filename with an blank in it
+# *******************************************************************
+set basename off
+continue
+