trepanning 0.0.4

data/bin/trepan

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Invoke debugger from the command line. 
+require_relative '../app/run'
+require_relative '../app/options'
+require_relative '../lib/trepanning'
+
+# FIXME: the figure out how to run via gem installation.
+if File.basename(__FILE__) == File.basename($0)
+  include Trepanning
+
+  # One way to get local variables is to create a block which is run
+  # once.  
+  # 
+  # Note however that since there are constants below, we can't
+  # wrap all of this in a procedure as that would be defining
+  # constants dynamically.
+  1.times do 
+    | ; trepan_path, program_to_debug |
+    # options = DEFAULT_CMDLINE_SETTINGS.merge({}) seems to change up
+    # DEFAULT_CMDLINE_SETTINGS when options[:key] is changed. The
+    # below is the simplest thing I can come up with so far.
+    options = copy_default_options
+    opts    = setup_options(options)
+    Trepan::ARGV = ARGV.clone
+    rest = opts.parse! ARGV
+
+    trepan_path = File.expand_path($0)
+    if RUBY_PLATFORM =~ /mswin/
+      trepan_path += '.cmd' unless trepan_path =~ /\.cmd$/i
+    end
+
+    # FIXME: do we need to test defined? 
+    # FIXME: Should (some of) these be instance variables?
+    Trepan::RUBY_PATH    = ruby_path
+    Trepan::TREPAN_PATH  = trepan_path
+    Trepan::RBDBGR_FILE  = __FILE__
+
+    if ARGV.empty?
+      if options[:version] || options[:help]
+        exit 100
+      else
+        STDERR.puts 'Sorry - for now you must specify a Ruby script to debug.'
+        exit(1)
+      end
+    end
+
+    program_to_debug = ARGV.shift
+    program_to_debug = whence_file(program_to_debug) unless 
+      File.exist?(program_to_debug)
+    Trepan::PROG_SCRIPT = program_to_debug
+
+    # Set global so others may use this debugger.
+    $trepan = Trepan.new(:restart_argv => 
+                           explicit_restart_argv(Trepan::ARGV),
+                           :cmdfiles    => options[:cmdfiles],
+                           :initial_dir => options[:chdir],
+                           :nx          => options[:nx]
+                           )
+    debug_program($trepan, Trepan::RUBY_PATH, 
+                  File.expand_path(program_to_debug))
+  end
+end

data/data/custom_require.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+module Kernel
+
+  ##
+  # The Kernel#require from before RubyGems was loaded.
+
+  alias gem_original_require require
+
+  ##
+  # When RubyGems is required, Kernel#require is replaced with our own which
+  # is capable of loading gems on demand.
+  #
+  # When you call <tt>require 'x'</tt>, this is what happens:
+  # * If the file can be loaded from the existing Ruby loadpath, it
+  #   is.
+  # * Otherwise, installed gems are searched for a file that matches.
+  #   If it's found in gem 'y', that gem is activated (added to the
+  #   loadpath).
+  #
+  # The normal <tt>require</tt> functionality of returning false if
+  # that file has already been loaded is preserved.
+
+  def require(path) # :doc:
+    gem_original_require path
+  rescue LoadError => load_error
+    if load_error.message.end_with?(path)
+      if Gem.try_activate(path)
+        return gem_original_require(path)
+      end
+    end
+
+    raise load_error
+  end
+
+  private :require
+  private :gem_original_require
+
+end unless Kernel.private_method_defined?(:gem_original_require)
+

data/data/irbrc

