rbx-trepanning 0.0.1-universal-rubinius

data/processor/command/info_subcmd/breakpoints.rb

@@ -0,0 +1,75 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoBreakpoints < Trepan::Subcommand
+    HELP         = <<-EOH
+info breakpoints [num1 ...] [verbose]
+
+Show status of user-settable breakpoints. If no breakpoint numbers are
+given, the show all breakpoints. Otherwise only those breakpoints
+listed are shown and the order given. If VERBOSE is given, more
+information provided about each breakpoint.
+
+The "Disp" column contains one of "keep", "del", the disposition of
+the breakpoint after it gets hit.
+
+The "enb" column indicates whether the breakpoint is enabled.
+
+The "Where" column indicates where the breakpoint is located.
+EOH
+  MIN_ABBREV   = 'br'.size
+  NAME         = File.basename(__FILE__, '.rb')
+  PREFIX       = %w(info breakpoints)
+  SHORT_HELP   = 'Status of user-settable breakpoints'
+  
+  def run(args)
+    # FIXME: Originally was 
+    #   section "Breakpoints"
+    # Add section? 
+
+    show_all = 
+      if args.size > 2
+        opts = {
+        :msg_on_error => 
+        "An '#{PREFIX.join(' ')}' argument must eval to a breakpoint between 1..#{@proc.brkpts.max}.",
+        :min_value => 1,
+        :max_value => @proc.brkpts.max
+      }
+        bp_nums = @proc.get_int_list(args[2..-1])
+        false
+      else
+        true
+      end
+
+    bpmgr = @proc.brkpts
+    if bpmgr.empty? && @proc.dbgr.deferred_breakpoints.empty?
+      msg('No breakpoints.')
+    else
+      # There's at least one
+      bpmgr.list.each do |bp|
+        msg "%3d: %s" % [bp.id, bp.describe]
+      end
+      msg('Deferred breakpoints...')
+      @proc.dbgr.deferred_breakpoints.each_with_index do |bp, i|
+        if bp
+          msg "%3d: %s" % [i+1, bp.describe]
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup('info')
+  subcommand = Trepan::Subcommand::InfoBreakpoints.new(cmd)
+
+  puts '-' * 20
+  subcommand.run(%w(info break))
+  puts '-' * 20
+  subcommand.summary_help(name)
+  puts
+  puts '-' * 20
+end

data/processor/command/info_subcmd/file.rb

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require 'linecache'
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoFile < Trepan::Subcommand
+  unless defined?(HELP)
+    DEFAULT_FILE_ARGS = %w(size sha1)
+
+    HELP =
+"info file [{FILENAME|.} [all | brkpts | sha1 | size | stat]]
+
+Show information about the current file. If no filename is given and
+the program is running then the current file associated with the
+current stack entry is used. Sub options which can be shown about a file are:
+
+brkpts -- Line numbers where there are statement boundaries. 
+          These lines can be used in breakpoint commands.
+sha1   -- A SHA1 hash of the source text. This may be useful in comparing
+          source code.
+size   -- The number of lines in the file.
+stat   -- File.stat information
+
+all    -- All of the above information.
+
+If no sub-options are given #{DEFAULT_FILE_ARGS.join(' ')} are assumed.
+"
+    MIN_ABBREV   = 'fi'.size  # Note we have "info frame"
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = false
+    PREFIX       = %w(info file)
+  end
+  
+  # Get file information
+  def run(args)
+    return if args.size < 2
+    args << '.' if 2 == args.size 
+    filename = 
+      if '.' == args[2]
+        if not @proc.frame
+          errmsg("No frame - no default file.")
+          return false
+          nil
+        else
+          File.expand_path(@proc.frame.file)
+        end
+      else
+        args[2]
+      end
+    args += DEFAULT_FILE_ARGS if args.size == 3
+
+    m = filename + ' is'
+    canonic_name = LineCache::map_file(filename)
+    if LineCache::cached?(canonic_name)
+      m += " cached in debugger"
+      if canonic_name != filename
+        m += (' as:' + canonic_name)
+      end
+      m += '.'
+      msg(m)
+    # elsif !(matches = find_scripts(filename)).empty?
+    #   if (matches.size > 1)
+    #     msg("Multiple files found:")
+    #     matches.each { |filename| msg("\t%s" % filename) }
+    #     return
+    #   else
+    #     msg('File "%s" just now cached.' % filename)
+    #     LineCache::cache(matches[0])
+    #     LineCache::remap_file(matches[0], filename)
+    #     canonic_name = matches[0]
+    #   end
+    else
+      msg(m + ' not cached in debugger.')
+      return
+    end
+    seen = {}
+    args[3..-1].each do |arg|
+      processed_arg = false
+
+      if %w(all size).member?(arg) 
+        unless seen[:size]
+          max_line = LineCache::size(canonic_name)
+          msg "File has %d lines." % max_line if max_line
+        end
+        processed_arg = seen[:size] = true
+      end
+
+      if %w(all sha1).member?(arg)
+        unless seen[:sha1]
+          msg("SHA1 is %s." % LineCache::sha1(canonic_name))
+        end
+        processed_arg = seen[:sha1] = true
+      end
+
+      if %w(all brkpts).member?(arg)
+        unless seen[:brkpts]
+          msg("Possible breakpoint line numbers:")
+          lines = LineCache::trace_line_numbers(canonic_name)
+          fmt_lines = columnize_numbers(lines)
+          msg(fmt_lines)
+        end
+        processed_arg = seen[:brkpts] = true
+      end
+
+      # if %w(all iseq).member?(arg) 
+      #   unless seen[:iseq]
+      #     if SCRIPT_ISEQS__.member?(canonic_name)
+      #       msg("File contains instruction sequences:")
+      #       SCRIPT_ISEQS__[canonic_name].each do |iseq|
+      #         msg("\t %s %s" % [iseq, iseq.name.inspect])
+      #       end 
+      #     else
+      #       msg("Instruction sequences not recorded; there may be some, though.")
+      #     end
+      #   end
+      #   processed_arg = seen[:iseq] = true
+      # end
+
+      if %w(all stat).member?(arg)
+        unless seen[:stat]
+          msg("Stat info:\n\t%s." % LineCache::stat(canonic_name).inspect)
+        end
+        processed_arg = seen[:stat] = true
+      end
+
+      if not processed_arg
+        errmsg("I don't understand sub-option \"%s\"." % arg)
+      end
+    end unless args.empty?
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../../mock'
+  require_relative '../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+  # FIXME: DRY the below code
+  dbgr, cmd = MockDebugger::setup('info')
+  subcommand = Trepan::Subcommand::InfoFile.new(cmd)
+  testcmdMgr = Trepan::Subcmd.new(subcommand)
+  LineCache::cache(__FILE__)
+  
+  [%w(info file nothere),
+   %w(info file .),
+   %w(info file),
+   %w(info file file.rb),
+   %w(info file . all),
+   %w(info file . lines size sha1 sha1)].each do |args|
+    subcommand.run(args)
+    puts '-' * 40
+  end
+end

