trepanning 0.1.0 → 0.1.1

data/app/yarv.rb

@@ -107,6 +107,10 @@ module CodeRay
             state = :expect_another_operand
             if match = scan(/^(\d+)/)
               tokens << [match, :integer]
+              if match = scan(/^[.]{2}\d+/)
+                tokens << ['..', :operator]
+                tokens << [match[2..-1], :integer]
+              end
             elsif match = scan(/\/.*\//)
               # Really a regular expression
               tokens << [match, :entity]
@@ -118,6 +122,9 @@ module CodeRay
               tokens << [match, :pre_constant]
             elsif match = scan(/nil|true|false/)
               tokens << [match, :pre_constant]
+            elsif match = scan(/block in (?:<.+>|[^,]+)/)
+              tokens << ["block in ", :variable]
+              tokens << [match['block in '.size..-1], :content]
             elsif match = scan(/[A-Za-z_][_A-Za-z0-9?!]*/)
               tokens << [match, :variable]
             elsif match = scan(/^#[^, \n]*/)
@@ -157,7 +164,6 @@ if __FILE__ == $0
   require 'term/ansicolor'
   ruby_scanner = CodeRay.scanner :yarv
 string='
-     0045 opt_regexpmatch1 /^-e$/
      0000 trace            1                                              (   9)
      0002 putnil           
      0003 putstring        "irb"
@@ -174,6 +180,10 @@ string='
      0029 setinlinecache   <ic:2>
      0031 putstring        "/usr/local/bin/irb"
      0033 send             :start, 1, nil, 0, <ic:3>
+     0026 putobject        0..1
+     0030 send             :map, 0, block in <top gcd.rb>, 0, <ic:3>
+     0177 send             :catch, 1, block in start, 8, <ic:23>
+     0045 opt_regexpmatch1 /^-e$/
 '  
   yarv_scanner = CodeRay.scanner :yarv
   tokens = yarv_scanner.tokenize(string)

data/bin/.gitignore

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

data/bin/trepan

@@ -48,18 +48,18 @@ if File.basename(__FILE__) == File.basename($0)
       end
     end
 
-    program_to_debug = ARGV.shift
-    program_to_debug = whence_file(program_to_debug) unless 
-      File.exist?(program_to_debug)
+    program_to_debug = (Trepan::PROG_UNRESOLVED_SCRIPT = ARGV.shift).dup
+    program_to_debug = whence_file(Trepan::PROG_UNRESOLVED_SCRIPT) unless 
+      File.exist?(Trepan::PROG_UNRESOLVED_SCRIPT)
     Trepan::PROG_SCRIPT = program_to_debug
 
-    # Set global so others may use this debugger.
-    
     opts = {}
-    %w(cmdfiles initial_dir host nx port server highlight).each do |opt|
+    %w(cmdfiles highlight initial_dir host nx port readline server 
+      ).each do |opt|
       opts[opt.to_sym] = options[opt.to_sym]
     end
 
+    # Set global so others may use this debugger.
     $trepan = Trepan.new(opts)
     debug_program($trepan, Trepan::RUBY_PATH, 
                   File.expand_path(program_to_debug))

data/data/.gitignore

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

data/interface/.gitignore

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

data/interface/base_intf.rb

@@ -16,7 +16,7 @@ class Trepan
   #  - another interface in another process or computer
   class Interface
 
-    attr_accessor :interactive, :input, :output
+    attr_accessor :history_io, :history_save, :interactive, :input, :output
 
     unless defined?(YES)
       YES = %w(y yes oui si yep ja)
@@ -25,10 +25,14 @@ class Trepan
     end
 
     def initialize(inp=nil, out=nil, opts={})
-      @input       = inp || STDIN
-      @interactive = false 
-      @opts        = opts
-      @output      = out || STDOUT
+      @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.

data/interface/comcodes.rb

@@ -6,13 +6,15 @@ module Trepanning
   # Most of these go from debugged process to front-end
   # client interface. COMMAND goes the other way.
   module RemoteCommunication
-    PRINT         = '.'
-    COMMAND       = 'C'
-    CONFIRM_TRUE  = 'Y'
-    CONFIRM_FALSE = 'N'
-    CONFIRM_REPLY = '?'
-    QUIT          = 'q'
-    PROMPT        = 'p'
-    RESTART       = 'r'
+    unless defined?(PRINT)
+      PRINT         = '.'
+      COMMAND       = 'C'
+      CONFIRM_TRUE  = 'Y'
+      CONFIRM_FALSE = 'N'
+      CONFIRM_REPLY = '?'
+      QUIT          = 'q'
+      PROMPT        = 'p'
+      RESTART       = 'r'
+    end
   end
 end

data/interface/user.rb

@@ -1,37 +1,47 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 
-# Interface when communicating with the user in the same process as
-# the debugged program.
+# Interface when communicating with the user.
 
 # 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.
+# Interface when communicating with the user.
 class Trepan::UserInterface < Trepan::Interface
 
-  FILE_HISTORY = '.trapan_hist' unless defined?(FILE_HISTORY)
+  DEFAULT_USER_OPTS = {
+    :readline   => true,                # Try to use GNU Readline?
+    
+    # The below are only used if we want and have readline support.
+    # See method Trepan::GNU_readline? below.
+    :histsize => 256,                   # Use gdb's default setting
+    :file_history   => '.trepan_hist',  # where history file lives
+                                        # Note a directory will 
+                                        # be appended
+    :history_save   => true             # do we save the history?
+  } unless defined?(DEFAULT_USER_OPTS)
 
   def initialize(inp=nil, out=nil, opts={})
     super(inp, out, opts)
+    @opts = DEFAULT_USER_OPTS.merge(opts)
     @input = if inp.class.ancestors.member?(Trepan::InputBase)
                inp
              else
-               Trepan::UserInput.open(inp)
+               Trepan::UserInput.open(inp, {:readline => opts[:readline]})
              end
+    if Trepan::GNU_readline? && @opts[:complete]
+      Readline.completion_proc = @opts[:complete]
+      read_history
+    end
+    at_exit { finalize }
   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.
+  # FIXME: make common routine for this and server.rb
   def confirm(prompt, default)
     default_str = default ? 'Y/n' : 'N/y'
     while true do
@@ -50,19 +60,68 @@ class Trepan::UserInterface < Trepan::Interface
     return YES.member?(response)
   end
 
+  # Read a saved Readline history file into Readline. The history
+  # file will be created if it doesn't already exist.
+  # Much of this code follows what's done in ruby-debug.
+  def read_history 
+    unless @histfile
+      dirname = ENV['HOME'] || ENV['HOMEPATH'] || File.expand_path('~')
+      @histfile = File.join(dirname, @opts[:file_history])
+    end
+    @histsize ||= (ENV['HISTSIZE'] ? ENV['HISTSIZE'].to_i : @opts[:histsize])
+    Readline.completion_proc = @opts[:complete]
+    if File.exists?(@histfile)
+      lines = IO::readlines(@histfile).last(@histsize).collect do  
+        |line| line.chomp 
+      end
+      Readline::HISTORY.push(*lines)
+      @history_io = File.new(@histfile, "a")
+    else
+      @history_io = File.new(@histfile, "w")
+    end
+    @history_io.sync = true
+    @history_save = @opts[:history_save]
+  end
+
+  def save_history 
+    if @histfile
+      lines = Readline::HISTORY.to_a
+      lines = lines[-@histsize, @histsize] if lines.size > @histsize
+      begin
+        open(@histfile, 'w') do |file|
+          Readline::HISTORY.to_a.last(@histsize).each do |line|
+            file.puts line
+          end 
+        end if defined?(@history_save) and @history_save
+      rescue
+      end
+    end
+  end
+
   def finalize(last_wishes=nil)
-    # print exit annotation
-    # save history
+    # ?? print gdb-style exit annotation if annotate = 2?
+    if Trepan::GNU_readline? && @history_save
+      save_history 
+    end
     super
   end
 
   def interactive? ; @input.interactive? end
 
   def read_command(prompt='')
-    line = readline(prompt)
-    # FIXME: Do something with history?
-    return line
+    readline(prompt) 
   end
+
+  def readline(prompt='')
+    @output.flush
+    if @input.line_edit && @opts[:readline]
+      @input.readline(prompt)
+    else
+      @output.write(prompt) if prompt and prompt.size > 0
+      @input.readline
+    end
+  end
+
 end
 
 # Demo

data/io/.gitignore

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

data/io/input.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 
 # Debugger user/command-oriented input possibly attached to IO-style
 # input or GNU Readline.
@@ -13,10 +13,14 @@ class Trepan
   # input or GNU Readline.
   class UserInput < Trepan::InputBase
 
+    @@readline_finalized = false
+
     def initialize(inp, opts={})
-      @opts      = DEFAULT_OPTS.merge(opts)
-      @input     = inp || STDIN
-      @eof       = false
+      @opts         = DEFAULT_OPTS.merge(opts)
+      @input        = inp || STDIN
+      @eof          = false
+      @line_edit    = @opts[:line_edit]
+      @use_readline = @opts[:readline]
     end
 
     def closed?; @input.closed? end
@@ -25,20 +29,24 @@ class Trepan
     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.
+    def readline(prompt='')
       raise EOFError if eof?
       begin 
-        line = @opts[:line_edit] ? Readline.readline : @input.gets
-        @eof = !line
-      rescue
+        if @line_edit && @use_readline
+          line = Readline.readline(prompt, true)
+        else
+          line = @input.gets
+          end
+      rescue Interrupt
+        return ''
+      rescue EOFError
+      rescue => e
+        puts $!.backtrace
+        puts "Exception caught #{e.inspect}"
         @eof = true
       end
+      @eof = !line
       raise EOFError if eof?
       return line
     end
@@ -52,17 +60,33 @@ class Trepan
       def open(inp=nil, opts={})
         inp ||= STDIN
         inp = File.new(inp, 'r') if inp.is_a?(String)
-        opts[:line_edit] = false unless
+        opts[:line_edit] = @line_edit = 
           inp.respond_to?(:isatty) && inp.isatty && Trepan::GNU_readline?
         self.new(inp, opts)
       end
+
+      def finalize
+       if defined?(RbReadline) && !@@readline_finalized
+          begin 
+            RbReadline.rl_cleanup_after_signal()
+          rescue
+          end
+          begin 
+            RbReadline.rl_deprep_terminal()
+          rescue
+          end
+          @@readline_finalized = true
+        end
+      end
     end
   end
 end
 
 def Trepan::GNU_readline?
   begin
-    require 'readline'
+    return @have_readline unless @have_readline.nil?
+    @have_readline = require 'readline'
+    at_exit { Trepan::UserInput::finalize }
     return true
   rescue LoadError
     return false

data/io/tcpclient.rb

@@ -19,6 +19,8 @@ class Trepan
       :port    => 1027,  # Arbitrary non-privileged port
     }
 
+    attr_reader :state
+
     def initialize(opts={})
       @opts      = CLIENT_SOCKET_OPTS.merge(opts)
       @addr      = nil
@@ -33,7 +35,11 @@ class Trepan
     def close
       @state = :closing
       @inout.close if @inout
-      @state = :disconnnected
+      @state = :disconnected
+    end
+
+    def disconnected?
+      :disconnected == @state
     end
 
     def open(opts={})

data/io/tcpfns.rb

@@ -5,9 +5,11 @@
 module Trepanning
   module TCPPacking
 
-    TCP_MAX_PACKET = 8192 # Largest size for a recv
-    LOG_MAX_MSG    = Math.log10(TCP_MAX_PACKET).ceil
-
+    unless defined?(TCP_MAX_PACKET)
+      TCP_MAX_PACKET = 8192 # Largest size for a recv
+      LOG_MAX_MSG    = Math.log10(TCP_MAX_PACKET).ceil
+    end
+      
     def pack_msg(msg)
       fmt = '%%%dd' % LOG_MAX_MSG # A funny way of writing: '%4d'
       (fmt % msg.size) + msg

data/io/tcpserver.rb

@@ -12,16 +12,18 @@ class Trepan
   class TCPDbgServer < Trepan::InOutBase
 
     include Trepanning::TCPPacking
-    
-    DEFAULT_INIT_OPTS = {:open => true}
-    
-    SERVER_SOCKET_OPTS = {
-      :host    => Trepan::DEFAULT_SETTINGS[:host],
-      :port    => Trepan::DEFAULT_SETTINGS[:port], # A non-privileged port
-      :timeout => 5,     # FIXME: not used
-      :reuse   => true,  # FIXME: not used. Allow port to be resued on close?
-                         # Python has: 'posix' == os.name 
-    }
+
+    unless defined?(SERVER_SOCKET_OPTS)
+      DEFAULT_INIT_OPTS = {:open => true}
+      
+      SERVER_SOCKET_OPTS = {
+        :host    => Trepan::DEFAULT_SETTINGS[:host],
+        :port    => Trepan::DEFAULT_SETTINGS[:port], # A non-privileged port
+        :timeout => 5,     # FIXME: not used
+        :reuse   => true,  # FIXME: not used. Allow port to be resued on close?
+        # Python has: 'posix' == os.name 
+      }
+    end
 
     attr_reader :state
 
@@ -32,6 +34,7 @@ class Trepan
       @state   = :disconnected
       @port    = nil   # Current port in use
       @host    = nil   # current host in use
+      @line_edit = false
       open(@opts) if @opts[:open]
     end
 

data/lib/.gitignore

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

data/lib/trepanning.rb

@@ -1,7 +1,9 @@
 #!/usr/bin/env ruby
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 require 'trace'                          # Trace filtering
-require 'thread_frame'
+require 'thread_frame'                   # Stack frame introspection and more.
+require_relative '../app/complete'       # command completion
 require_relative '../app/core'           # core event-handling mechanism
 require_relative '../app/default'        # default debugger settings
 require_relative '../interface/user'     # user interface (includes I/O)
@@ -23,14 +25,15 @@ ISEQS__        = {} unless
 
 class Trepan
 
+  attr_reader   :completion_proc # GNU Readline completion proc
   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_accessor :restart_argv # How to restart us, empty or nil.
+                              # Note: restart_argv is typically C's
+                              # **argv, not Ruby's ARGV. So
+                              # restart_argv[0] is $0.
   attr_reader   :settings     # Hash[:symbol] of things you can configure
   attr_accessor :trace_filter # Procs/Methods we ignore.
 
@@ -45,11 +48,15 @@ class Trepan
     @input  = @settings[:input] || STDIN
     @output = @settings[:output] || STDOUT
 
+    @completion_proc = method(:completion_method)
+
     @intf = 
       if @settings[:server]
+        @completion_proc = nil
         opts = Trepan::ServerInterface::DEFAULT_INIT_CONNECTION_OPTS.dup
         opts[:port] = @settings[:port] if @settings[:port]
         opts[:host] = @settings[:host] if @settings[:host]
+        opts[:readline] = false
         puts("starting debugger in out-of-process mode port at " +
              "#{opts[:host]}:#{opts[:port]}")
         [Trepan::ServerInterface.new(nil, nil, opts)]
@@ -57,9 +64,13 @@ class Trepan
         opts = Trepan::ClientInterface::DEFAULT_INIT_CONNECTION_OPTS.dup
         opts[:port] = @settings[:port] if @settings[:port]
         opts[:host] = @settings[:host] if @settings[:host]
+        opts[:complete] = @completion_proc
+        opts[:readline] ||= @settings[:readline]
         [Trepan::ClientInterface.new(nil, nil, nil, nil, opts)]
       else
-        [Trepan::UserInterface.new(@input, @output)]
+        opts = {:complete => @completion_proc,
+                :readline => @settings[:readline]}
+        [Trepan::UserInterface.new(@input, @output, opts)]
       end
 
     process_cmdfile_setting(@settings)
@@ -94,8 +105,6 @@ class Trepan
 
     # 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
@@ -104,6 +113,29 @@ class Trepan
     th.exec_event_tracing  = false
   end
 
+  # The method is called when we want to do debugger command completion
+  # such as called from GNU Readline with <TAB>.
+  def completion_method(last_token, leading=Readline.line_buffer)
+    completion = @core.processor.complete(leading, last_token)
+    if 1 == completion.size 
+      completion_token = completion[0]
+      if last_token.end_with?(' ')
+        if last_token.rstrip == completion_token 
+          # There is nothing more to complete
+          []
+        else
+          []
+        end
+      else
+        [completion_token]
+      end
+    else
+      # We have multiple completions. Get the last token so that will
+      # be presented as a list of completions.
+      completion
+    end
+  end
+
   # To call from inside a Ruby program, there is one-time setup that 
   # needs to be done first:
   #    require 'trepanning'
@@ -148,6 +180,10 @@ class Trepan
       @core.processor.hidelevels[Thread.current] = 
         RubyVM::ThreadFrame.current.stack_size
     end
+    # unless defined?(PROG_UNRESOLVED_SCRIPT)
+    #  # We may later do more sophisticated things...
+    #  Trepan.const_set('PROG_UNRESOLVED_SCRIPT', RubyVM::OS_ARGV.index($0) ? $0 : nil)
+    # end
     th = Thread.current
     if block
       start
@@ -193,11 +229,10 @@ class Trepan
         return
       else
         stderr.puts "Command file '#{cmdfile}' does not exist."
-        stderr.puts caller
         return
       end
     end
-    @intf << Trepan::ScriptInterface.new(cmdfile, @output)
+    @intf << Trepan::ScriptInterface.new(cmdfile)
   end
 
   def add_startup_files()
@@ -246,8 +281,9 @@ class Trepan
     opts = {:hide_stack => false}.merge(opts)
     unless defined?($trepanning) && $trepanning.is_a?(Trepan)
       $trepanning = Trepan.new(opts)
-      $trepanning.trace_filter << self.method(:debug)
     end
+    tf = $trepanning.trace_filter
+    tf << self.method(:debugger) unless tf.member? self.method(:debugger)
     $trepanning.debugger(opts, &block)
   end
 
@@ -267,8 +303,9 @@ module Kernel
     opts = {:hide_stack => false}.merge(opts)
     unless defined?($trepanning) && $trepanning.is_a?(Trepan)
       $trepanning = Trepan.new(opts)
-      $trepanning.trace_filter << self.method(:debugger)
     end
+    tf = $trepanning.trace_filter
+    tf << self.method(:debugger) unless tf.member? self.method(:debugger)
     $trepanning.debugger(opts)
   end
 end