trepanning 0.0.4

data/io/string_array.rb

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Simulate I/O using lists of strings.
+
+require_relative 'base_io'
+
+# Simulate I/O using an array of strings. Sort of like StringIO, but
+# even simplier.
+class Trepan::StringArrayInput < Trepan::InputBase
+
+  def initialize(inp, opts={})
+    super
+    @closed = false
+  end
+
+  # this close() interface is defined for class compatibility
+  def close
+    @closed = true 
+  end
+
+  def closed?
+    @closed
+  end
+
+  def eof?
+    @closed || @input.empty?
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def flush ; end
+
+  # Read a line of input. EOFError will be raised on EOF.  
+  # Note that we don't support prompting
+  def readline
+    raise EOFError if eof?
+    if @input.empty?
+      raise EOFError
+    end
+    line = @input.shift
+    return line 
+  end
+
+  class << self
+    # Use this to set where to read from.
+    def open(inp, opts={})
+      if inp.is_a?(Array)
+        return self.new(inp)
+      else
+        raise IOError, "Invalid input type (%s) for %s" % [inp.class, inp]
+      end
+    end
+  end
+end
+
+# Simulate I/O using an array of strings. Sort of like StringIO, but
+# even simplier.
+class Trepan::StringArrayOutput < Trepan::OutputBase
+
+  def initialize(out=[], opts={})
+    super 
+    @closed = false
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def close
+    @closed = true 
+  end
+
+  def closed?
+    @closed
+  end
+
+  def eof?
+    @closed || @output.empty? 
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def flush ; end
+
+  # This method the debugger uses to write. In contrast to
+  # writeline, no newline is added to the end to `str'.
+  #
+  def write(msg)
+    raise ValueError if @closed
+    @output << msg
+  end
+  
+  # used to write to a debugger that is connected to this
+  # server; Here, we use the null string '' as an indicator of a
+  # newline.
+  def writeline(msg)
+    write(msg)
+    write('')
+  end
+
+  class << self
+    # Use this to set where to write to. output can be a 
+    # file object or a string. This code raises IOError on error.
+    # 
+    # If another file was previously open upon calling this open,
+    # that will be stacked and will come back into use after
+    # a close_write().
+    def open(output=[])
+      if output.is_a?(Array)
+        return self.new(output)
+      else
+        raise IOError, ("Invalid output type (%s) for %s" % 
+                        [output.class, output])
+      end
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  inp  = Trepan::StringArrayInput.open(['Now is the time', 'for all good men'])
+  line = inp.readline
+  p line
+  line = inp.readline
+  p line
+  begin
+    line = inp.readline
+  rescue EOFError
+    puts 'EOF hit on read'
+  end
+
+  out = Trepan::StringArrayOutput.open
+  p out.output
+#    line = io.readline('Type some more characters: ')
+  out.writeline('Hello, world!')
+  p out.output
+  out.write('Hello');
+  p out.output
+  out.writeline(', again.');
+  p out.output
+#     io.open_write(sys.stdout)
+  out.flush_after_write = true
+  out.write('Last hello')
+  puts "Output is closed? #{out.closed?}"
+  out.close
+  p out.output
+  begin
+    out.writeline("You won't see me")
+  rescue
+  end
+
+  # Closing after already closed is okay
+  out.close
+  puts "Output is closed? #{out.closed?}"
+  puts "Input is closed? #{inp.closed?}"
+  inp.close
+  puts "Input is closed? #{inp.closed?}"
+end
+

data/lib/Makefile

@@ -0,0 +1,7 @@
+# Whatever it is you want to do, it should be forwarded to the 
+# to top-level irectories
+.PHONY: check all
+all: check
+
+%: 
+	$(MAKE) -C .. $@

data/lib/trepanning.rb