data/processor/command/info_subcmd/method.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoMethod < Trepan::Subcommand
+  unless defined?(HELP)
+    HELP         = 
+'info [METHOD|.]
+
+Show information about a method.
+
+Examples:
+  info method
+  info method .
+  info method require_relative
+'
+    MIN_ABBREV   = 'me'.size
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info method)
+    SHORT_HELP   = 'Information about a (compiled) method'
+  end
+
+  def run(args)
+    if args.size <= 2
+      method_name = '.'
+    else
+      method_name = args[2]
+    end
+    if '.' == method_name
+      meth = @proc.frame.method
+    # elsif ...
+    #   # FIXME: do something if there is more than one
+    else
+      meth = nil
+    end
+    
+    if meth
+      msg("Method #{meth.name}():")
+      %w(arity         child_methods describe
+         file          first_line    lines         local_count
+         required_args splat         stack_size    total_args 
+         ).each do |field|
+        msg "  %-15s: %s" % [field, meth.send(field).inspect]
+      end
+    else
+      mess = "Can't find method"
+      mess += " for #{args.join(' ')}" unless args.empty?
+      errmsg mess
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+
+  require_relative '../../mock'
+  require_relative '../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, cmd = MockDebugger::setup('info')
+  subcommand = Trepan::Subcommand::InfoMethod.new(cmd)
+  testcmdMgr = Trepan::Subcmd.new(subcommand)
+
+  subcommand.run([name])
+  name = File.basename(__FILE__, '.rb')
+  subcommand.summary_help(name)
+end

data/processor/command/info_subcmd/program.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoProgram < Trepan::Subcommand
+  unless defined?(HELP)
+    HELP         = 'Information about debugged program and its environment'
+    MIN_ABBREV   = 'pr'.size
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info program)
+  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'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, cmd = MockDebugger::setup('info')
+  subcommand = Trepan::Subcommand::InfoProgram.new(cmd)
+  testcmdMgr = Trepan::Subcmd.new(subcommand)
+
+  subcommand.run_show_bool
+  name = File.basename(__FILE__, '.rb')
+  subcommand.summary_help(name)
+  puts
+end

data/processor/command/info_subcmd/variables.rb

@@ -0,0 +1,40 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Command::InfoVariables < Trepan::Subcommand
+  MIN_ABBREV   = 'var'.size
+  NAME         = File.basename(__FILE__, '.rb')
+  NEED_STACK   = true
+  PREFIX       = %w(info variables)
+  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
+        msg "No variable set named '#{var}'"
+      end
+    end
+  end
+end

data/processor/command/irb.rb

@@ -0,0 +1,96 @@
+# 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) # :nodoc
+    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]}
+    cont = IRB.start_session(@proc.frame.binding, @proc, conf).to_s
+    trap('SIGINT', save_trap) # Restore old trap
+
+    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
+
+    if %w(continue finish next ext step).member?(cont)
+      @proc.commands[cont].run([cont]) # (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