X-Git-Url: http://nitlanguage.org

diff --git a/lib/standard/stream.nit b/lib/standard/stream.nit
index f93a17b..1a90d56 100644
--- a/lib/standard/stream.nit
+++ b/lib/standard/stream.nit
@@ -18,19 +18,19 @@ import string
 # Abstract stream class
 class IOS
 	# close the stream
-	meth close is abstract
+	fun close is abstract
 end
 
 # Abstract input streams
 class IStream
-special IOS
+	super IOS
 	# Read a character. Return its ASCII value, -1 on EOF or timeout
-	meth read_char: Int is abstract
+	fun read_char: Int is abstract
 
 	# Read at most i bytes
-	meth read(i: Int): String
+	fun read(i: Int): String
 	do
-		var s = new String.with_capacity(i)
+		var s = new Buffer.with_capacity(i)
 		while i > 0 and not eof do
 			var c = read_char
 			if c >= 0 then
@@ -38,33 +38,33 @@ special IOS
 				i -= 1
 			end
 		end
-		return s
+		return s.to_s
 	end
 
 	# Read a string until the end of the line.
-	meth read_line: String
+	fun read_line: String
 	do
 		assert not eof
-		var s = new String
+		var s = new Buffer
 		append_line_to(s)
-		return s
+		return s.to_s
 	end
 
 	# Read all the stream until the eof.
-	meth read_all: String
+	fun read_all: String
 	do
-		var s = ""
+		var s = new Buffer
 		while not eof do
 			var c = read_char
 			if c >= 0 then s.add(c.ascii)
 		end
-		return s
+		return s.to_s
 	end
 
 	# Read a string until the end of the line and append it to `s'.
-	meth append_line_to(s: String)
+	fun append_line_to(s: Buffer)
 	do
-		while true do
+		loop
 			var x = read_char
 			if x == -1 then
 				if eof then return
@@ -77,23 +77,23 @@ special IOS
 	end
 
 	# Is there something to read.
-	meth eof: Bool is abstract
+	fun eof: Bool is abstract
 end
 
 # Abstract output stream
 class OStream
-special IOS
+	super IOS
 	# write a string
-	meth write(s: String) is abstract
+	fun write(s: String) is abstract
 
 	# Can the stream be used to write
-	meth is_writable: Bool is abstract
+	fun is_writable: Bool is abstract
 end
 
 # Input streams with a buffer
 class BufferedIStream
-special IStream
-	redef meth read_char
+	super IStream
+	redef fun read_char
 	do
 		assert not eof
 		if _buffer_pos >= _buffer.length then
@@ -107,15 +107,15 @@ special IStream
 		return c.ascii
 	end
 
-	redef meth read(i)
+	redef fun read(i)
 	do
-		var s = new String.with_capacity(i)
+		var s = new Buffer.with_capacity(i)
 		var j = _buffer_pos
 		var k = _buffer.length
 		while i > 0 do
 			if j >= k then
 				fill_buffer
-				if eof then return s
+				if eof then return s.to_s
 				j = _buffer_pos
 				k = _buffer.length
 			end
@@ -126,12 +126,12 @@ special IStream
 			end
 		end
 		_buffer_pos = j
-		return s
+		return s.to_s
 	end
 
-	redef meth read_all
+	redef fun read_all
 	do
-		var s = ""
+		var s = new Buffer
 		while not eof do
 			var j = _buffer_pos
 			var k = _buffer.length
@@ -142,12 +142,12 @@ special IStream
 			_buffer_pos = j
 			fill_buffer
 		end
-		return s
+		return s.to_s
 	end   
 
-	redef meth append_line_to(s)
+	redef fun append_line_to(s)
 	do
-		while true do
+		loop
 			# First phase: look for a '\n'
 			var i = _buffer_pos
 			while i < _buffer.length and _buffer[i] != '\n' do i += 1
@@ -181,88 +181,87 @@ special IStream
 		end
 	end
 
-	redef meth eof do return _buffer_pos >= _buffer.length and end_reached
+	redef fun eof do return _buffer_pos >= _buffer.length and end_reached
 
 	# The buffer
-	attr _buffer: String
+	var _buffer: nullable Buffer = null
 
 	# The current position in the buffer
-	attr _buffer_pos: Int
+	var _buffer_pos: Int = 0
 
 	# Fill the buffer
-	protected meth fill_buffer is abstract
+	protected fun fill_buffer is abstract
 
 	# Is the last fill_buffer reach the end 
-	protected meth end_reached: Bool is abstract
+	protected fun end_reached: Bool is abstract
 
 	# Allocate a `_buffer' for a given `capacity'.
-	protected meth prepare_buffer(capacity: Int)
+	protected fun prepare_buffer(capacity: Int)
 	do
-		_buffer = new String.with_capacity(capacity)
+		_buffer = new Buffer.with_capacity(capacity)
 		_buffer_pos = 0 # need to read
 	end
 end
 
 class IOStream
-special IStream
-special OStream
+	super IStream
+	super OStream
 end
 
 ##############################################################"
 
 class FDStream
-special IOS
+	super IOS
 	# File description
-	attr _fd: Int
+	var _fd: Int
 
-	redef meth close do native_close(_fd)
+	redef fun close do native_close(_fd)
 
-	private meth native_close(i: Int): Int is extern "stream_FDStream_FDStream_native_close_1"
-	private meth native_read_char(i: Int): Int is extern "stream_FDStream_FDStream_native_read_char_1"
-	private meth native_read(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_read_3"
-	private meth native_write(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_write_3"
+	private fun native_close(i: Int): Int is extern "stream_FDStream_FDStream_native_close_1"
+	private fun native_read_char(i: Int): Int is extern "stream_FDStream_FDStream_native_read_char_1"
+	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"
 
 	init(fd: Int) do _fd = fd
 end
 
 class FDIStream
-special FDStream
-special IStream
-	redef readable attr _eof: Bool
+	super FDStream
+	super IStream
+	redef readable var _eof: Bool = false
 	
-	redef meth read_char
+	redef fun read_char
 	do
 		var nb = native_read_char(_fd)
 		if nb == -1 then _eof = true
 		return nb
 	end
 
-	redef init(fd: Int) do super
+	init(fd: Int) do end 
 end
 
 class FDOStream
-special FDStream
-special OStream
-	redef readable attr _is_writable: Bool
+	super FDStream
+	super OStream
+	redef readable var _is_writable: Bool
 
-	redef meth write(s)
+	redef fun write(s)
 	do
 		var nb = native_write(_fd, s.to_cstring, s.length)
 		if nb < s.length then _is_writable = false
 	end
 
-	redef init(fd: Int)
+	init(fd: Int)
 	do
-		super
 		_is_writable = true
 	end
 end
 
 class FDIOStream
-special FDIStream
-special FDOStream
-special IOStream
-	redef init(fd: Int)
+	super FDIStream
+	super FDOStream
+	super IOStream
+	init(fd: Int)
 	do
 		_fd = fd
 		_is_writable = true