@@ -0,0 +1,277 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'trace'                          # Trace filtering
+require 'thread_frame'
+require_relative '../app/core'           # core event-handling mechanism
+require_relative '../app/default'        # default debugger settings
+require_relative '../interface/user'     # user interface (includes I/O)
+require_relative '../interface/script'   # --command interface (includes I/O)
+
+# SCRIPT_ISEQS__ is like SCRIPT_LINES__ in a patched Ruby 1.9. Setting
+# this variable to a hash causes instruction sequences to be added in
+# this has under their "filename" as a key. More accurately though,
+# the "filename" is instruction sequence name that was given as in the
+# "filename" parameter when the instruction sequence was
+# generated. Each value is an array of instruction sequences that
+# share that name.
+SCRIPT_ISEQS__ = {} unless 
+  defined?(SCRIPT_ISEQS__) && SCRIPT_ISEQS__.is_a?(Hash)
+ISEQS__        = {} unless 
+  defined?(ISEQS__) && ISEQS__.is_a?(Hash)
+
+class Trepan
+  VERSION = '0.0.4'
+
+  attr_accessor :core         # access to Trepan::Core instance
+  attr_accessor :intf         # Array. The way the outside world
+                              # interfaces with us.  An array, so that
+                              # interfaces can be stacked.
+  attr_reader   :initial_dir  # String. Current directory when program
+                              # started. Used in restart program.
+  attr_accessor :restart_argv # How to restart us, empty or nil. 
+                              # Note restart[0] is typically $0.
+  attr_reader   :settings     # Hash[:symbol] of things you can configure
+  attr_accessor :trace_filter # Procs/Methods we ignore.
+
+  def initialize(settings={})
+
+    # FIXME: Tracing through intialization code is slow. Need to figure
+    # out better ways to do this. 
+    th = Thread.current
+    th.exec_event_tracing  = true
+
+    @settings = Trepanning::DEFAULT_SETTINGS.merge(settings)
+    @input  ||= @settings[:input]
+    @output ||= @settings[:output]
+
+    @intf     = [Trepan::UserInterface.new(@input, @output)]
+    @settings[:cmdfiles].each do |cmdfile|
+      add_command_file(cmdfile)
+    end if @settings.member?(:cmdfiles)
+    @core     = Core.new(self, @settings[:core_opts])
+    if @settings[:initial_dir]
+      Dir.chdir(@settings[:initial_dir])
+    else
+      @settings[:initial_dir] = Dir.pwd
+    end
+    @initial_dir  = @settings[:initial_dir]
+    @restart_argv = 
+      if @settings[:set_restart]
+        [File.expand_path($0)] + ARGV
+      elsif @settings[:restart_argv]
+        @settings[:restart_argv]
+      else 
+        nil
+      end
+    @trace_filter = Trace::Filter.new
+    %w(debugger start stop).each do |m| 
+      @trace_filter << self.method(m.to_sym)
+    end
+    %w(debugger event_processor trace_var_processor).each do 
+      |m| 
+      @trace_filter << @core.method(m)
+    end
+    @trace_filter << @trace_filter.method(:add_trace_func)
+    @trace_filter << @trace_filter.method(:remove_trace_func)
+    @trace_filter << Kernel.method(:add_trace_func)
+
+    # Run user debugger command startup files.
+    add_startup_files unless @settings[:nx]
+    add_command_file(@settings[:restore_profile]) if 
+      @settings[:restore_profile] && File.readable?(@settings[:restore_profile])
+
+    at_exit do 
+      clear_trace_func
+      @intf[-1].close 
+    end
+    th.exec_event_tracing  = false
+  end
+
+  # To call from inside a Ruby program, there is one-time setup that 
+  # needs to be done first:
+  #    require 'trepanning'
+  #    mydbg = Trepan.new()
+  # or if you haven't mucked around with $0 and ARGV, you might try:
+  #    mydbg = Trepan.new(:set_restart=>true))
+  # which will tell the debugger how to "restart" the program.
+  #
+  # If you want a synchronous stop in your program call to the
+  # debugger at the point of the call, set opts[:immediate]
+  # true. Example:
+  #
+  #    ... work, work, work
+  #    mydbg.debugger(:immediate=>true)   # enter debugger here
+  #    ... work, work, work
+  #
+  # However to enter the debugger on the next event after the 
+  # debugger() call:
+  #  
+  #    ... work, work, work
+  #    mydbg.debugger  # Don't stop here...
+  #    work            # but stop here.
+  #
+  # And finally, if you want to debug just a block:
+  #   mydbg.debugger {
+  #     ... code you want to debug.
+  #   }
+  #
+  # Some options
+
+  #   :immediate -  boolean. If true, immediate stop rather than wait
+  #                          for an event
+  #
+  #   :hide_stack - boolean. If true, omit stack frames before the
+  #                          debugger call
+  # 
+  #   :debugme    - boolean. Allow tracing into this routine. You
+  #                          generally won't want this. It slows things
+  #                          down horribly.
+
+  def debugger(opts={}, &block)
+    # FIXME: one option we may want to pass is the initial trace filter.
+    if opts[:hide_stack]
+      @core.processor.hidelevels[Thread.current] = 
+        RubyVM::ThreadFrame.current.stack_size
+    end
+    th = Thread.current
+    if block
+      start
+      # I don't think yield or block.call is quite right.
+      ret = yield   # Not: block.call(self) ? 
+      stop
+      return ret
+    elsif opts[:immediate]
+      # Stop immediately after this method returns. But if opts[:debugme]
+      # is set, we can stop in this method.
+      RubyVM::ThreadFrame::current.trace_off = true unless opts[:debugme]
+      @trace_filter.set_trace_func(@core.event_proc) 
+      Trace.event_masks[0] |= @core.step_events
+      @core.debugger(1) 
+    else
+      RubyVM::ThreadFrame::current.trace_off = true unless opts[:debugme]
+
+      @trace_filter.set_trace_func(@core.event_proc)
+      Trace.event_masks[0] |= @core.step_events
+
+      # Set to stop on the next event after this returns.
+      @core.step_count = 0
+    end
+  end
+
+  # Set core's trace-event processor to run
+  def start
+    @trace_filter.add_trace_func(@core.event_proc)
+  end
+  
+  # Remove all of our trace events
+  def stop(opts={})
+    # FIXME: should do something in the middle when
+    # we have the ability to remove *our* specific hook
+    # @trace_filter.set_trace_func(nil)
+    # @trace_filter.remove_trace_func
+    clear_trace_func
+  end
+
+  def add_command_file(cmdfile, stderr=$stderr)
+    unless File.readable?(cmdfile)
+      if File.exists?(cmdfile)
+        stderr.puts "Command file '#{cmdfile}' is not readable."
+        return
+      else
+        stderr.puts "Command file '#{cmdfile}' does not exist."
+        stderr.puts caller
+        return
+      end
+    end
+    @intf << Trepan::ScriptInterface.new(cmdfile, @output)
+  end
+
+  def add_startup_files()
+    seen = {}
+    cwd_initfile = File.join('.', Trepanning::CMD_INITFILE_BASE)
+    [cwd_initfile, Trepanning::CMD_INITFILE].each do |initfile|
+      full_initfile_path = File.expand_path(initfile)
+      next if seen[full_initfile_path]
+      add_command_file(full_initfile_path) if File.readable?(full_initfile_path)
+      seen[full_initfile_path] = true
+    end
+  end
+
+  # As a simplification for creating a debugger object, and then
+  # calling using the object to invoke the debugger, we allow this
+  # two-step process in one step. That is, instead of
+  #  
+  #  require 'trepanning'
+  #  mydbg = Trepan.new()
+  #  ... 
+  #  mydbg.debugger
+
+  # You can run:
+  #  require 'trepanning'
+  # ...
+  #  Trepan.debug
+  #
+  # See debugger for options that can be passed. By default :hide_stack is
+  # set.
+  # 
+  # Likewise for mydbg.debugger{ ... }
+
+  def self.debug(opts={}, &block)
+    opts = {:hide_stack => true}.merge(opts)
+    unless defined?($trepanning) && $trepanning.is_a?(Trepan)
+      $trepanning = Trepan.new(opts)
+      $trepanning.trace_filter << self.method(:debug)
+    end
+    $trepanning.debugger(opts, &block)
+  end
+
+  def self.debug_str(string, opts = DEFAULT_DEBUG_STR_SETTINGS)
+    $trepanning = Trepan.new(opts) unless 
+      $trepanning && $trepanning.is_a?(Trepan)
+    $trepanning.core.processor.settings[:different] = false
+    # Perhaps we should do a remap file to string right here? 
+    $trepanning.debugger(opts) { eval(string) }
+  end
+end
+
+module Kernel
+  # Same as Trepan.debug. 
+  # FIXME figure out a way to remove duplication.
+  def trepan(opts={}, &block)
+    opts = {:hide_stack => true}.merge(opts)
+    unless defined?($trepanning) && $trepanning.is_a?(Trepan)
+      $trepanning = Trepan.new
+      $trepanning.trace_filter << self.method(:trepan)
+    end
+    $trepanning.debugger(opts, &block)
+  end
+end
+
+if __FILE__ == $0
+  def square(x) 
+    x * x
+  end
+  puts 'block debugging...'
+  # It is imagined that there are all sorts of command-line options here.
+  # (I have a good imagination.)
+  Trepan.debug(:set_restart=>true) {
+    a = 2
+    b = square(a)
+    p "square of #{a} is #{b}"
+  }
+
+  puts 'immediate debugging...'
+  $trepanning.debugger(:immediate => true)
+  puts 'line after immediate'
+  a = 3
+  square(a)
+
+  class MyClass
+    def initialize(x)
+      @x = x
+    end
+  end
+  $trepanning.debugger
+  m = MyClass.new(5)
+  raise RuntimeError # To see how we handle post-mortem debugging.
+end

