rbx-trepanning 0.2.0-universal-rubinius-2.0

data/io/null_output.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Nukes output. Used for example in sourcing where you don't want
+# to see output.
+# 
+
+require 'rubygems'; require 'require_relative'
+require_relative '../io'
+
+class Trepan::OutputNull < Trepan::OutputBase
+  def initialize(out, opts={})
+    @closed = false
+    super
+  end
+  
+  def close
+    @closed = true
+  end
+  
+  def closed?
+    !!@closed
+  end
+  
+  def 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)
+  end
+  
+  # used to write to a debugger that is connected to this
+  # `str' written will have a newline added to it
+  #
+  def writeline( msg)
+  end
+end
+
+# Demo it
+if __FILE__ == $0
+  output = Trepan::OutputNull.new(nil)
+  p output
+  output.write("Invisible")
+  output.writeline("Invisible")
+end

data/io/string_array.rb

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Simulate I/O using lists of strings.
+
+require 'rubygems'; require 'require_relative'
+require_relative '../io'
+
+# Simulate I/O using an array of strings. Sort of like StringIO, but
+# even simplier.
+class Trepan::StringArrayInput < Trepan::InputBase
+
+  def initialize(inp, opts={})
+    super
+    @closed = false
+  end
+
+  # this close() interface is defined for class compatibility
+  def close
+    @closed = true 
+  end
+
+  def closed?
+    @closed
+  end
+
+  def eof?
+    @closed || @input.empty?
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def flush ; end
+
+  # Read a line of input. EOFError will be raised on EOF.  
+  # Note that we don't support prompting
+  def readline
+    raise EOFError if eof?
+    if @input.empty?
+      raise EOFError
+    end
+    line = @input.shift
+    return line 
+  end
+
+  class << self
+    # Use this to set where to read from.
+    def open(inp, opts={})
+      if inp.is_a?(Array)
+        return self.new(inp)
+      else
+        raise IOError, "Invalid input type (%s) for %s" % [inp.class, inp]
+      end
+    end
+  end
+end
+
+# Simulate I/O using an array of strings. Sort of like StringIO, but
+# even simplier.
+class Trepan::StringArrayOutput < Trepan::OutputBase
+
+  def initialize(out=[], opts={})
+    super 
+    @closed = false
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def close
+    @closed = true 
+  end
+
+  def closed?
+    @closed
+  end
+
+  def eof?
+    @closed || @output.empty? 
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def flush ; end
+
+  # This method the debugger uses to write. In contrast to
+  # writeline, no newline is added to the end to `str'.
+  #
+  def write(msg)
+    raise ValueError if @closed
+    @output << msg
+  end
+  
+  # used to write to a debugger that is connected to this
+  # server; Here, we use the null string '' as an indicator of a
+  # newline.
+  def writeline(msg)
+    write(msg)
+    write('')
+  end
+
+  class << self
+    # Use this to set where to write to. output can be a 
+    # file object or a string. This code raises IOError on error.
+    # 
+    # If another file was previously open upon calling this open,
+    # that will be stacked and will come back into use after
+    # a close_write().
+    def open(output=[])
+      if output.is_a?(Array)
+        return self.new(output)
+      else
+        raise IOError, ("Invalid output type (%s) for %s" % 
+                        [output.class, output])
+      end
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  inp  = Trepan::StringArrayInput.open(['Now is the time', 'for all good men'])
+  line = inp.readline
+  p line
+  line = inp.readline
+  p line
+  begin
+    line = inp.readline
+  rescue EOFError
+    puts 'EOF hit on read'
+  end
+
+  out = Trepan::StringArrayOutput.open
+  p out.output
+#    line = io.readline('Type some more characters: ')
+  out.writeline('Hello, world!')
+  p out.output
+  out.write('Hello');
+  p out.output
+  out.writeline(', again.');
+  p out.output
+#     io.open_write(sys.stdout)
+  out.flush_after_write = true
+  out.write('Last hello')
+  puts "Output is closed? #{out.closed?}"
+  out.close
+  p out.output
+  begin
+    out.writeline("You won't see me")
+  rescue
+  end
+
+  # Closing after already closed is okay
+  out.close
+  puts "Output is closed? #{out.closed?}"
+  puts "Input is closed? #{inp.closed?}"
+  inp.close
+  puts "Input is closed? #{inp.closed?}"
+end

