rbx-trepanning 0.0.2-universal-rubinius-1.2

data/processor/command/list.rb

@@ -0,0 +1,296 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'require_relative'
+require 'linecache'
+require_relative 'base/cmd'
+
+class Trepan::Command::ListCommand < Trepan::Command
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME}[>] [FIRST [NUM]]
+#{NAME}[>] LOCATION [NUM]
+
+#{NAME} source code. 
+
+Without arguments, prints lines centered around the current
+line. If this is the first #{NAME} command issued since the debugger
+command loop was entered, then the current line is the current
+frame. If a subsequent #{NAME} command was issued with no intervening
+frame changing, then that is start the line after we last one
+previously shown.
+
+If the command has a '>' suffix, then line centering is disabled and
+listing begins at the specificed location.
+
+The number of line to show is controled by the debugger listsize
+setting. Use 'set listsize' or 'show listsize' to see or set the
+value.
+
+\"#{NAME} -\" shows lines before a previous listing. 
+
+A LOCATION is a either 
+  - number, e.g. 5, 
+  - a function, e.g. join or os.path.join
+  - a module, e.g. os or os.path
+  - a filename, colon, and a number, e.g. foo.rb:5,  
+  - or a module name and a number, e.g,. os.path:5.  
+  - a '.' for the current line number
+  - a '-' for the lines before the current line number
+
+If the location form is used with a subsequent parameter, the
+parameter is the starting line number.  When there two numbers are
+given, the last number value is treated as a stopping line unless it
+is less than the start line, in which case it is taken to mean the
+number of lines to list instead.
+
+Wherever a number is expected, it does not need to be a constant --
+just something that evaluates to a positive integer.
+
+Some examples:
+
+#{NAME} 5            # List centered around line 5
+#{NAME} 4+1          # Same as above.
+#{NAME} 5>           # List starting at line 5
+#{NAME} foo.rb:5     # List centered around line 5 of foo.rb
+#{NAME} foo.rb 5     # Same as above.
+#{NAME} foo.rb:5>    # List starting around line 5 of foo.rb
+#{NAME} foo.rb  5 6  # list lines 5 and 6 of foo.rb
+#{NAME} foo.rb  5 2  # Same as above, since 2 < 5.
+#{NAME} foo.rb:5 2   # Same as above
+#{NAME} FileUtils.cp # List lines around the FileUtils.cp function.
+#{NAME} .            # List lines centered from where we currently are stopped
+#{NAME} . 3          # List 3 lines starting from where we currently are stopped
+                     # if . > 3. Otherwise we list from . to 3.
+#{NAME} -            # List lines previous to those just shown
+
+    HELP
+
+    ALIASES       = %W(l #{NAME}> l>)
+    CATEGORY      = 'files'
+    MAX_ARGS      = 3
+    SHORT_HELP    = 'List source code'
+  end
+
+  # If last is less than first, assume last is a count rather than an
+  # end line number.
+  def adjust_last(first, last)
+    last < first ? first + last - 1 : last
+  end
+
+  # What a f*cking mess. Necessitated I suppose because we want to 
+  # allow somewhat flexible parsing with either module names, files or none
+  # and optional line counts or end-line numbers.
+  
+  # Parses arguments for the "list" command and returns the tuple:
+  # filename, start, last
+  # or sets these to nil if there was some problem.
+  def parse_list_cmd(args, listsize, center_correction)
+    
+    last = nil
+    
+    if args.size > 0
+      if args[0] == '-'
+        return no_frame_msg unless @proc.line_no
+        first = [1, @proc.line_no - 2*listsize - 1].max
+        file  = @proc.frame.file
+      elsif args[0] == '.'
+        return no_frame_msg unless @proc.line_no
+        if args.size == 2
+          opts = {
+            :msg_on_error => 
+            "#{NAME} command last or count parameter expected, " +
+            'got: %s.' % args[2]
+          }
+          second = @proc.get_an_int(args[1], opts)
+          return nil, nil, nil unless second
+          first = @proc.frame.line 
+          last = adjust_last(first, second)
+        else
+          first = [1, @proc.frame.line - center_correction].max
+        end
+
+        file  = @proc.frame.file
+      else
+        modfunc, file, first = @proc.parse_position(args[0])
+        if first == nil and modfunc == nil
+          # error should have been shown previously
+          return nil, nil, nil
+        end
+        if args.size == 1
+          first = 1 if !first and modfunc
+          first = [1, first - center_correction].max
+        elsif args.size == 2 or (args.size == 3 and modfunc)
+          opts = {
+            :msg_on_error => 
+            "#{NAME} command starting line expected, got %s." % args[-1]
+          }
+          last = @proc.get_an_int(args[1], opts)
+          return nil, nil, nil unless last
+          if modfunc
+            if first
+              first = last
+              if args.size == 3 and modfunc
+                opts[:msg_on_error] = 
+                  ("#{NAME} command last or count parameter expected, " +
+                   'got: %s.' % args[2])
+                last = @proc.get_an_int(args[2], opts)
+                return nil, nil, nil unless last
+              end
+            end
+          end
+          last = adjust_last(first, last)
+        elsif not modfunc
+          errmsg('At most 2 parameters allowed when no module' +
+                  ' name is found/given. Saw: %d parameters' % args.size)
+          return nil, nil, nil
+        else
+          errmsg(('At most 3 parameters allowed when a module' +
+                  ' name is given. Saw: %d parameters') % args.size)
+          return nil, nil, nil
+        end
+      end
+    elsif !@proc.line_no and @proc.frame
+      first = [1, @proc.frame.line - center_correction].max
+      file  = @proc.frame.file
+    else
+      first = [1, @proc.line_no - center_correction].max 
+      file  = @proc.frame.file
+    end
+    last = first + listsize - 1 unless last
+
+    if @proc.frame.eval?
+      script = @proc.frame.vm_location.static_scope.script 
+      LineCache::cache(script)
+    else
+      LineCache::cache(file)
+      script = nil
+    end
+    return file, script, first, last
+  end
+
+  def no_frame_msg
+    errmsg("No Ruby program loaded.")
+    return nil, nil, nil
+  end
+    
+  def run(args)
+    listsize = settings[:maxlist]
+    center_correction = 
+      if args[0][-1..-1] == '>'
+        0
+      else
+        (listsize-1) / 2
+      end
+
+    file, script, first, last = 
+      parse_list_cmd(args[1..-1], listsize, center_correction)
+    frame = @proc.frame
+    return unless file
+
+    cached_item = script || file
+
+    # We now have range information. Do the listing.
+    max_line = LineCache::size(cached_item)
+
+    # FIXME: join with line_at of location.rb
+    unless max_line && file
+      # Try using search directories (set with command "directory")
+      if file[0..0] != File::SEPARATOR
+        try_filename = @proc.resolve_file_with_dir(file) 
+        if try_filename && 
+            max_line = LineCache::size(try_filename)
+          LineCache::remap_file(file, try_filename)
+        end
+      end
+    end
+
+    unless max_line 
+      errmsg('File "%s" not found.' % file)
+      return
+    end
+
+    if first > max_line
+      errmsg('Bad line range [%d...%d]; file "%s" has only %d lines' %
+             [first, last, file, max_line])
+      return
+    end
+
+    if last > max_line
+      # msg('End position changed to last line %d ' % max_line)
+      last = max_line
+    end
+
+    begin
+      first.upto(last).each do |lineno|
+        line = LineCache::getline(cached_item, lineno,
+                                  @proc.reload_on_change)
+        unless line
+          msg('[EOF]')
+          break
+        end
+        line.chomp!
+        s = '%3d' % lineno
+        s = s + ' ' if s.size < 4 
+        s += (@proc.frame && lineno == @proc.frame.vm_location.line) ? '->' : '  '
+        # && container == frame.source_container) 
+        msg(s + "\t" + line)
+        @proc.line_no = lineno
+      end
+    rescue => e
+      errmsg e.to_s if settings[:debugexcept]
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../location'
+  require_relative '../mock'
+  require_relative '../frame'
+  dbgr, cmd = MockDebugger::setup
+  cmd.proc.send('frame_initialize')
+  LineCache::cache(__FILE__)
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, __FILE__ + ':10'])
+  
+  def run_cmd(cmd, args)
+    seps = '--' * 10
+    puts "%s %s %s" % [seps, args.join(' '), seps]
+    cmd.run(args)
+  end
+  
+  
+  load 'tmpdir.rb'
+  run_cmd(cmd, %W(#{cmd.name} tmpdir.rb 10))
+  run_cmd(cmd, %W(#{cmd.name} tmpdir.rb))
+  
+  run_cmd(cmd, %W(cmd.name .))
+  run_cmd(cmd, %W(cmd.name 30))
+  
+  # cmd.run(['list', '9+1'])
+  
+  run_cmd(cmd, %W(cmd.name> 10))
+  run_cmd(cmd, %W(cmd.name 3000))
+  run_cmd(cmd, %W(cmd.name run_cmd))
+  
+  p = Proc.new do 
+    |x,y| x + y
+  end
+  run_cmd(cmd, %W(#{cmd.name} p))
+  
+  # Function from a file found via an instruction sequence
+  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize))
+  
+  # Use Class/method name. 15 isn't in the function - should this be okay?
+  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 15))
+  
+  # Start line and count, since 3 < 30
+  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 30 3))
+  
+  # Start line finish line 
+  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 40 50))
+
+  # Method name
+  run_cmd(cmd, %W(#{cmd.name} cmd.run))
+end

data/processor/command/next.rb

@@ -0,0 +1,66 @@
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../stepping'
+require_relative '../../app/breakpoint'
+
+class Trepan::Command::NextCommand < Trepan::Command
+
+  ALIASES      = %w(n)
+  CATEGORY     = 'running'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP= <<-HELP
+#{NAME} [NUM]
+
+Attempt to continue execution and stop at the next line. If there is
+a conditional branch between the current position and the next line,
+execution is stopped within the conditional branch instead.
+
+The optional argument is a number which specifies how many lines to
+attempt to skip past before stopping execution.
+
+If the current line is the last in a method, execution is stopped
+at the current position of the caller.
+
+See also 'step' and 'nexti'.
+      HELP
+  NEED_RUNNING = true
+  SHORT_HELP   =  'Move to the next line or conditional branch'
+
+  def run(args)
+    if args.size == 1
+      step_count = 1
+    else
+      step_str = args[1]
+      opts = {
+        :msg_on_error => 
+        "The #{NAME} command argument must eval to an integer. Got: %s" % 
+        step_str,
+        :min_value => 1
+      }
+      step_count = @proc.get_an_int(step_str, opts)
+      return unless step_count
+    end
+
+    @proc.step('next', step_count)
+  end
+  
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  # [%w(n 5), %w(next 1+2), %w(n foo)].each do |c|
+  #   dbgr.core.step_count = 0
+  #   cmd.proc.leave_cmd_loop = false
+  #   result = cmd.run(c)
+  #   puts 'Run result: %s' % result
+  #   puts 'step_count %d, leave_cmd_loop: %s' % [dbgr.core.step_count,
+  #                                               cmd.proc.leave_cmd_loop]
+  # end
+  # [%w(n), %w(next+), %w(n-)].each do |c|
+  #   dbgr.core.step_count = 0
+  #   cmd.proc.leave_cmd_loop = false
+  #   result = cmd.run(c)
+  #   puts cmd.proc.different_pos
+  # end
+end

data/processor/command/nexti.rb

@@ -0,0 +1,59 @@
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../stepping'
+require_relative '../../app/breakpoint'
+require_relative '../../app/iseq'
+
+class Trepan::Command::NextInstructionCommand < Trepan::Command
+  ALIASES      = %w(ni)
+  CATEGORY     = 'running'
+  HELP         = <<-HELP
+Continue but stop execution at the next bytecode instruction.
+
+Does not step into send instructions.
+
+See also 'continue', 'step', and 'next' commands.
+      HELP
+  NAME         = File.basename(__FILE__, '.rb')
+  NEED_STACK   = true
+  SHORT_HELP   = 'Move to the next bytecode instruction'
+  
+  def run(args)
+    if args.size == 1
+      step = 1
+    else
+      step_str = args[1]
+      opts = {
+        :msg_on_error => 
+        "The 'next' command argument must eval to an integer. Got: %s" % 
+        step_str,
+        :min_value => 1
+      }
+      step = @proc.get_an_int(step_str, opts)
+      return unless step
+    end
+    
+    exec = current_method
+    insn = Rubinius::InstructionSet[exec.iseq[@proc.frame.next_ip]]
+    
+    next_ip = @proc.frame.next_ip + insn.width
+    
+    if next_ip >= exec.iseq.size
+      @proc.step_to_parent
+    elsif Trepanning::ISeq.goto_op?(exec, @proc.frame.next_ip)
+      @proc.set_breakpoints_between(exec, @proc.frame.next_ip, next_ip)
+    else
+      line = exec.line_from_ip(next_ip)
+      
+      bp = Trepanning::Breakpoint.for_ip(exec, next_ip, :event => 'vm-insn')
+      bp.scoped!(@proc.frame.scope)
+      bp.activate
+    end
+    @proc.continue('nexti')
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+end

data/processor/command/pr.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../eval'
+class Trepan::Command::PrCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = 
+      "#{NAME} EXPRESSION
+
+Print the value of the EXPRESSION. Variables accessible are those of the
+environment of the selected stack frame, plus globals. 
+
+If the length output string large, the first part of the value is
+shown and ... indicates it has been truncated.
+
+See 'set max string' to change the string truncation limit.
+"
+
+    # ALIASES       = %w(p)
+    CATEGORY      = 'data'
+    SHORT_HELP    = 'print expression truncating long output'
+  end
+  
+  def run(args)
+    msg @proc.debug_eval(@proc.cmd_argstr, @proc.settings[:maxstring])
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  arg_str = '1 + 2'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([cmd.name, arg_str])
+end

data/processor/command/ps.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../eval'
+class Trepan::Command::PsCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+      "ps ARRAY
+
+Print the value of the ARRAY in columns and sorted."
+
+    CATEGORY      = 'data'
+    MIN_ARGS      = 1  # Need least this many
+    NAME          = File.basename(__FILE__, '.rb')
+    SHORT_HELP    = 'Print array sorted and in columns'
+  end
+  
+  def run(args)
+    array = @proc.debug_eval(@proc.cmd_argstr, @proc.settings[:maxstring])
+    # FIXME: should test for enumerable
+    if array.is_a?(Array)
+      msg columnize_commands(array.sort)
+    else
+      errmsg "ps: #{@proc.cmd_argstr} should evaluate an Array not #{array.class}"
+    end
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  arg_str = '(1..30).to_a'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([cmd.name, arg_str])
+  arg_str = '1'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  cmd.run([cmd.name, arg_str])
+end

data/processor/command/restart.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../../app/run'
+class Trepan::Command::RestartCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME         = File.basename(__FILE__, '.rb')
+    ALIASES      = %w(R run)
+    HELP = <<-HELP
+#{NAME} 
+
+Restart debugger and program via an exec call. All state is lost, and
+new copy of the debugger is used.
+    HELP
+    
+    CATEGORY     = 'running'
+    MAX_ARGS     = 0  # Need at most this many
+    SHORT_HELP  = '(Hard) restart of program via exec()'
+  end
+    
+  # This method runs the command
+  def run(args)
+
+    dbgr = @proc.dbgr
+    argv = dbgr.restart_argv
+    if argv and argv.size > 0
+      # unless File.executable?(argv[0])
+      #   msg(["File #{argv[0]} not executable.",
+      #        "Adding Ruby interpreter."])
+      #   argv.unshift Trepanning::ruby_path
+      # end
+      @proc.run_cmd(%w(show args))
+      if not confirm('Restart (exec)?', false)
+        msg "Restart not confirmed"
+      else
+        msg 'Restarting...'
+        @proc.run_cmd(%w(save))
+        # FIXME: Run atexit finalize routines?
+        Dir.chdir(Rubinius::OS_STARTUP_DIR)
+        exec(*argv)
+      end
+    else
+      errmsg("No executable file and command options recorded.")
+    end
+  end
+end
+
+if __FILE__ == $0
+  exit if ARGV[-1] == 'exit'
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  dbgr.restart_argv = []
+  cmd.run([cmd.name])
+  dbgr.restart_argv = Rubinius::OS_ARGV + ['exit']
+  # require_relative '../../debugger'
+  # Trepan.start
+  cmd.run([cmd.name])
+end

data/processor/command/set.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/submgr'
+
+class Trepan::Command::SetCommand < Trepan::SubcommandMgr
+  unless defined?(HELP)
+    HELP =
+'Modifies parts of the debugger environment.
+
+You can give unique prefix of the name of a subcommand to get
+information about just that subcommand.
+
+Type "set" for a list of "set" subcommands and what they do.
+Type "help set *" for just the list of "set" subcommands.
+
+For compatability with older ruby-debug "set auto..." is the
+same as "set auto ...". For example "set autolist" is the same 
+as "set auto list".
+'
+
+    CATEGORY      = 'support'
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = false
+    SHORT_HELP    = 'Modify parts of the debugger environment'
+  end
+
+  def run(args)
+    if args.size > 1 
+      first = args[1].downcase
+      alen = 'auto'.size
+      args[1..1] = ['auto', first[alen..-1]] if
+        first.start_with?('auto') && first.size > alen
+    end
+    super
+  end
+
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, 'autolist'])
+  cmd.run([cmd.name, 'autoeval', 'off'])
+  cmd.run([cmd.name, 'basename'])
+end