data/processor/breakpoint.rb

@@ -0,0 +1,108 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../app/core'
+class Trepan
+
+  class CmdProcessor
+
+    attr_reader   :brkpts          # BreakpointManager. 
+
+    attr_reader   :brkpt           # Breakpoint. If we are stopped at a
+                                   # breakpoint this is the one we
+                                   # found.  (There may be other
+                                   # breakpoints that would have caused a stop
+                                   # as well; this is just one of them).
+                                   # If no breakpoint stop this is nil.
+
+    def breakpoint_initialize
+      @brkpts          = BreakpointMgr.new
+      @brkpt           = nil
+    end
+
+    def breakpoint?
+      @brkpt = @brkpts.find(@frame.iseq, @frame.pc_offset, @frame.binding)
+      @brkpts.delete_by_brkpt(@brkpt) if @brkpt && @brkpt.temp?
+      return !!@brkpt
+    end
+
+    def breakpoint_find(bpnum, show_errmsg = true)
+      if 0 == @brkpts.size 
+        errmsg('No breakpoints set.') if show_errmsg
+        return nil
+      elsif bpnum > @brkpts.max || bpnum < 1
+        errmsg('Breakpoint number %d is out of range 1..%d' %
+               [bpnum, @brkpts.max]) if show_errmsg
+        return nil
+      end
+      bp = @brkpts[bpnum]
+      if bp
+        return bp
+      else
+        errmsg('Breakpoint number %d previously deleted.' %
+               bpnum) if show_errmsg
+        return nil
+      end
+    end
+
+    # Does whatever needs to be done to set a breakpoint
+    def breakpoint_line(line_number, iseq, temp=false)
+      # FIXME: handle breakpoint conditions.
+      found_iseq = iseq.child_iseqs.detect do |iseq|
+        iseq.lineoffsets.keys.member?(line_number) 
+      end
+      unless found_iseq
+        found_iseq = iseq.parent
+        while found_iseq do
+          break if found_iseq.lineoffsets.keys.member?(line_number)
+          found_iseq = found_iseq.parent
+        end
+      end
+      offset = 
+        if found_iseq 
+          # FIXME
+          found_iseq.line2offsets(line_number)[1] || 
+            found_iseq.line2offsets(line_number)[0]
+        else
+          nil
+        end
+      unless offset
+        place = "in #{iseq.source_container.join(' ')} " if found_iseq 
+        errmsg("No line #{line_number} found #{place}for breakpoint.")
+        return nil
+      end
+      @brkpts.add(found_iseq, offset, :temp => temp)
+    end
+
+    def breakpoint_offset(offset, iseq, temp=false)
+      # FIXME: handle breakpoint conditions.
+      unless iseq.offsetlines.keys.member?(offset)
+        errmsg("Offset #{offset} not found in #{iseq.name} for breakpoint.")
+        return nil
+      end
+      @brkpts.add(iseq, offset, :temp => temp, :type => 'offset')
+    end
+
+    # Delete a breakpoint given its breakpoint number.
+    def delete_breakpoint_by_number(bpnum, do_enable=true)
+      bp = breakpoint_find(bpnum)
+      return false unless bp
+          
+      @brkpts.delete_by_brkpt(bp)
+      return true
+    end
+
+    # Enable or disable a breakpoint given its breakpoint number.
+    def en_disable_breakpoint_by_number(bpnum, do_enable=true)
+      bp = breakpoint_find(bpnum)
+      return false unless bp
+          
+      enable_disable = do_enable ? 'en' : 'dis'
+      if bp.enabled? == do_enable
+        errmsg('Breakpoint %d previously %sabled.' % 
+               [bpnum, enable_disable])
+        return false
+      end
+      bp.enabled = do_enable
+      return true
+    end
+  end
+end

