rbx-trepanning 0.2.0-universal-rubinius-2.0

data/interface/script.rb

@@ -0,0 +1,112 @@
+# -*- 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 '../interface'
+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,
+    :basename       => 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 ScriptError 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 '../interface'
+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,158 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010-2012 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Interface when communicating with the user.
+
+# Our local modules
+
+require 'rubygems'; require 'require_relative'
+require_relative '../interface'
+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   => '.trepanx_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 && @input.use_readline
+      @input.readline(prompt)
+    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?}"
+  intf.close
+  STDERR.puts "User interface closed?: #{intf.closed?}"
+end

data/interface.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 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 :history_io, :history_save, :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={})
+      @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/io/.gitignore

@@ -0,0 +1,3 @@
+/*.rbc
+/*~
+

data/io/input.rb

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010-2012 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Debugger user/command-oriented input possibly attached to IO-style
+# input or GNU Readline.
+# 
+
+require 'rubygems'; require 'require_relative'
+require_relative '../io'
+
+class Trepan
+
+  # Debugger user/command-oriented input possibly attached to IO-style
+  # input or GNU Readline.
+  class UserInput < Trepan::InputBase
+
+    attr_reader   :use_readline
+
+    @@readline_finalized = false
+
+    def initialize(inp, opts={})
+      @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
+    def eof?; @eof end
+
+    def interactive? 
+      @input.respond_to?(:isatty) && @input.isatty
+    end
+    # Read a line of input. EOFError will be raised on EOF.  
+    def readline(prompt='')
+      raise EOFError if eof?
+      begin 
+        if @line_edit && @use_readline
+          line = Readline.readline(prompt, true)
+        else
+          # Prompt should be empty and should have been 
+          # handled by caller.
+          unless prompt.empty?
+            raise RuntimeError, 
+            "Internal error: prompt '#{prompt}' should have been handled by caller" unless prompt.empty?
+          end
+          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
+    
+    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] = @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
+    return @use_readline unless @use_readline.nil?
+    %w(rb-readline rb-readline.rb/readline).each do |gem_name|
+      @use_readline ||= require gem_name
+      break if @use_readline
+    end
+    if @use_readline
+      # Returns current line buffer
+      def Readline.line_buffer
+        RbReadline.rl_line_buffer
+      end
+      at_exit { Trepan::UserInput::finalize }
+    end
+    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