rbx-trepanning 0.0.5-universal-rubinius-1.2.1

data/processor/command/info_subcmd/program.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoProgram < Trepan::Subcommand
+  unless defined?(HELP)
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = 'Information about debugged program and its environment'
+    MIN_ABBREV   = 'pr'.size
+    NEED_STACK   = true
+   end
+
+  def run(args)
+    frame = @proc.frame
+    ## m = 'Program stop event: %s' % @proc.core.event
+    m = ''
+    m += "Frame index #{@proc.frame_index}, " if @proc.frame_index != 0
+    m += 
+      if frame.method
+        "PC offset %d of method: %s" %
+          [frame.next_ip, frame.method.name]
+      else
+        ## '.'
+      end
+    msg m
+    # if 'return' == @proc.core.event 
+    #   msg 'R=> %s' % @proc.frame.sp(1).inspect 
+    # elsif 'raise' == @proc.core.event
+    #   msg @proc.core.hook_arg.inspect if @proc.core.hook_arg
+    # end
+
+    if @proc.brkpt && @proc.brkpt.event == :Breakpoint
+      msg('It stopped at %sbreakpoint %d.' %
+          [@proc.brkpt.temp? ? 'temporary ' : '',
+           @proc.brkpt.id])
+    else
+      msg("Program stopped at a #{@proc.event} event.")
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  cmd = MockDebugger::sub_setup(Trepan::Subcommand::InfoProgram, false)
+  cmd.run(cmd.prefix)
+end

data/processor/command/info_subcmd/ruby.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoRuby < Trepan::Subcommand
+  unless defined?(HELP)
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = <<-EOH
+#{CMD=PREFIX.join(' ')} [-v|--verbose|-no-verbose]
+
+Show Ruby version information such as you'd get from 
+"rbx -v" (which is really just the value of RUBY_RELEASE_DATE),
+or from "rbx -vv". 
+
+See also constants: RUBY_DESCRIPITON, RUBY_VERSION, and RUBY_RELEASE_DATE."
+    EOH
+    MIN_ABBREV   = 'ru'.size
+    NEED_STACK   = false
+    SHORT_HELP   = 'Ruby version information'
+   end
+
+  def parse_options(args) # :nodoc
+    options = {}
+    parser = OptionParser.new do |opts|
+      opts.on("-v", 
+              "--[no-]verbose", "show additional version information") do
+        |v| 
+        options[:verbose] = v
+      end
+    end
+    parser.parse(args)
+    return options
+  end
+
+  def run(args)
+    options = parse_options(args[2..-1])
+    msg RUBY_DESCRIPTION
+    if options[:verbose]
+      msg "Options:"
+      msg "  Interpreter type: #{Rubinius::INTERPRETER}"
+      if jit = Rubinius::JIT
+        msg "  JIT enabled: #{jit.join(', ')}"
+      else
+        msg "  JIT disabled"
+      end
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  $0 = __FILE__ + 'notagain' # So we don't run this again
+  require_relative '../../mock'
+  cmd = MockDebugger::sub_setup(Trepan::Subcommand::InfoRuby, false)
+  cmd.run(cmd.prefix)
+  %w(-v --verbose --no-verbose).each do |opt|
+    puts '-' * 10 + " #{opt}"
+    cmd.run(cmd.prefix + [opt])
+  end
+end

data/processor/command/info_subcmd/variables.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Command::InfoVariables < Trepan::Subcommand
+  Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+  MIN_ABBREV   = 'var'.size
+  NEED_STACK   = true
+  SHORT_HELP   = 'Display the value of a variable or variables'
+  HELP         = <<-HELP
+Show debugger variables and user created variables. By default,
+shows all variables.
+
+The optional argument is which variable specifically to show the value of.
+      HELP
+  
+  def run(args)
+    if args.size == 2
+      @proc.dbgr.variables.each do |name, val|
+        msg "var '#{name}' = #{val.inspect}"
+      end
+      
+      if @proc.dbgr.user_variables > 0
+        section "User variables"
+        (0...@proc.dbgr.user_variables).each do |i|
+          str = "$d#{i}"
+          val = Rubinius::Globals[str.to_sym]
+          msg "var #{str} = #{val.inspect}"
+        end
+      end
+    else
+      var = args[2]
+      if @proc.dbgr.variables.key?(var)
+        msg "var '#{var}' = #{variables[var].inspect}"
+      else
+        errmsg "No variable set named '#{var}'"
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  cmd = MockDebugger::sub_setup(Trepan::Subcommand::InfoVariables, false)
+  # cmd.run(cmd.prefix)
+end

data/processor/command/irb.rb

