rbx-trepanning 0.0.5-universal-rubinius-1.2.1

data/processor/command/macro.rb

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../eval'
+class Trepan::Command::MacroCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME          = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} MACRO-NAME PROC-OBJECT
+
+Define MACRO-NAME as a debugger macro. Debugger macros get a list of
+arguments and should return either a String or an Array of Strings to
+use in its place.  If the return is a String, that gets tokenized by a
+simple String#split .  Note that macro processing is done right after
+splitting on ;; so if the macro returns a string containing ;; those
+won't be handled on the first string returned.
+
+If instead, Array of Strings is returned, then the first string is
+unshifted from the array and executed. The remaning strings are pushed
+onto the command queue. In contrast to the first string, subsequent
+strings which contain other macros or ;; splitting will be acted upon.
+
+Here is an example. The below creates a macro called finish+ which
+issues two commands 'finish' followed by 'step':
+
+  macro fin+ Proc.new{|*args| %w(finish step)}
+
+Here is another example using arguments. I use the following to debug
+a debugger command:
+
+  macro dbgcmd Proc.new{|*args| ["set debug dbgr", "debug $trepan_cmdproc.commands['\#{args[0]}'].run(\#{args.inspect})"]}
+
+With the above, 'dbgcmd list 5' will ultimately expand to: 
+  set debug dbgr
+  debug $trepan_cmdproc.commands['list'].run(['5'])
+
+and will debug the debugger's 'list' command on the command 'list 5'.
+
+See also 'show macro'.
+    HELP
+
+    CATEGORY      = 'support'
+    MIN_ARGS      = 2  # Need at least this many
+    SHORT_HELP    = 'Define a macro'
+  end
+  
+  def run(args)
+    macro_name = args[1]
+    proc_argstr = @proc.cmd_argstr[macro_name.size..-1].lstrip
+    proc_obj = @proc.debug_eval(proc_argstr, @proc.settings[:maxstring])
+    if proc_obj
+      if proc_obj.is_a?(Proc)
+        @proc.macros[macro_name] = proc_obj
+        msg "Macro \"#{macro_name}\" defined."
+      else
+        errmsg "Expecting a Proc object; got: #{proc_argstr}"
+      end
+    end
+  end
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmdproc = cmd.proc
+  ["#{cmd.name} foo Proc.new{|x, y| 'x+y'}",
+   "#{cmd.name} bad2 1+2"].each do |cmdline|
+    args = cmdline.split
+    cmd_argstr = cmdline[args[0].size..-1].lstrip
+    cmdproc.instance_variable_set('@cmd_argstr', cmd_argstr)
+    cmd.run(args)
+  end
+  p cmdproc.macros
+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 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 = 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, 2011 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, 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, 2011 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, 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/server.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'optparse'
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../../app/default'
+require_relative '../../interface/server'   # server interface (remote debugging)
+class Trepan::Command::ServerCommand < Trepan::Command
+  include Trepanning
+
+  unless defined?(HELP)
+    CATEGORY     = 'support'
+    DEFAULT_OPTIONS = {
+      :host => Trepan::DEFAULT_SETTINGS[:host],
+      :port => Trepan::DEFAULT_SETTINGS[:port]
+    }
+    MAX_ARGS     = 4  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [{--port|-p} NUM] [{--host|-h} HOST-OR-IP]
+
+Put session into server mode which allows an out-of-process or remote
+connection to the debugged program. --port and --host can be supplied
+to specify the port number to use and the host name for TCP
+connections. If neither is given, the default host (#{Trepan::DEFAULT_SETTINGS[:host]}) 
+and the default port (#{Trepan::DEFAULT_SETTINGS[:port]}) are used.
+
+Examples:
+   #{NAME} # Accept remote connections using defaults
+   #{NAME} --port 123 # Accept remote connections on port 123
+   #{NAME} --host my.host.net --port 2048
+   #{NAME} -h my.host.net -p 2048 # same as above
+      HELP
+
+    SHORT_HELP  = 'Go into out-of-process debugging (server) mode'
+
+  end
+    
+  def parse_options(options, args) # nodoc
+    parser = OptionParser.new do |opts|
+      opts.on("-h", "--host NAME", String, 
+              "Host or IP used in TCP connections for --server or --client. " + 
+              "Default is #{DEFAULT_SETTINGS[:host].inspect}.") do 
+        |name_or_ip| 
+        options[:host] = name_or_ip
+      end
+      opts.on("-p", "--port NUMBER", Integer, 
+              "Port number used in TCP connections for --server or --client. " + 
+              "Default is #{DEFAULT_SETTINGS[:port]}.") do 
+        |num| 
+        options[:port] = num
+      end
+    end
+    parser.parse(args)
+    return options
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    options = parse_options(DEFAULT_OPTIONS.dup, args[1..-1])
+    msg("starting debugger in out-of-process mode on host #{options[:host].inspect}, " +
+        "port: #{options[:port]}")
+    @proc.dbgr.intf << Trepan::ServerInterface.new(nil, nil, options)
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  # cmd.run([cmd.name])
+  # cmd.run([cmd.name, '--server'])
+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