@@ -0,0 +1,55 @@
+# -*- Ruby -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# We use this as the default startup file for irb inside trepan
+# Down the line we will have a way for folks to add/override this
+# with their own file.
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+IRB.conf[:PROMPT][:SIMPLE] = 
+    {:PROMPT_C=>"trepan ?> ",
+     :PROMPT_I=>"trepan >> ",
+     :PROMPT_N=>"trepan >> ",
+     :PROMPT_S=>nil,
+     :RETURN=>"=> %s\n"}
+
+# Using dbgr to issue a debugger statement inside irb:
+#  dbgr %w(info program)
+#  dbgr 'info program'  # also works
+# But...
+#  dbgr info program    # wrong!
+# 
+puts "You are in a trepan session. You should have access to program scope."
+puts "'dbgr', 'step', 'n', 'q', 'cont' commands have been added."
+
+if defined?($trepan) && $trepan
+   puts 'You should have access to debugger state via global variable $trepan'
+end
+if defined?($trepan_frame) && $trepan_frame
+   puts 'You should have access to the program frame via global variable $trepan_frame'
+end
+if defined?($trepan_cmdproc) && $trepan_cmdproc
+   puts 'You should have access to the command processor via global variable $trepan_cmdproc'
+end
+
+# Monkeypatch to save the current IRB statement to be run and make the instruction sequence
+# "filename" unique. Possibly not needed.
+class IRB::Context
+  def evaluate(line, line_no)
+    $trepan_irb_statements = line
+    @line_no = line_no
+    @eval_counter ||= 0
+    container = 
+      if irb_path =~ /\((.+)\)/
+        # Note we originally had a colon below. This causes IRB to think
+        # tracebacks are IRB bugs since the regexp matching it uses here
+        # is now messed up. (irb:5): in ... vs (irb): in ...
+        "(#{$1}[#{@eval_counter}])" 
+      else
+        irb_path
+      end
+    set_last_value(@workspace.evaluate(self, line, container, line_no))
+#    @workspace.evaluate("_ = IRB.conf[:MAIN_CONTEXT]._")
+#    @_ = @workspace.evaluate(line, irb_path, line_no)
+    @eval_counter += 1
+  end
+end
+

data/data/prelude.rb

@@ -0,0 +1,38 @@
+
+# Mutex
+
+class Mutex
+  def synchronize
+    self.lock
+    begin
+      yield
+    ensure
+      self.unlock rescue nil
+    end
+  end
+end
+
+# Thread
+
+class Thread
+  MUTEX_FOR_THREAD_EXCLUSIVE = Mutex.new
+  def self.exclusive
+    MUTEX_FOR_THREAD_EXCLUSIVE.synchronize{
+      yield
+    }
+  end
+end
+
+module Kernel
+  module_function
+  def require_relative(relative_feature)
+    c = caller.first
+    e = c.rindex(/:\d+:in /)
+    file = $`
+    if /\A\((.*)\)/ =~ file # eval, etc.
+      raise LoadError, "require_relative is called in #{$1}"
+    end
+    absolute_feature = File.expand_path(File.join(File.dirname(file), relative_feature))
+    require absolute_feature
+  end
+end

data/interface/base_intf.rb

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# A base class for a debugger interface.
+
+class Trepan
+
+  unless defined?(NotImplementedMessage)
+    NotImplementedMessage = 'This method must be overriden in a subclass'
+  end
+
+  # A debugger interface handles the communication or interaction with between
+  # the program and the outside portion which could be
+  #  - a user, 
+  #  - a front-end that talks to a user, or
+  #  - another interface in another process or computer
+  class Interface
+
+    attr_accessor :interactive, :input, :output
+
+    unless defined?(YES)
+      YES = %w(y yes oui si yep ja)
+      NO  = %w(n no non nope nein)
+      YES_OR_NO = YES + NO
+    end
+
+    def initialize(inp=nil, out=nil, opts={})
+      @input       = inp || STDIN
+      @interactive = false 
+      @opts        = opts
+      @output      = out || STDOUT
+    end
+
+    # Closes all input and/or output.
+    def close
+      @input.close  unless @input.closed?
+      @output.close unless @output.closed?
+    end
+
+    # Called when a dangerous action is about to be done to make sure
+    # it's okay. `prompt' is printed; user response is returned.
+    def confirm(prompt, default=false)
+      raise RuntimeError, Trepan::NotImplementedMessage
+    end
+
+    # Common routine for reporting debugger error messages.
+    def errmsg(str, prefix='** ')
+      if str.is_a?(Array)
+        str.each{|s| errmsg(s)}
+      else
+        str.split("\n").each do |s|
+          msg("%s%s" % [prefix, s])
+        end
+      end
+    end
+
+    def finalize(last_wishes=nil)
+      close
+    end
+
+    # Return true if interface is interactive.
+    def interactive?
+      # Default false and making subclasses figure out how to determine
+      # interactiveness.
+      false 
+    end
+
+    # used to write to a debugger that is connected to this
+    # server; `str' written will have a newline added to it.
+    def msg(message)
+      if message.is_a?(Array)
+        message.each{|s| msg(s)}
+      else
+        message = message ? message.to_s + "\n" : ''
+        @output.write(message)
+      end
+    end
+
+    # used to write to a debugger that is connected to this
+    # server; `str' written will not have a newline added to it
+    def msg_nocr(msg)
+      @output.write(msg)
+    end
+
+    def read_command( prompt)
+      raise RuntimeError, Trepan::NotImplementedMessage
+    end
+
+    def readline(prompt='')
+      @output.flush
+      @output.write(prompt) if prompt and prompt.size > 0
+      @input.readline
+    end
+  end
+end

