rb8-trepanning 0.1.3

data/processor/command/info_subcmd/ruby.rb

@@ -0,0 +1,57 @@
+# -*- 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} [-v|--verbose|-no-verbose]
+
+Show Ruby version information such as you'd get from 
+"ruby -v" (which is really just the value of RUBY_RELEASE_DATE).
+
+See also constants: RUBY_DESCRIPITON, RUBY_VERSION, and RUBY_RELEASE_DATE."
+    EOH
+    MIN_ABBREV   = 'ru'.size
+    NEED_STACK   = false
+    MIN_ARGS     = 0
+    MAX_ARGS     = 0
+    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]
+      # To be completed
+    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/source.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require 'pp'
+begin
+  require 'linecache'
+rescue LoadError
+  require 'linecache19'
+end
+require 'columnize'
+require_relative '../base/subcmd'
+require_relative '../../../app/complete'
+
+class Trepan::Subcommand::InfoSource < Trepan::Subcommand
+  unless defined?(HELP)
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    DEFAULT_FILE_ARGS = %w(size mtime sha1)
+
+    HELP = <<-EOH
+#{CMD} 
+
+Show information about the current source file. 
+EOH
+    MAX_ARGS     = 0
+    MIN_ABBREV   = 'so'.size  # Note we have "info frame"
+    NEED_STACK   = true
+  end
+
+  # completion %w(all brkpts iseq sha1 size stat)
+
+  include Trepanning
+
+  # Get file information
+  def run(args)
+    if not @proc.frame
+      errmsg('No frame - no default file.')
+      return false
+    end
+    frame_file = @proc.frame.file
+    filename = LineCache::unmap_file(frame_file) || File.expand_path(frame_file)
+    canonic_name = @proc.canonic_file(filename)
+    canonic_name = LineCache::unmap_file(canonic_name) || canonic_name
+    m = filename
+    if LineCache::cached?(canonic_name)
+      m += ' is cached in debugger'
+      if canonic_name != filename
+        m += (' as:\n  ' + canonic_name)
+      end
+      m += '.'
+      msg(m)
+    end
+    max_line = LineCache::size(canonic_name)
+    msg 'File has %d lines.' % max_line if max_line
+    msg('SHA1 is %s.' % LineCache::sha1(canonic_name))
+    msg('Possible breakpoint line numbers:')
+    lines = LineCache.trace_line_numbers(canonic_name)
+    fmt_lines = columnize_numbers(lines)
+    msg(fmt_lines)
+    msg("Stat info:\n\t%s" % LineCache::stat(canonic_name).pretty_inspect)
+  end
+end
+
+if __FILE__ == $0
+  if !(ARGV.size == 1 && ARGV[0] == 'noload')
+    ISEQS__        = {}
+    SCRIPT_ISEQS__ = {}
+    ARGV[0..-1]    = ['noload']
+    load(__FILE__)
+  else    
+    require_relative '../../mock'
+    cmd = MockDebugger::sub_setup(Trepan::Subcommand::InfoSource, false)
+    cmd.run(cmd.prefix)
+  end
+end

data/processor/command/info_subcmd/stack.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+
+class Trepan::Subcommand::InfoStack < Trepan::Subcommand
+  unless defined?(HELP)
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP = 'Same thing as "backtrace"'
+    MIN_ABBREV   = 'st'.size
+    NEED_STACK   = true
+   end
+
+  def run(args)
+    @proc.commands['backtrace'].run(['backtrace'] + args[2..-1])
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  cmd = MockDebugger::sub_setup(Trepan::Subcommand::InfoStack, false)
+  cmd.run(cmd.prefix)
+end

data/processor/command/info_subcmd/threads.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoThreads < Trepan::Subcommand
+  unless defined?(HELP)
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = 'Show IDs of currently-known threads'
+    MIN_ABBREV   = 'th'.size
+    MIN_ARGS     = 0
+    MAX_ARGS     = 0
+    NEED_STACK   = true
+  end
+  
+  def display_context(c, show_top_frame=true)
+    c_flag = c.thread == Thread.current ? '+' : ' '
+    c_flag = '$' if c.suspended?
+    d_flag = c.ignored? ? '!' : ' '
+    str  = "%s%s" % [c_flag, d_flag]
+    str += "%d " % c.thnum
+    str += "%s\t" % c.thread.inspect
+    if c.stack_size > 0 and show_top_frame
+      str += "%s:%d" % [@proc.canonic_file(c.frame_file(0)), c.frame_line(0)]
+    end
+    msg str
+  end
+  
+  def get_context(thnum)
+    Debugger.contexts.find{|c| c.thnum == thnum}
+  end  
+  
+  def parse_thread_num(subcmd, arg)
+    if '' == arg
+      errmsg "'%s' needs a thread number\n" % subcmd
+      nil
+    else
+      thread_num = @proc.get_int(arg, 
+                                 :cmdname => "thread #{subcmd}", 
+                                 :default => 1)
+      return nil unless thread_num
+      get_context(thread_num)
+    end
+  end
+  
+  def parse_thread_num_for_cmd(subcmd, arg)
+    c = parse_thread_num(subcmd, arg)
+    return nil unless c
+    case 
+    when nil == c
+      errmsg "No such thread."
+    when @proc.context == c
+      errmsg "It's the current thread."
+    when c.ignored?
+      errmsg "Can't #{subcmd} to the debugger thread #{arg}."
+    else # Everything is okay
+      return c
+    end
+    return nil
+  end
+  
+  def run(args)
+    threads = Debugger.contexts.sort_by{|c| c.thnum}.each do |c|
+      display_context(c)
+    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::InfoThreads, false)
+  cmd.run(cmd.prefix)
+end