@@ -0,0 +1,128 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'irb'
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../../app/irb'
+class Trepan::Command::IRBCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP 
+#{NAME} [-d]\tstarts an Interactive Ruby (IRB) session.
+
+If -d is added you can get access to debugger frame the global variables
+$trepanx_frame and $trepanx_cmdproc. 
+
+#{NAME} is extended with methods 'cont', 'ne', and, 'q', 'step' which 
+run the corresponding debugger commands 'continue', 'next', 'exit' and 'step'. 
+
+To issue a debugger command, inside #{NAME} nested inside a debugger use
+'dbgr'. For example:
+
+  dbgr %w(info program)
+  dbgr('info', 'program') # Same as above
+  dbgr 'info program'     # Single quoted string also works
+
+But arguments have to be quoted because #{NAME} will evaluate them:
+
+  dbgr info program     # wrong!
+  dbgr info, program    # wrong!
+  dbgr(info, program)   # What I say 3 times is wrong!
+
+Here then is a loop to query VM stack values:
+  (-1..1).each {|i| dbgr(\"info reg sp \#{i}\")}
+     HELP
+
+    CATEGORY     = 'support'
+    MAX_ARGS     = 1  # Need at most this many
+    SHORT_HELP  = "Run #{NAME} as a command subshell"
+  end
+
+  # This method runs the command
+  def run(args)
+    add_debugging = 
+      if args.size > 1
+        '-d' == args[1]
+      else
+        false
+      end
+
+    # unless @state.interface.kind_of?(LocalInterface)
+    #   print "Command is available only in local mode.\n"
+    #   throw :debug_error
+    # end
+
+    save_trap = trap('SIGINT') do
+      throw :IRB_EXIT, :cont if $trepanx_in_irb
+    end
+
+    $trepanx = @proc.dbgr 
+    if add_debugging
+      $trepanx_cmdproc  = @proc
+      $trepanx_frame    = @proc.frame
+    end
+    $trepanx_in_irb = true
+    $trepanx_irb_statements = nil
+    $trepanx_command = nil
+
+    conf = {:BACK_TRACE_LIMIT => settings[:maxstack],
+            :RC => true}
+
+    # ?? Should we set GNU readline to what we have,
+    # or let IRB make its own determination? 
+
+    # Save the Readline history and set the Readline completion function 
+    # to be IRB's function 
+    if Trepan::GNU_readline? 
+      @proc.intf.save_history if @proc.intf.respond_to?(:save_history)
+      require 'irb/completion'
+      Readline.completion_proc = IRB::InputCompletor::CompletionProc
+    end
+
+    # And just when you thought, we'd never get around to 
+    # actually running irb...
+    cont = IRB.start_session(@proc.frame.binding, @proc, conf)
+    trap('SIGINT', save_trap) # Restore our old interrupt function.
+
+    # Restore the debuggers' Readline history and the Readline completion 
+    # function
+    if Trepan::GNU_readline? && @proc.dbgr.completion_proc
+      @proc.intf.read_history if @proc.intf.respond_to?(:read_history)
+      Readline.completion_proc = @proc.dbgr.completion_proc 
+    end
+
+    # Respect any backtrace limit set in irb.
+    back_trace_limit = IRB.CurrentContext.back_trace_limit
+    if settings[:maxstack] !=  back_trace_limit
+      msg("\nSetting debugger's BACK_TRACE_LIMIT (%d) to match irb's last setting (%d)" % 
+          [settings[:maxstack], back_trace_limit])
+      settings[:maxstack]= IRB.CurrentContext.back_trace_limit
+    end
+
+    case cont
+    when :continue
+      @proc.continue
+    when :finish
+      @proc.finish 
+    when :next
+      @proc.next # (1, {})
+    when :quit
+      @proc.quit
+    when :step
+      @proc.step # (1, {})
+    else
+      @proc.print_location
+    end
+  ensure
+    $trepanx_in_irb = false
+    # restore old trap if any
+    trap('SIGINT', save_trap) if save_trap
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  # Get an IRB session -- the hard way :-)
+  cmd.run([cmd.name]) if ARGV.size > 0
+end

data/processor/command/kill.rb

@@ -0,0 +1,70 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+class Trepan::Command::KillCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [signal-number|signal-name|unconditionally]
+
+Kill execution of program being debugged.
+
+Equivalent of Process.kill('KILL', Process.pid). This is an unmaskable
+signal. When all else fails, e.g. in thread code, use this.
+
+If 'unconditionally' is given, no questions are asked. Otherwise, if
+we are in interactive mode, we'll prompt to make sure.
+
+Examples:
+
+  #{NAME}  
+  #{NAME} unconditionally
+  #{NAME} KILL # same as above
+  #{NAME} kill # same as above
+  #{NAME} -9   # same as above
+  #{NAME} 9    # same as above
+    HELP
+
+    CATEGORY     = 'running'
+    MAX_ARGS     = 1  # Need at most this many
+    SHORT_HELP  = 'Send this process a POSIX signal (default "9" is "kill -9")'
+  end
+    
+  # This method runs the command
+  def run(args) # :nodoc
+    if args.size > 1
+      sig = Integer(args[1]) rescue args[1]
+      unless sig.is_a?(Integer) || Signal.list.member?(sig.upcase)
+        errmsg("Signal name '#{sig}' is not a signal I know about.\n")
+        return false
+      end
+#       FIXME: reinstate
+#       if 'KILL' == sig || Signal['KILL'] == sig
+#           @proc.intf.finalize
+#       end
+    else
+      if not confirm('Really kill?', false)
+        msg('Kill not confirmed.')
+        return
+      else 
+        sig = 'KILL'
+      end
+    end
+    begin
+      Process.kill(sig, Process.pid)
+    rescue Errno::ESRCH
+      errmsg "Unable to send kill #{sig} to process #{Process.pid}"
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  %w(fooo 1 -1 HUP -9).each do |arg| 
+    puts "#{cmd.name} #{arg}"
+    cmd.run([cmd.name, arg])
+    puts '=' * 40
+  end
+end

data/processor/command/list.rb

@@ -0,0 +1,300 @@
+# Copyright (C) 2010, 2011 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 lines to show is controlled by the debugger "list size"
+setting. Use 'set max list' or 'show max list' 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
+      opts = {
+        :reload_on_change => @proc.reload_on_change,
+        :output => settings[:highlight]
+      }
+      first.upto(last).each do |lineno|
+        line = LineCache::getline(cached_item, lineno, opts)
+        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, {:unlimited => true})
+        @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__)
+  require 'trepanning'
+  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