rb8-trepanning 0.1.3

data/app/run.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rbconfig'
+require 'rubygems'; require 'require_relative'
+module Trepan
+
+  module_function # All functions below are easily publically accessible
+
+  # Given a Ruby interpreter and program we are to debug, debug it.
+  # The caller must ensure that ARGV is set up to remove any debugger
+  # arguments or things that the debugged program isn't supposed to
+  # see.  FIXME: Should we make ARGV an explicit parameter?
+
+  def debug_program(ruby_path, options)
+    # Make sure Ruby script syntax checks okay.
+    # Otherwise we get a load message that looks like trepan8 has 
+    # a problem. 
+    output = `#{ruby_path} -c #{Trepan::PROG_SCRIPT.inspect} 2>&1`
+    if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+      puts output
+      exit $?.exitstatus 
+    end
+
+    %w(highlight basename).each do |opt|
+      opt = opt.to_sym
+      Debugger.handler.cmdproc.settings[opt] = options[opt]
+    end
+
+    # Record where we are we can know if the call stack has been
+    # truncated or not.
+    Trepan.start_sentinal=caller(0)[1]
+
+    bt = Debugger.debug_load(Trepan::PROG_SCRIPT, options[:stop], false)
+    if bt
+      if options[:post_mortem]
+        Debugger.handle_post_mortem(bt)
+      else
+        print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+        print "Uncaught exception: #{bt}\n"
+      end
+    end
+  end
+
+  # Do a shell-like path lookup for prog_script and return the results.
+  # If we can't find anything return prog_script.
+  def whence_file(prog_script)
+    if prog_script.index(File::SEPARATOR)
+      # Don't search since this name has path separator components
+      return prog_script
+    end
+    for dirname in ENV['PATH'].split(File::PATH_SEPARATOR) do
+      prog_script_try = File.join(dirname, prog_script)
+      return prog_script_try if File.readable?(prog_script_try)
+    end
+    # Failure
+    return prog_script
+  end
+end
+
+# Path name of Ruby interpreter we were invoked with. Is part of 
+# 1.9 but not necessarily 1.8.
+def RbConfig.ruby
+  File.join(RbConfig::CONFIG['bindir'],  
+            RbConfig::CONFIG['RUBY_INSTALL_NAME'] + 
+            RbConfig::CONFIG['EXEEXT'])
+end unless defined? RbConfig.ruby
+
+if __FILE__ == $0
+  # Demo it.
+  include  Trepan
+  puts whence_file('irb')
+  puts whence_file('probably-does-not-exist')
+  puts RbConfig.ruby
+end

data/app/util.rb

@@ -0,0 +1,65 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+module Trepan
+  module Util
+
+    module_function 
+    def safe_repr(str, max, elipsis='... ')
+      if str.is_a?(String) && max > 0 && str.size > max && !str.index("\n")
+        "%s%s%s" % [ str[0...max/2], elipsis,  str[str.size-max/2..str.size]]
+      else
+        str
+      end
+    end
+
+    # name is String and list is an Array of String.
+    # If name is a unique leading prefix of one of the entries of list,
+    # then return that. Otherwise return name.
+    def uniq_abbrev(list, name)
+      candidates = list.select do |try_name| 
+        try_name.start_with?(name)
+      end
+      candidates.size == 1 ? candidates.first : name
+    end
+
+    # extract the "expression" part of a line of source code.
+    # 
+    def extract_expression(text)
+      if text =~ /^\s*(?:if|elsif|unless)\s+/
+        text.gsub!(/^\s*(?:if|elsif|unless)\s+/,'') 
+        text.gsub!(/\s+then\s*$/, '')
+      elsif text =~ /^\s*(?:until|while)\s+/
+        text.gsub!(/^\s*(?:until|while)\s+/,'') 
+        text.gsub!(/\s+do\s*$/, '')
+      elsif text =~ /^\s*return\s+/
+        # EXPRESION in: return EXPRESSION
+        text.gsub!(/^\s*return\s+/,'')
+      elsif text =~ /^\s*case\s+/
+        # EXPRESSION in: case EXPESSION
+        text.gsub!(/^\s*case\s*/,'')
+      elsif text =~ /^\s*def\s*.*\(.+\)/
+        text.gsub!(/^\s*def\s*.*\((.*)\)/,'[\1]')
+      elsif text =~ /^\s*[A-Za-z_][A-Za-z0-9_\[\]]*\s*=[^=>]/
+        # RHS of an assignment statement.
+        text.gsub!(/^\s*[A-Za-z_][A-Za-z0-9_\[\]]*\s*=/,'')
+      end
+      return text
+    end
+  end
+end
+
+if __FILE__ == $0
+  include Trepan::Util
+  string = 'The time has come to talk of many things.'
+  puts safe_repr(string, 50)
+  puts safe_repr(string, 17)
+  puts safe_repr(string.inspect, 17)
+  puts safe_repr(string.inspect, 17, '')
+  ## puts "main script in above is #{locs.size() - 1 - find_main_script(locs)}"
+
+  list = %w(disassemble disable distance up)
+  p list
+  %w(dis disa u upper foo).each do |name|
+    puts "uniq_abbrev of #{name} is #{uniq_abbrev(list, name)}"
+  end
+end