data/processor/command/set_subcmd/auto.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subsubcmd'
+require_relative '../base/subsubmgr'
+
+class Trepan::SubSubcommand::SetAuto < Trepan::SubSubcommandMgr
+  unless defined?(HELP)
+    HELP   = 'Set controls for things with some sort of "automatic" default behavior'
+    NAME   = File.basename(__FILE__, '.rb')
+    PREFIX = %W(set #{NAME})
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../../mock'
+  dbgr, cmd = MockDebugger::setup('set')
+  # cmds = dbgr.core.processor.commands
+  # set_cmd = cmds['set']
+  # command = Trepan::SubSubcommand::SetAuto.new(dbgr.core.processor, 
+  #                                              set_cmd)
+  # name = File.basename(__FILE__, '.rb')
+  # cmd_args = ['set', name]
+  # set_cmd.instance_variable_set('@last_args', cmd_args)
+  # # require_relative '../../../lib/trepanning'
+  # # Trepan.debug(:set_restart => true)
+  # command.run(cmd_args)
+end

data/processor/command/set_subcmd/auto_subcmd/dis.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../../base/subsubcmd'
+
+class Trepan::Subcommand::SetAutoDis < Trepan::SetBoolSubSubcommand
+  unless defined?(HELP)
+    HELP = "Set to run a 'disassemble' command each time we enter the debugger"
+    MIN_ABBREV = 'd'.size
+    NAME       = File.basename(__FILE__, '.rb')
+    PREFIX     = %W(set auto #{NAME})
+    SHORT_HELP = "Set running a 'disassemble' command each time we enter the debugger"
+  end
+
+  def run(args)
+    super
+    if @proc.settings[:autodis]
+      @proc.cmdloop_prehooks.insert_if_new(10, *@proc.autodis_hook)
+    else
+      @proc.cmdloop_prehooks.delete_by_name('autodis')
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../../mock'
+  require_relative '../auto'
+  cmd = MockDebugger::subsub_setup(Trepan::SubSubcommand::SetAuto,
+                                   Trepan::SubSubcommand::SetAutoDis)
+  cmd.run([cmd.name, 'off'])
+end