# Input and output streams of characters
module stream
-import string
+intrude import ropes
in "C" `{
#include <unistd.h>
#include <poll.h>
#include <errno.h>
#include <string.h>
+ #include <signal.h>
`}
# Abstract stream class
redef fun write_to(stream) do stream.write(self)
end
+redef class RopeNode
+ super Streamable
+end
+
+redef class Leaf
+
+ redef fun write_to(s) do s.write(str)
+end
+
+redef class Concat
+
+ redef fun write_to(s)
+ do
+ if left != null then left.write_to(s)
+ if right != null then right.write_to(s)
+ end
+end
+
+redef class RopeString
+
+ redef fun write_to(s) do root.write_to(s)
+end
+
# Input streams with a buffer
abstract class BufferedIStream
super IStream
redef fun read(i)
do
- var s = new FlatBuffer.with_capacity(i)
- var j = _buffer_pos
- var k = _buffer.length
- while i > 0 do
- if j >= k then
+ if _buffer.length == _buffer_pos then
+ if not eof then
fill_buffer
- if eof then return s.to_s
- j = _buffer_pos
- k = _buffer.length
- end
- while j < k and i > 0 do
- s.add(_buffer.chars[j])
- j += 1
- i -= 1
+ return read(i)
end
+ return ""
end
- _buffer_pos = j
- return s.to_s
+ if _buffer_pos + i >= _buffer.length then
+ var from = _buffer_pos
+ _buffer_pos = _buffer.length
+ return _buffer.substring_from(from).to_s
+ end
+ _buffer_pos += i
+ return _buffer.substring(_buffer_pos - i, i).to_s
end
redef fun read_all
var j = _buffer_pos
var k = _buffer.length
while j < k do
- s.add(_buffer.chars[j])
+ s.add(_buffer[j])
j += 1
end
_buffer_pos = j
redef fun eof do return _buffer_pos >= _buffer.length and end_reached
# The buffer
- var _buffer: nullable FlatBuffer = null
+ private var buffer: nullable FlatBuffer = null
# The current position in the buffer
- var _buffer_pos: Int = 0
+ private var buffer_pos: Int = 0
# Fill the buffer
protected fun fill_buffer is abstract
private fun native_read(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_read_3"
private fun native_write(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_write_3"
private fun native_write_char(i: Int, c: Char): Int is extern "stream_FDStream_FDStream_native_write_char_2"
-
- init(fd: Int) do self.fd = fd
end
class FDIStream
if nb == -1 then eof = true
return nb
end
-
- init(fd: Int) do end
end
class FDOStream
super FDStream
super OStream
- redef var is_writable: Bool
+ redef var is_writable = true
redef fun write(s)
do
var nb = native_write(fd, s.to_cstring, s.length)
if nb < s.length then is_writable = false
end
-
- init(fd: Int)
- do
- is_writable = true
- end
end
class FDIOStream
super FDIStream
super FDOStream
super IOStream
- init(fd: Int)
- do
- self.fd = fd
- is_writable = true
- end
end
redef interface Object
private var content = new Array[String]
redef fun to_s do return content.to_s
- redef fun is_writable do return true
- redef fun write(str) do content.add(str.to_s)
+ redef fun is_writable do return not closed
+ redef fun write(str)
+ do
+ assert not closed
+ content.add(str.to_s)
+ end
+
+ protected var closed = false
+ redef fun close do closed = true
end