rb8-trepanning 0.1.3

data/interface/comcodes.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Communication status codes
+module Trepanning
+  # Most of these go from debugged process to front-end
+  # client interface. COMMAND goes the other way.
+  module RemoteCommunication
+    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/script.rb

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Module for reading debugger scripts
+
+# Our local modules
+require 'rubygems'; require 'require_relative'
+require_relative 'base_intf'
+require_relative '../io/input'
+require_relative '../io/string_array'
+
+# Interface when reading debugger scripts
+class Trepan::ScriptInterface < Trepan::Interface
+  attr_accessor :opts, :output
+
+  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           = opts[: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]
+      script_name = 
+        if @opts[:basename] 
+          File.basename(@script_name)
+        else 
+          @script_name
+        end
+      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/server.rb

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Our local modules
+require 'rubygems'; require 'require_relative'
+require_relative 'base_intf'
+require_relative 'comcodes'
+require_relative '../io/input'
+require_relative '../io/tcpserver'
+
+# Mfifoserver = import_relative('fifoserver', '..io', 'pydbgr')
+
+# Interface for debugging a program but having user control
+# reside outside of the debugged process, possibly on another
+# computer
+class Trepan::ServerInterface < Trepan::Interface
+
+  include Trepanning::RemoteCommunication
+
+  DEFAULT_INIT_CONNECTION_OPTS = {
+    :io => 'TCP'
+  } unless defined?(DEFAULT_INIT_CONNECTION_OPTS)
+
+  def initialize(inout=nil, out=nil, connection_opts={})
+
+    @connection_opts = DEFAULT_INIT_CONNECTION_OPTS.merge(connection_opts)
+
+    at_exit { finalize }
+    @inout = 
+      if inout
+        inout
+      else
+        server_type = @connection_opts[:io]
+        # FIXME: complete this.
+        # if 'FIFO' == server_type
+        #     FIFOServer.new
+        # else
+        Trepan::TCPDbgServer.new(@connection_opts)
+        # end
+      end
+    # For Compatability 
+    @output = @inout
+    @input  = @inout
+    @interactive = true # Or at least so we think initially
+  end
+  
+  # Closes both input and output
+  def close
+    if @inout && @inout.connected?
+      @inout.write(QUIT + 'bye')
+      @inout.close 
+    end
+  end
+  
+  def closed?
+    @inout.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.
+  # FIXME: make common routine for this and user.rb
+  def confirm(prompt, default)
+    while true
+      begin
+        write_confirm(prompt, default)
+        reply = readline(nil).strip.downcase
+      rescue EOFError
+        return default
+      end
+      if YES.member?(reply)
+        return true
+      elsif NO.member?(reply)
+        return false
+      else
+        msg "Please answer 'yes' or 'no'. Try again."
+      end
+    end
+    return default
+  end
+  
+  # Return true if we are connected
+  def connected?
+    :connected == @inout.state
+  end
+    
+  # print exit annotation
+  def finalize(last_wishes=QUIT)
+    @inout.writeline(last_wishes) if connected?
+    close
+  end
+  
+  def input_eof?
+    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(msg)
+    @inout.writeline(PRINT + msg)
+  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)
+    @inout.write(PRINT +  msg)
+  end
+  
+  def read_command(prompt)
+    readline(prompt)
+  end
+  
+  def read_data
+    @inout.read_dat
+  end
+  
+  def readline(prompt, add_to_history=true)
+    if prompt
+      write_prompt(prompt)
+    end
+    coded_line = @inout.read_msg()
+    @read_ctrl = coded_line[0..0]
+    coded_line[1..-1]
+  end
+  
+  # Return connected
+  def state
+    @inout.state
+  end
+  
+  def write_prompt(prompt)
+    @inout.write(PROMPT + prompt)
+  end
+  
+  def write_confirm(prompt, default)
+    if default
+      code = CONFIRM_TRUE
+    else
+      code = CONFIRM_FALSE
+    end
+    @inout.write(code + prompt)
+  end
+end
+    
+# Demo
+if __FILE__ == $0
+  intf = Trepan::ServerInterface.new(nil, nil, :open => false)
+end

data/interface/user.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Interface when communicating with the user.
+
+# Our local modules
+
+require 'rubygems'; require 'require_relative'
+require_relative 'base_intf'
+require_relative '../io/input'
+
+# Interface when communicating with the user.
+class Trepan::UserInterface < Trepan::Interface
+
+  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   => '.trepan8_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, {:readline => opts[:readline]})
+             end
+    if Trepan::GNU_readline? && @opts[:complete]
+      Readline.completion_proc = @opts[:complete]
+      read_history
+    end
+    ## at_exit { finalize }
+  end
+
+  def closed?
+    @input.closed? && @output.closed?
+  end
+
+  # 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
+      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
+
+  # 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 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='')
+    readline(prompt) 
+  end
+
+  def readline(prompt='')
+    @output.flush
+    if @input.line_edit && @opts[:readline]
+      if Trepan::GNU_readline? && @opts[:complete]
+        Readline.completion_proc = @opts[:complete]
+      end
+      # rb-readline 0.4.0 has bugs
+      begin
+        @input.readline(prompt)
+      rescue Exception => e
+        @output.write("Exception: #{e} in readline\n")
+        ''
+      end
+    else
+      @output.write(prompt) if prompt and prompt.size > 0
+      @input.readline
+    end
+  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
+  puts "User interface closed?: #{intf.closed?}"
+end

data/io/base_io.rb

@@ -0,0 +1,148 @@
+# Copyright (C) 2010, 2011 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.
+
+module 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
+      @eof    = false
+    end
+
+    def close
+      @output.close if @output
+      @eof = true
+    end
+
+    def eof? 
+      @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
+
+  # This is an abstract class that specifies debugger input output when
+  # handled by the same channel, e.g. a socket or tty.
+  #
+  class InOutBase
+    
+    def initialize(inout, opts={})
+      @opts = DEFAULT_OPTS.merge(opts)
+      @inout = inout
+    end
+    
+    def close
+      @inout.close() if @inout
+    end
+    
+    def eof? 
+      begin
+        @input.eof?
+      rescue IOError
+        true
+      end
+    end
+
+    def flush
+      @inout.flush
+    end
+    
+    # Read a line of input. EOFError will be raised on EOF.  
+    # 
+    # Note that we don't support prompting first. Instead, arrange to
+    # call DebuggerOutput.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 nil as is normally
+    # expected the value from the class initialization is used.
+    def readline(use_raw=nil)
+      @input.readline
+    end
+
+    # Use this to set where to write to. output can be a 
+    # file object or a string. This code raises IOError on error.
+    # 
+    # 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)
+      @inout.write(*args)
+    end
+    
+    # used to write to a debugger that is connected to this
+    # server; `str' written will have a newline added to it
+    def writeline( msg)
+      @inout.write("%s\n" % msg)
+    end
+  end
+
+end
+