data/bin/.gitignore

@@ -0,0 +1 @@
+/*~

data/bin/trepan8

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'rubygems'
+require 'ruby-debug-base'
+require 'optparse'
+require 'require_relative'
+require_relative '../app/run'
+require_relative '../app/options'
+require_relative '../interface/user'
+require_relative '../lib/trepanning'
+
+begin
+  eval(File.read(Trepan::CMD_INITFILE)) if File.exist?(Trepan::CMD_INITFILE)
+rescue
+end
+
+options = Trepan.copy_default_options
+opts = Trepan.setup_options(options)
+
+begin
+  if not defined? Trepan::ARGV
+    Trepan::ARGV = ARGV.clone
+  end
+  trepan8_path = File.expand_path($0)
+  if RUBY_PLATFORM =~ /mswin/
+    trepan8_path += '.cmd' unless trepan8_path =~ /\.cmd$/i
+  end
+  Trepan::PROG_UNRESOLVED_SCRIPT = trepan8_path
+  Trepan::TREPAN8_FILE = __FILE__
+  Trepan::INITIAL_DIR = Dir.pwd
+  opts.parse! ARGV
+rescue StandardError => e
+  puts opts
+  puts
+  puts e.message
+  exit(-1)
+end
+
+if options[:client]
+  Debugger.start_client(options[:host], options[:port])
+else
+  if ARGV.empty?
+    exit if $VERBOSE and not options[:verbose_long]
+    puts opts
+    puts
+    puts 'Must specify a script to run'
+    exit(-1)
+  end
+  
+  # save script name
+  prog_script = ARGV.shift
+  prog_script = Trepan::whence_file(prog_script) unless 
+    File.exist?(prog_script)
+  Trepan::PROG_SCRIPT = File.expand_path prog_script
+  
+  # install interruption handler
+  trap('INT') { Debugger.interrupt_last }
+  
+  # set options
+  Trepan.wait_connection = options[:wait]
+  Debugger.keep_frame_binding = options[:frame_bind]
+  
+  if options[:server]
+    # start remote mode
+    Debugger.start_remote(options[:host], [options[:port], options[:cport]], 
+                          options[:post_mortem]) do
+      # load initrc script
+      Trepan.add_startup_files unless options[:nx]
+    end
+    debug_program(RbConfig.ruby, options)
+  else
+    # Set up trace hook for debugger
+    Trepan.start
+    # start control thread
+    Trepan.start_control(options[:host], options[:cport]) if options[:control]
+
+    # load initrc script (e.g. .trepan8rc)
+    Trepan.add_startup_files unless options[:nx]
+    
+    # run startup script if specified
+    Trepan.add_command_file(options[:script]) if options[:script]
+
+    # activate post-mortem
+    Trepan.post_mortem if options[:post_mortem]
+    options[:stop] = false if options[:tracing]
+    Debugger.tracing = options[:tracing]
+
+    if !options[:quit]
+      if Debugger.started?
+        until Debugger.stop do end
+      end
+      begin
+        debug_program(RbConfig.ruby, options)
+      rescue SyntaxError
+        puts $!.backtrace.map{|l| "\t#{l}"}.join("\n")
+        puts "Uncaught Syntax Error\n"
+      rescue
+        print $!.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+        print "Uncaught exception: #{$!}\n"
+      end
+      print "The program finished.\n" unless 
+        Debugger.annotate.to_i > 1 # annotate has its own way
+      ## interface = Debugger::LocalInterface.new
+      interface = Trepan::UserInterface.new
+
+      # Not sure if ControlCommandProcessor is really the right
+      # thing to use. CommandProcessor requires a state.
+      processor = Debugger::ControlCommandProcessor.new(interface)
+      processor.process_commands
+    else
+      Trepan::debug_program(RbConfig.ruby, options)
+    end
+  end
+end

data/data/.gitignore

@@ -0,0 +1 @@
+/*~

data/data/irbrc

@@ -0,0 +1,41 @@
+# -*- Ruby -*-
+# Copyright (C) 2010, 2011 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=>"trepan8 ?> ",
+     :PROMPT_I=>"trepan8 >> ",
+     :PROMPT_N=>"trepan8 >> ",
+     :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', 'ne', '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.
+class IRB::Context
+  alias_method :_trepan_original_evaluate, :evaluate
+  def evaluate(line, line_no)
+    $trepan_irb_statements = line
+    _trepan_original_evaluate(line, line_no)
+  end
+end
+

data/interface/.gitignore

@@ -0,0 +1 @@
+/*~

data/interface/base_intf.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# A base class for a debugger interface.
+
+module 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, :history_io, :history_save, :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={})
+      @histfile     = nil
+      @history_io   = nil
+      @history_save = false
+      @histsize     = nil
+      @input        = inp || STDIN
+      @interactive  = false 
+      @opts         = opts
+      @output       = out || STDOUT
+    end
+
+    # Closes all input and/or output.
+    def close
+      @input.close  unless !@input || @input.closed?
+      @output.close unless !@output || @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)
+      if @output && !@output.closed?
+        msg "%sThat's all, folks..." % 
+          (defined?(Trepan::PROGRAM) ? "#{Trepan::PROGRAM}: " : '')
+      end
+      close
+    end
+
+    def input_eof?
+      @input.eof?
+    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='')
+      line = readline(prompt)
+      # FIXME: Do something with history?
+      return line
+    end
+
+    def readline(prompt='')
+      @output.flush
+      @output.write(prompt) if prompt and prompt.size > 0
+      @input.readline
+    end
+  end
+end

data/interface/client.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Interface for client (i.e. user to communication-device) interaction.
+# The debugged program is at the other end of the communcation.
+
+require 'rubygems'; require 'require_relative'
+require_relative 'user'
+require_relative '../io/tcpclient'
+require_relative 'comcodes'
+
+# Interface for a user which is attached to a debugged process via
+# some sort of communication medium (e.g. socket, tty, FIFOs).  This
+# could be on the same computer in a different process or on a remote
+# computer.
+class Trepan::ClientInterface < Trepan::Interface
+  
+  DEFAULT_INIT_CONNECTION_OPTS = {
+    :open => true,
+    :io   => :tcp
+  }
+  
+  def initialize(inp=nil, out=nil, inout=nil, user_opts={}, 
+                 connection_opts={})
+    
+    @connection_opts = DEFAULT_INIT_CONNECTION_OPTS.merge(connection_opts)
+    
+    @user = Trepan::UserInterface.new(inp, out, user_opts)
+    
+    @inout = 
+      if inout
+        inout 
+      else
+        # @server_type = @connection_opts[:io]
+        # if 'FIFO' == self.server_type
+        #   Mfifoclient.FIFOClient(opts=@connection_opts)
+        # elsif :tcp == self.server_type
+        Trepan::TCPDbgClient.new(@connection_opts)
+        # else
+        #   errmsg("Expecting server type TCP or FIFO. Got: %s." %
+        #          self.server_type)
+        #   return
+        # end
+      end
+  end
+  
+  def closed?
+    @inout.closed?
+  end
+
+  def confirm(prompt, default)
+    @user.confirm(prompt, default)
+  end
+  
+  def read_command(prompt='')
+    @user.read_command(prompt)
+  end
+  
+  # Send a message back to the server (in contrast to the local user
+  # output channel).
+  def read_remote
+    coded_line = nil
+    until coded_line
+      coded_line = @inout.read_msg
+    end
+    control = coded_line[0..0]
+    remote_line = coded_line[1..-1]
+    [control, remote_line]
+  end
+  
+  # Send a message back to the server (in contrast to the local user
+  # output channel).
+  def write_remote(code, msg)
+    # FIXME change into write_xxx
+    @inout.writeline(code + msg)
+  end
+end
+
+# Demo
+if __FILE__ == $0
+    intf = Trepan::ClientInterface.new
+end