data/interface/script.rb

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Module for reading debugger scripts
+
+# Our local modules
+require_relative 'base_intf'
+require_relative '../io/input'
+require_relative '../io/string_array'
+
+# Interface when reading debugger scripts
+class Trepan::ScriptInterface < Trepan::Interface
+
+  DEFAULT_OPTS = {
+    :abort_on_error => true,
+    :confirm_val    => false,
+    :verbose        => false
+  } unless defined?(DEFAULT_OPTS)
+  
+  def initialize(script_name, out=nil, opts={})
+
+    @opts = DEFAULT_OPTS.merge(opts)
+
+    at_exit { finalize }
+    @script_name     = script_name
+    @input_lineno    = 0
+    @input           = Trepan::UserInput.open(script_name,
+                                                :line_edit => false)
+    @buffer_output   = []
+    unless opts[:verbose] or out
+      out = Trepan::StringArrayOutput.open(@buffer_output)
+    end
+    super(@input, out, @opts)
+  end
+
+  # Closes input only.
+  def close
+    @input.close
+  end
+
+  # Called when a dangerous action is about to be done, to make
+  # sure it's okay.
+  #
+  # Could look also look for interactive input and
+  # use that. For now, though we'll simplify.
+  def confirm(prompt, default)
+    @opts[:default_confirm]
+  end
+
+  # Common routine for reporting debugger error messages.
+  # 
+  def errmsg(msg, prefix="*** ")
+    #  self.verbose shows lines so we don't have to duplicate info
+    #  here. Perhaps there should be a 'terse' mode to never show
+    #  position info.
+    mess = if not @opts[:verbose]
+             location = ("%s:%s: Error in source command file" %
+                         [@script_name, @input_lineno])
+             "%s%s:\n%s%s" % [prefix, location, prefix, msg]
+           else
+             "%s%s" % [prefix, msg]
+           end
+    msg(mess)
+    # FIXME: should we just set a flag and report eof? to be more
+    # consistent with File and IO?
+    raise IOError if @opts[:abort_on_error]
+  end
+
+  def interactive? ; false end
+    
+  # Script interface to read a command. `prompt' is a parameter for 
+  # compatibilty and is ignored.
+  def read_command(prompt='')
+    @input_lineno += 1
+    line = readline
+    if @opts[:verbose]
+      location = "%s line %s" % [@script_name, @input_lineno]
+      msg('+ %s: %s' % [location, line])
+    end
+    # Do something with history?
+    return line
+  end
+
+  # Script interface to read a line. `prompt' is a parameter for 
+  # compatibilty and is ignored.
+  #
+  # Could decide make this look for interactive input?
+  def readline(prompt='')
+    begin 
+      return input.readline().chomp
+    rescue EOFError
+      @eof = true
+      raise EOFError
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  intf = Trepan::ScriptInterface.new(__FILE__)
+  line = intf.readline()
+  print "Line read: ", line
+end