data/io/tcpclient.rb

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Debugger Socket Input/Output Interface.
+
+require 'socket'
+require 'rubygems'; require 'require_relative'
+require_relative '../io'
+require_relative 'tcpfns'
+
+class Trepan 
+  # Debugger Client Input/Output Socket.
+  class TCPDbgClient < Trepan::InOutBase
+
+    include Trepanning::TCPPacking
+
+    DEFAULT_INIT_OPTS = {:open => true}
+
+    CLIENT_SOCKET_OPTS = {
+      :host    => 'localhost', # Symbolic name
+      :port    => 1027,  # Arbitrary non-privileged port
+    }
+
+    attr_reader :state
+
+    def initialize(opts={})
+      @opts      = CLIENT_SOCKET_OPTS.merge(opts)
+      @addr      = nil
+      @buf       = ''
+      @line_edit = false # Our name for GNU readline capability
+      @state     = :disconnected
+      @inout     = nil
+      open(@opts) if @opts[:open]
+    end
+
+    # Closes both input and output
+    def close
+      @state = :closing
+      @inout.close if @inout
+      @state = :disconnected
+    end
+
+    def disconnected?
+      :disconnected == @state
+    end
+
+    def open(opts={})
+      @opts = CLIENT_SOCKET_OPTS.merge(opts)
+      @host = @opts[:host]
+      @port = @opts[:port]
+      begin
+        @inout = TCPSocket.new(@host, @port)
+        @state = :connected
+      rescue SystemCallError => e
+        raise IOError, 
+        ('Open client for host %s on port %s gives error: %s' %
+         [@host, @port, e])
+      end
+    end
+    
+    # Read one message unit. It's possible however that
+    # more than one message will be set in a receive, so we will
+    # have to buffer that for the next read.
+    # EOFError will be raised on EOF.
+    def read_msg
+      if @state == :connected
+        if !@buf || @buf.empty?
+          @buf = @inout.recv(TCP_MAX_PACKET)
+          if @buf.empty?
+            @state = :disconnected
+            raise EOFError
+          end
+        end
+        @buf, data = unpack_msg(@buf)
+        return data
+      else
+        raise IOError, ("read_msg called in state: %s." % @state.to_s)
+      end
+    end
+
+    # This method the debugger uses to write a message unit.
+    def write(msg)
+      # FIXME: do we have to check the size of msg and split output? 
+      @inout.write(pack_msg(msg))
+    end
+
+    def writeline(msg)
+      write(msg + "\n")
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  client = Trepan::TCPDbgClient.new({'open' => false})
+  if ARGV.size > 0
+    threads = []
+    Thread.new do
+      server = TCPServer.new('localhost', 1027)
+      session = server.accept
+      while 'quit' != (line = session.gets)
+        session.puts line 
+      end
+      session.close
+    end
+
+    threads << Thread.new do
+      print 'Connecting...'
+      client.open()
+      puts 'connected.'
+      while true
+        print "input? "
+        line = STDIN.gets
+        break if line.chomp == 'quit'
+        begin
+          line = client.writeline(line)
+          puts "Got: #{client.read_msg.chomp}"
+        rescue EOFError
+          puts "Got EOF"
+          break
+        rescue Exception => e
+          puts "Got #{e}"
+          break
+        end
+      end
+    end
+    threads.each {|t| t.join }
+  end
+  client.close
+end