data/processor/command/alias.rb

@@ -0,0 +1,55 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+
+class Trepan::Command::AliasCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"alias ALIAS COMMAND
+
+Add an alias for a COMMAND
+
+See also 'unalias'.
+"
+
+    CATEGORY      = 'support'
+    MAX_ARGS      = 2  # Need at most this many
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = true
+    SHORT_HELP    = 'Add an alias for a debugger command'
+  end
+  
+  # Run command. 
+  def run(args)
+    if args.size == 1
+      @proc.commands['show'].run(%w(show alias))
+    elsif args.size == 2
+      @proc.commands['show'].run(%W(show alias #{args[1]}))
+    else
+      junk, al, command = args
+      old_command = @proc.aliases[al]
+      if @proc.commands.member?(command)
+        @proc.aliases[al] = command
+        if old_command
+          msg("Alias '#{al}' for command '#{command}' replaced old " + 
+              "alias for '#{old_command}'.")
+        else
+          msg "New alias '#{al}' for command '#{command}' created."
+        end
+      else
+        errmsg "You must alias to a command name, and '#{command}' isn't one."
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  cmd.run %w(alias yy foo)
+  cmd.run %w(alias yy step)
+  cmd.run %w(alias)
+  cmd.run %w(alias yy next)
+end

data/processor/command/backtrace.rb

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+class Trepan::Command::BacktraceCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME          = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [count]
+
+Print a stack trace, with the most recent frame at the top.  With a
+positive number, print at most many entries.  With a negative number
+print the top entries minus that number.
+
+An arrow indicates the 'current frame'. The current frame determines
+the context used for many debugger commands such as expression
+evaluation or source-line listing.
+
+Examples:
+   #{NAME}    # Print a full stack trace
+   #{NAME} 2  # Print only the top two entries
+   #{NAME} -1 # Print a stack trace except the initial (least recent) call."
+      HELP
+
+    ALIASES       = %w(bt where)
+    CATEGORY      = 'stack'
+    MAX_ARGS      = 1  # Need at most this many
+    NEED_STACK    = true
+    SHORT_HELP    = 'Print backtrace of stack frames'
+  end
+
+  require_relative '../../app/frame'
+  include Trepan::Frame
+
+  # This method runs the command
+  def run(args) # :nodoc
+    unless @proc.frame
+      errmsg 'No frame.'
+      return false
+    end
+    hide_level  = 
+      if !settings[:debugstack] && @proc.hidelevels[Thread.current] 
+        @proc.hidelevels[Thread.current] 
+      else 0 
+      end
+    stack_size = @proc.top_frame.stack_size - hide_level
+    opts = {
+      :basename    => @proc.settings[:basename],
+      :current_pos => @proc.frame_index,
+      :maxstack    => @proc.settings[:maxstack],
+      :maxwidth    => @proc.settings[:maxwidth],
+      :show_pc     => @proc.settings[:show_pc]
+    }
+    opts[:count] = 
+      if args.size > 1
+        opts[:maxstack] = @proc.get_int(args[1], 
+                                       :cmdname   => 'where',
+                                       :max_value => stack_size)
+      else
+        stack_size
+      end
+    return false unless opts[:count]
+    # FIXME: Fix Ruby so we don't need this workaround? 
+    # See also location.rb
+    opts[:class] = @proc.core.hook_arg  if 
+      'CFUNC' == @proc.frame.type && 
+      @proc.core.hook_arg && @proc.event != 'raise'
+    print_stack_trace(@proc.top_frame, opts)
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require 'thread_frame'
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+
+  def run_cmd(cmd, args)
+    cmd.run(args)
+    puts '=' * 40
+  end
+
+  run_cmd(cmd, [name])
+
+  %w(1 100).each {|count| run_cmd(cmd, [name, count])}
+  cmd.settings[:basename] = true
+  def foo(cmd, name)
+    cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+    run_cmd(cmd, [name])
+  end
+  foo(cmd, name)
+  cmd.settings[:show_pc] = true
+  1.times {run_cmd(cmd, [name])}
+end