data/interface/user.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Interface when communicating with the user in the same process as
+# the debugged program.
+
+# Our local modules
+
+require_relative 'base_intf'
+require_relative '../io/input'
+
+# Moutput    = import_relative('dbg_output', '..io', 'pydbgr')
+
+# Interface when communicating with the user in the same
+# process as the debugged program.
+class Trepan::UserInterface < Trepan::Interface
+
+  FILE_HISTORY = '.trapan_hist' unless defined?(FILE_HISTORY)
+
+  def initialize(inp=nil, out=nil, opts={})
+    super(inp, out, opts)
+    @input = if inp.class.ancestors.member?(Trepan::InputBase)
+               inp
+             else
+               Trepan::UserInput.open(inp)
+             end
+  end
+
+  # Closes both input and output
+
+  # Called when a dangerous action is about to be done, to make
+  # sure it's okay. Expect a yes/no answer to `prompt' which is printed,
+  # suffixed with a question mark and the default value.  The user
+  # response converted to a boolean is returned.
+  def confirm(prompt, default)
+    default_str = default ? 'Y/n' : 'N/y'
+    while true do
+      begin 
+        response = readline('%s (%s) ' % [prompt, default_str])
+      rescue EOFError
+        return default
+      end
+      response = response.strip.downcase
+
+      # We don't catch "Yes, I'm sure" or "NO!", but I leave that 
+      # as an exercise for the reader.
+      break if YES_OR_NO.member?(response)
+      msg "Please answer 'yes' or 'no'. Try again."
+    end
+    return YES.member?(response)
+  end
+
+  def finalize(last_wishes=nil)
+    # print exit annotation
+    # save history
+    super
+  end
+
+  def interactive? ; @input.interactive? end
+
+  def read_command(prompt='')
+    line = readline(prompt)
+    # FIXME: Do something with history?
+    return line
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  intf = Trepan::UserInterface.new
+  intf.errmsg("Houston, we have a problem here!")
+  if ARGV.size > 0
+    begin
+      line = intf.readline("Type something: ")
+    rescue EOFError
+      puts "No input, got EOF"
+    else
+      puts "You typed: #{line}"
+    end
+    puts "EOF is now: %s" % intf.input.eof?.inspect
+    unless intf.input.eof?
+      line = intf.confirm("Are you sure", false)
+      puts "You typed: #{line}"
+      puts "EOF is now: %s" % intf.input.eof?.inspect
+      line = intf.confirm("Are you not sure", true)
+      puts "You typed: #{line}"
+      puts "EOF is now: %s" % intf.input.eof?.inspect
+    end
+  end
+end

data/io/base_io.rb

@@ -0,0 +1,92 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# classes to support communication to and from the debugger.  This
+# communcation might be to/from another process or another computer.
+# And reading may be from a debugger command script.
+# 
+# For example, we'd like to support Sockets, and serial lines and file
+# reading, as well a readline-type input. Encryption and Authentication
+# methods might decorate some of the communication channels.
+# 
+# Some ideas originiated as part of Matt Fleming's 2006 Google Summer of
+# Code project.
+
+class Trepan
+
+  NotImplementedMessage = 'This method must be overriden in a subclass' unless
+    defined?(NotImplementedMessage)
+  
+  class InputBase
+    attr_reader   :input
+    attr_reader   :line_edit
+
+    DEFAULT_OPTS = {
+      :line_edit => false,
+    } unless defined?(DEFAULT_OPTS)
+
+    def initialize(inp, opts={})
+      @opts      = DEFAULT_OPTS.merge(opts)
+      @input     = inp
+      @line_edit = opts[:line_edit]
+    end
+
+    def close
+      @input.close unless @input.closed?
+    end
+
+    def eof? 
+      begin
+        @input.eof?
+      rescue IOError
+        true
+      end
+    end
+
+    # Read a line of input. EOFError will be raised on EOF.  
+    #
+    #   Note that we don't support prompting first. Instead, arrange
+    #  to call Trepan::Output.write() first with the prompt. If
+    # `use_raw' is set raw_input() will be used in that is supported
+    #    by the specific input input. If this option is left None as is
+    #    normally expected the value from the class initialization is
+    #    used.
+    def readline
+      @input.readline
+    end
+  end
+
+  # This is an abstract class that specifies debugger output.
+  class OutputBase
+    attr_accessor :flush_after_write
+    attr_reader   :output
+    def initialize(out, opts={})
+      @output = out
+      @flush_after_write = false
+    end
+
+    def close
+      @output.close if @output
+    end
+
+    def eof? 
+      @input.eof?
+    end
+
+    def flush
+      @output.flush
+    end
+
+    # Use this to set where to write to. output can be a 
+    # file object or a string. This code raises IOError on error.
+    def write(*args)
+      @output.print(*args)
+    end
+
+    # used to write to a debugger that is connected to this
+    # `str' written will have a newline added to it
+    #
+    def writeline( msg)
+      @output.write("%s\n" % msg)
+    end
+  end
+end
+