data/processor/command/kill.rb

@@ -0,0 +1,78 @@
+# Copyright (C) 2010, 2011 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]
+
+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 you are in interactive mode, you are prompted to confirm killing.
+However when this command is aliased from a command ending in !, no 
+questions are asked.
+
+Examples:
+
+  #{NAME}  
+  #{NAME} unconditionally
+  #{NAME} KILL # same as above
+  #{NAME} kill # same as above
+  #{NAME} -9   # same as above
+  #{NAME}  9   # same as above
+  #{NAME}! 9   # same as above, but no questions asked.
+    HELP
+
+    ALIASES      = %w(kill!)
+    CATEGORY     = 'running'
+    MAX_ARGS     = 1  # Need at most this many
+    SHORT_HELP  = 'Send this process a POSIX signal (default "9" is "kill -9")'
+  end
+  
+  def complete(prefix)
+    completions = Signal.list.keys + 
+      Signal.list.values.map{|i| i.to_s} + 
+      Signal.list.values.map{|i| (-i).to_s} 
+    Trepan::Complete.complete_token(completions, prefix)
+  end
+    
+  # This method runs the command
+  def run(args) # :nodoc
+    unconditional = ('!' == args[0][-1..-1])
+    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
+    else
+      if not (unconditional || confirm('Really quit?', false))
+        msg('Kill not confirmed.')
+        return
+      else 
+        sig = 'KILL'
+      end
+    end
+    begin
+      ## @proc.intf.finalize  if 'KILL' == sig || Signal['KILL'] == sig
+      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,117 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::ListCommand < Trepan::Command
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} 
+#{NAME} -
+#{NAME} =
+#{NAME} mm-nn
+
+#{NAME} source code. 
+
+In the first form without arguments, prints lines starting at
+the 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.
+
+In the second form, list lines before the preciding list or
+the current line.
+
+In the third form, list lines centered around the current line.
+
+Use 'set max list' or 'show max list' to see or set the value.
+    HELP
+
+    ALIASES       = %W(l)
+    CATEGORY      = 'files'
+    MAX_ARGS      = 2
+    SHORT_HELP    = 'List source code'
+  end
+
+  # Show FILE from line B to E where CURRENT is the current line number.
+  # If we can show from B to E then we return B, otherwise we return the
+  # previous line @state.previous_line.
+  def display_list(b, e, file, current)
+    opts = {
+      :reload_on_change => settings[:reload],
+      :output => settings[:highlight]
+    }
+    lines = LineCache::getlines(file, opts)
+    if lines
+      b = lines.size - (e - b) if b >= lines.size
+      e = lines.size if lines.size < e
+      msg "[%d, %d] in %s" % [b, e, file]
+      [b, 1].max.upto(e) do |n|
+        if n > 0 && lines[n-1]
+          if n == current
+            msg "=> %3d  %s" % [n, lines[n-1].chomp], :unlimited => true
+          else
+            msg "   %3d  %s" % [n, lines[n-1].chomp], :unlimited => true
+          end
+        end
+      end
+    else
+      errmsg "No sourcefile available for %s\n" % file
+      return @proc.state.previous_line
+    end
+    return b
+  end
+
+  def run(args)
+    listsize = settings[:maxlist]
+    if args.size == 1
+      b = @proc.state.previous_line ? 
+      @proc.state.previous_line + listsize : @proc.frame.line - (listsize/2)
+      e = b + listsize - 1
+    elsif args[1] == '-'
+      b = if @proc.state.previous_line
+            if  @proc.state.previous_line > 0
+              @proc.state.previous_line - listsize 
+            else
+              @proc.state.previous_line
+            end
+          else 
+            @proc.state.line - (listsize/2)
+          end
+      e = b + listsize - 1
+    elsif args[1] == '='
+      @proc.state.previous_line = nil
+      b = @proc.state.line - (listsize/2)
+      e = b + listsize -1
+    else
+      b, e = args[1].split(/[-,]/)
+      if e
+        b = b.to_i
+        e = e.to_i
+      else
+        b = b.to_i - (listsize/2)
+        e = b + listsize - 1
+      end
+    end
+    @proc.state.previous_line = 
+      display_list(b, e, @proc.frame.file, @proc.frame.line)
+  end
+  
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  def run_cmd(cmd, args)
+    cmd.proc.instance_variable_set('@cmd_argstr', args[1..-1].join(' '))
+    cmd.run(args)
+    puts '-' * 20
+  end
+  
+  LineCache::cache(__FILE__)
+  run_cmd(cmd, [cmd.name])
+  run_cmd(cmd, [cmd.name, __FILE__ + ':10'])
+end

data/processor/command/macro.rb

@@ -0,0 +1,68 @@
+# -*- 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. 
+
+The macro should return either a String or an Array of Strings which
+is substituted for the command.  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 ;; this will not be handled on the 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 can contain other macros, and ;; in those strings will be
+split into separate commands.
+
+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)}
+
+See also 'show macro'.
+    HELP
+
+    CATEGORY      = 'support'
+    MIN_ARGS      = 2  # Need at least this many
+    SHORT_HELP    = 'Define a macro'
+  end
+  
+  def run(args)
+    cmd_name = args[1]
+    cmd_argstr = @proc.cmd_argstr[cmd_name.size..-1].lstrip
+    proc_obj = @proc.debug_eval(cmd_argstr, @proc.settings[:maxstring])
+    if proc_obj
+      if proc_obj.is_a?(Proc)
+        @proc.macros[cmd_name] = [proc_obj, cmd_argstr]
+        msg "Macro \"#{cmd_name}\" defined."
+      else
+        errmsg "Expecting a Proc object; got: #{cmd_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