data/io/tcpfns.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Subsidiary routines used to "pack" and "unpack" TCP messages.
+
+module Trepanning
+  module TCPPacking
+
+    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
+    end
+
+    def unpack_msg(buf)
+      length  = Integer(buf[0...LOG_MAX_MSG])
+      data    = buf[LOG_MAX_MSG..LOG_MAX_MSG+length]
+      buf     = buf[LOG_MAX_MSG+length..-1]
+      [buf, data]
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  include Trepanning::TCPPacking
+  msg = "Hi there!"
+  puts unpack_msg(pack_msg(msg))[1] == msg
+end
+

data/io/tcpserver.rb

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Debugger Server Input/Output interface.
+
+require 'socket'
+require 'rubygems'; require 'require_relative'
+require_relative '../app/default' # For host and port
+require_relative '../io'
+require_relative 'tcpfns'
+
+class Trepan 
+  # Debugger Server Input/Output Socket.
+  class TCPDbgServer < Trepan::InOutBase
+
+    include Trepanning::TCPPacking
+
+    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
+
+    def initialize(opts={})
+      @opts    = DEFAULT_INIT_OPTS.merge(opts)
+      @input = @output = @session = nil
+      @buf     = ''    # Read buffer
+      @state   = :disconnected
+      @port    = nil   # Current port in use
+      @host    = nil   # current host in use
+      @line_edit = false
+      open(@opts) if @opts[:open]
+    end
+
+    def connected?
+      :connected == @state
+    end
+    
+
+    # Closes server connection.
+    def close
+      @state = :closing
+      @session.close if @session
+      @state = :disconnected
+    end
+
+    def open(opts={})
+      @opts   = SERVER_SOCKET_OPTS.merge(opts)
+      @host   = @opts[:host]
+      @port   = @opts[:port]
+      @server = TCPServer.new(@host, @port)
+      # @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, 5)
+      #                   # @opts[:timeout])
+      @state  = :listening
+    end
+    
+    # Read one message unit. It's possible however that
+    # more than one message will be set in a receive, so we will
+    # have to buffer that for the next read.
+    # EOFError will be raised on EOF.
+    def read_msg
+      wait_for_connect unless connected?
+      while !@buf || @buf.empty?
+        @buf, info = @session.recvfrom(TCP_MAX_PACKET)
+      end
+      @buf, data = unpack_msg(@buf)
+      data
+    end
+
+    def wait_for_connect
+      @input = @output = @session = @server.accept
+      @state = :connected
+    end
+    
+    # This method the debugger uses to write. In contrast to
+    # writeline, no newline is added to the end to `str'. Also
+    # msg doesn't have to be a string.
+    def write(msg)
+      wait_for_connect() unless connected?
+      # FIXME: do we have to check the size of msg and split output? 
+      @session.print(pack_msg(msg))
+    end
+
+    def writeline(msg)
+      write(msg + "\n")
+    end
+
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  include Trepanning::TCPPacking
+  server = Trepan::TCPDbgServer.new({ :open => false,
+                                      :port => 1027,
+                                      :host => 'localhost'
+                                    })
+  if ARGV.size > 0
+    puts 'Listening for connection...'
+    server.open
+    threads = []
+    Thread.new do
+      while true do
+        begin
+          line = server.read_msg.chomp
+          puts "got #{line}"
+        rescue EOFError
+          puts 'Got EOF'
+          break
+        end
+      end
+    end
+    threads << Thread.new do 
+      t = TCPSocket.new('localhost', 1027)
+      while true do
+        begin
+          print "input? "
+          line = STDIN.gets
+          break if !line || line.chomp == 'quit'
+          t.puts(pack_msg(line))
+        rescue EOFError
+          puts "Got EOF"
+          break
+        rescue Exception => e
+          puts "Got #{e}"
+          break
+        end
+      end
+      t.close
+    end
+    threads.each {|t| t.join }
+    server.close
+  end
+end

data/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.
+
+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
+      @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
+

data/lib/.gitignore

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