data/io/input.rb

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Debugger user/command-oriented input possibly attached to IO-style
+# input or GNU Readline.
+# 
+
+require_relative 'base_io'
+
+class Trepan
+
+  # Debugger user/command-oriented input possibly attached to IO-style
+  # input or GNU Readline.
+  class UserInput < Trepan::InputBase
+
+    def initialize(inp, opts={})
+      @opts      = DEFAULT_OPTS.merge(opts)
+      @input     = inp || STDIN
+      @eof       = false
+    end
+
+    def closed?; @input.closed? end
+    def eof?; @eof end
+
+    def interactive? 
+      @input.respond_to?(:isatty) && @input.isatty
+    end
+
+    # Read a line of input. EOFError will be raised on EOF.  
+    # 
+    # Note that we don't support prompting first. Instead, arrange
+    # to call Trepan::Output.write() first with the prompt. 
+    def readline
+      # FIXME we don't do command completion.
+      raise EOFError if eof?
+      begin 
+        line = @opts[:line_edit] ? Readline.readline : @input.gets
+        @eof = !line
+      rescue
+        @eof = true
+      end
+      raise EOFError if eof?
+      return line
+    end
+    
+    class << self
+      # Use this to set where to read from. 
+      #
+      # Set opts[:line_edit] if you want this input to interact with
+      # GNU-like readline library. By default, we will assume to try
+      # using readline. 
+      def open(inp=nil, opts={})
+        inp ||= STDIN
+        inp = File.new(inp, 'r') if inp.is_a?(String)
+        opts[:line_edit] = false unless
+          inp.respond_to?(:isatty) && inp.isatty && Trepan::GNU_readline?
+        self.new(inp, opts)
+      end
+    end
+  end
+end
+
+def Trepan::GNU_readline?
+  begin
+    require 'readline'
+    return true
+  rescue LoadError
+    return false
+  end
+end
+    
+# Demo
+if __FILE__ == $0
+  puts 'Have GNU is: %s'  % Trepan::GNU_readline?
+  inp = Trepan::UserInput.open(__FILE__, :line_edit => false)
+  line = inp.readline
+  puts line
+  inp.close
+  filename = 'input.py'
+  begin
+    Trepan::UserInput.open(filename)
+  rescue
+    puts "Can't open #{filename} for reading: #{$!}"
+  end
+  inp = Trepan::UserInput.open(__FILE__, :line_edit => false)
+  while true
+    begin
+      inp.readline
+    rescue EOFError
+      break
+    end
+  end
+  begin
+    inp.readline
+  rescue EOFError
+      puts 'EOF handled correctly'
+  end
+
+  if ARGV.size > 0
+    inp = Trepan::UserInput.open
+    begin
+      print "Type some characters: "
+      line = inp.readline()
+      puts "You typed: %s" % line
+    rescue EOFError
+      puts 'Got EOF'
+    end
+  end
+end
+
+