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

diff --git a/lib/standard/file.nit b/lib/standard/file.nit
index a777028..2d4e9df 100644
--- a/lib/standard/file.nit
+++ b/lib/standard/file.nit
@@ -16,8 +16,8 @@
 module file
 
 intrude import stream
-intrude import ropes
-import string_search
+intrude import text::ropes
+import text
 import time
 import gc
 
@@ -32,7 +32,7 @@ in "C Header" `{
 	#include <errno.h>
 `}
 
-# File Abstract Stream
+# `Stream` used to interact with a File or FileDescriptor
 abstract class FileStream
 	super Stream
 	# The path of the file.
@@ -42,19 +42,45 @@ abstract class FileStream
 	private var file: nullable NativeFile = null
 
 	# The status of a file. see POSIX stat(2).
-	fun file_stat: NativeFileStat do return _file.file_stat
+	#
+	#     var f = new FileReader.open("/etc/issue")
+	#     assert f.file_stat.is_file
+	#
+	# Return null in case of error
+	fun file_stat: nullable FileStat
+	do
+		var stat = _file.file_stat
+		if stat.address_is_null then return null
+		return new FileStat(stat)
+	end
 
 	# File descriptor of this file
 	fun fd: Int do return _file.fileno
 
+	redef fun close
+	do
+		if _file == null then return
+		if _file.address_is_null then
+			if last_error != null then return
+			last_error = new IOError("Cannot close unopened file")
+			return
+		end
+		var i = _file.io_close
+		if i != 0 then
+			last_error = new IOError("Close failed due to error {sys.errno.strerror}")
+		end
+		_file = null
+	end
+
 	# Sets the buffering mode for the current FileStream
 	#
 	# If the buf_size is <= 0, its value will be 512 by default
 	#
 	# The mode is any of the buffer_mode enumeration in `Sys`:
-	#	- buffer_mode_full
-	#	- buffer_mode_line
-	#	- buffer_mode_none
+	#
+	# * `buffer_mode_full`
+	# * `buffer_mode_line`
+	# * `buffer_mode_none`
 	fun set_buffering_mode(buf_size, mode: Int) do
 		if buf_size <= 0 then buf_size = 512
 		if _file.set_buffering_type(buf_size, mode) != 0 then
@@ -63,7 +89,7 @@ abstract class FileStream
 	end
 end
 
-# File input stream
+# `Stream` that can read from a File
 class FileReader
 	super FileStream
 	super BufferedReader
@@ -72,6 +98,11 @@ class FileReader
 
 	# Open the same file again.
 	# The original path is reused, therefore the reopened file can be a different file.
+	#
+	#     var f = new FileReader.open("/etc/issue")
+	#     var l = f.read_line
+	#     f.reopen
+	#     assert l == f.read_line
 	fun reopen
 	do
 		if not eof and not _file.address_is_null then close
@@ -83,34 +114,41 @@ class FileReader
 			return
 		end
 		end_reached = false
-		_buffer_pos = 0
-		_buffer.clear
+		buffer_reset
 	end
 
 	redef fun close
 	do
-		if _file == null or _file.address_is_null then return
-		var i = _file.io_close
-		_buffer.clear
+		super
+		buffer_reset
 		end_reached = true
-		_file = null
 	end
 
 	redef fun fill_buffer
 	do
-		var nb = _file.io_read(_buffer.items, _buffer.capacity)
+		var nb = _file.io_read(_buffer, _buffer_capacity)
 		if nb <= 0 then
 			end_reached = true
 			nb = 0
 		end
-		_buffer.length = nb
+		_buffer_length = nb
 		_buffer_pos = 0
 	end
 
 	# End of file?
-	redef var end_reached: Bool = false
+	redef var end_reached = false
 
 	# Open the file at `path` for reading.
+	#
+	#     var f = new FileReader.open("/etc/issue")
+	#     assert not f.end_reached
+	#     f.close
+	#
+	# In case of error, `last_error` is set
+	#
+	#     f = new FileReader.open("/fail/does not/exist")
+	#     assert f.end_reached
+	#     assert f.last_error != null
 	init open(path: String)
 	do
 		self.path = path
@@ -122,6 +160,9 @@ class FileReader
 		end
 	end
 
+	# Creates a new File stream from a file descriptor
+	#
+	# This is a low-level method.
 	init from_fd(fd: Int) do
 		self.path = ""
 		prepare_buffer(1)
@@ -133,46 +174,59 @@ class FileReader
 	end
 end
 
-# File output stream
+# `Stream` that can write to a File
 class FileWriter
 	super FileStream
 	super Writer
 
+	redef fun write_bytes(s) do
+		if last_error != null then return
+		if not _is_writable then
+			last_error = new IOError("cannot write to non-writable stream")
+			return
+		end
+		write_native(s.items, 0, s.length)
+	end
+
 	redef fun write(s)
 	do
 		if last_error != null then return
 		if not _is_writable then
-			last_error = new IOError("Cannot write to non-writable stream")
+			last_error = new IOError("cannot write to non-writable stream")
 			return
 		end
-		if s isa FlatText then
-			write_native(s.to_cstring, s.length)
-		else
-			for i in s.substrings do write_native(i.to_cstring, i.length)
-		end
-		_file.flush
+		for i in s.substrings do write_native(i.to_cstring, i.length)
 	end
 
-	redef fun close
+	redef fun write_byte(value)
 	do
-		if _file == null then return
+		if last_error != null then return
+		if not _is_writable then
+			last_error = new IOError("Cannot write to non-writable stream")
+			return
+		end
 		if _file.address_is_null then
-			if last_error != null then return
-			last_error = new IOError("Cannot close unopened write stream")
+			last_error = new IOError("Writing on a null stream")
 			_is_writable = false
 			return
 		end
-		var i = _file.io_close
-		if i != 0 then
-			last_error = new IOError("Close failed due to error {sys.errno.strerror}")
+
+		var err = _file.write_byte(value)
+		if err != 1 then
+			# Big problem
+			last_error = new IOError("Problem writing a byte: {err}")
 		end
+	end
+
+	redef fun close
+	do
+		super
 		_is_writable = false
-		_file = null
 	end
 	redef var is_writable = false
 
 	# Write `len` bytes from `native`.
-	private fun write_native(native: NativeString, len: Int)
+	private fun write_native(native: NativeString, from, len: Int)
 	do
 		if last_error != null then return
 		if not _is_writable then
@@ -184,7 +238,7 @@ class FileWriter
 			_is_writable = false
 			return
 		end
-		var err = _file.io_write(native, len)
+		var err = _file.io_write(native, from, len)
 		if err != len then
 			# Big problem
 			last_error = new IOError("Problem in writing : {err} {len} \n")
@@ -219,22 +273,26 @@ redef class Int
 	# Creates a file stream from a file descriptor `fd` using the file access `mode`.
 	#
 	# NOTE: The `mode` specified must be compatible with the one used in the file descriptor.
-	private fun fd_to_stream(mode: NativeString): NativeFile is extern "file_int_fdtostream"
+	private fun fd_to_stream(mode: NativeString): NativeFile `{
+		return fdopen(self, mode);
+	`}
 end
 
 # Constant for read-only file streams
-private fun read_only: NativeString do return "r".to_cstring
+private fun read_only: NativeString do return once "r".to_cstring
 
 # Constant for write-only file streams
 #
 # If a stream is opened on a file with this method,
 # it will wipe the previous file if any.
 # Else, it will create the file.
-private fun wipe_write: NativeString do return "w".to_cstring
+private fun wipe_write: NativeString do return once "w".to_cstring
 
 ###############################################################################
 
 # Standard input stream.
+#
+# The class of the default value of `sys.stdin`.
 class Stdin
 	super FileReader
 
@@ -244,20 +302,33 @@ class Stdin
 		prepare_buffer(1)
 	end
 
-	redef fun poll_in: Bool is extern "file_stdin_poll_in"
+	redef fun poll_in `{
+		struct pollfd fd = {0, POLLIN, 0};
+		int res = poll(&fd, 1, 0);
+		if (res == -1) {
+			perror("Error poll stdin");
+			exit(EXIT_FAILURE);
+		}
+		return res > 0;
+	`}
 end
 
 # Standard output stream.
+#
+# The class of the default value of `sys.stdout`.
 class Stdout
 	super FileWriter
 	init do
 		_file = new NativeFile.native_stdout
 		path = "/dev/stdout"
 		_is_writable = true
+		set_buffering_mode(256, sys.buffer_mode_line)
 	end
 end
 
 # Standard error stream.
+#
+# The class of the default value of `sys.stderr`.
 class Stderr
 	super FileWriter
 	init do
@@ -289,7 +360,7 @@ class Path
 	# Path to this file
 	redef fun to_s do return path
 
-	# Name of the file name at `to_s`
+	# Short name of the file at `to_s`
 	#
 	# ~~~
 	# var path = "/tmp/somefile".to_path
@@ -304,6 +375,10 @@ class Path
 	#
 	# Returns `null` if there is no file at `self`.
 	#
+	#     assert "/etc/".to_path.stat.is_dir
+	#     assert "/etc/issue".to_path.stat.is_file
+	#     assert "/fail/does not/exist".to_path.stat == null
+	#
 	# ~~~
 	# var p = "/tmp/".to_path
 	# var stat = p.stat
@@ -330,8 +405,6 @@ class Path
 	end
 
 	# Delete a file from the file system, return `true` on success
-	#
-	# Require: `exists`
 	fun delete: Bool do return path.to_cstring.file_delete
 
 	# Copy content of file at `path` to `dest`
@@ -377,10 +450,12 @@ class Path
 	# ~~~
 	#
 	# See `Reader::read_all` for details.
-	fun read_all: String
+	fun read_all: String do return read_all_bytes.to_s
+
+	fun read_all_bytes: Bytes
 	do
 		var s = open_ro
-		var res = s.read_all
+		var res = s.read_all_bytes
 		s.close
 		return res
 	end
@@ -457,7 +532,7 @@ class Path
 		end
 
 		# Delete the directory itself
-		if ok then path.to_cstring.rmdir
+		if ok then ok = path.to_cstring.rmdir and ok
 
 		return ok
 	end
@@ -499,6 +574,11 @@ class FileStat
 		return stat.atime
 	end
 
+	# Returns the last access time
+	#
+	# alias for `last_access_time`
+	fun atime: Int do return last_access_time
+
 	# Returns the last modification time in seconds since Epoch
 	fun last_modification_time: Int
 	do
@@ -506,6 +586,12 @@ class FileStat
 		return stat.mtime
 	end
 
+	# Returns the last modification time
+	#
+	# alias for `last_modification_time`
+	fun mtime: Int do return last_modification_time
+
+
 	# Size of the file at `path`
 	fun size: Int
 	do
@@ -513,13 +599,16 @@ class FileStat
 		return stat.size
 	end
 
-	# Is this a regular file and not a device file, pipe, socket, etc.?
+	# Is self a regular file and not a device file, pipe, socket, etc.?
 	fun is_file: Bool
 	do
 		assert not finalized
 		return stat.is_reg
 	end
 
+	# Alias for `is_file`
+	fun is_reg: Bool do return is_file
+
 	# Is this a directory?
 	fun is_dir: Bool
 	do
@@ -543,6 +632,11 @@ class FileStat
 		return stat.ctime
 	end
 
+	# Returns the last status change time
+	#
+	# alias for `last_status_change_time`
+	fun ctime: Int do return last_status_change_time
+
 	# Returns the permission bits of file
 	fun mode: Int
 	do
@@ -589,10 +683,20 @@ redef class String
 	fun file_exists: Bool do return to_cstring.file_exists
 
 	# The status of a file. see POSIX stat(2).
-	fun file_stat: NativeFileStat do return to_cstring.file_stat
+	fun file_stat: nullable FileStat
+	do
+		var stat = to_cstring.file_stat
+		if stat.address_is_null then return null
+		return new FileStat(stat)
+	end
 
 	# The status of a file or of a symlink. see POSIX lstat(2).
-	fun file_lstat: NativeFileStat do return to_cstring.file_lstat
+	fun file_lstat: nullable FileStat
+	do
+		var stat = to_cstring.file_lstat
+		if stat.address_is_null then return null
+		return new FileStat(stat)
+	end
 
 	# Remove a file, return true if success
 	fun file_delete: Bool do return to_cstring.file_delete
@@ -674,12 +778,14 @@ redef class String
 		return res
 	end
 
-	# Simplify a file path by remove useless ".", removing "//", and resolving ".."
-	# ".." are not resolved if they start the path
-	# starting "/" is not removed
-	# trainling "/" is removed
+	# Simplify a file path by remove useless `.`, removing `//`, and resolving `..`
+	#
+	# * `..` are not resolved if they start the path
+	# * starting `.` is simplified unless the path is empty
+	# * starting `/` is not removed
+	# * trailing `/` is removed
 	#
-	# Note that the method only wonrk on the string:
+	# Note that the method only work on the string:
 	#
 	#  * no I/O access is performed
 	#  * the validity of the path is not checked
@@ -691,17 +797,29 @@ redef class String
 	# assert "dir/..".simplify_path            ==  "."
 	# assert "//absolute//path/".simplify_path ==  "/absolute/path"
 	# assert "//absolute//../".simplify_path   ==  "/"
+	# assert "/".simplify_path                 == "/"
+	# assert "../".simplify_path               == ".."
+	# assert "./".simplify_path                == "."
+	# assert "././././././".simplify_path      == "."
+	# assert "./../dir".simplify_path		   == "../dir"
+	# assert "./dir".simplify_path			   == "dir"
 	# ~~~
 	fun simplify_path: String
 	do
 		var a = self.split_with("/")
 		var a2 = new Array[String]
 		for x in a do
-			if x == "." then continue
-			if x == "" and not a2.is_empty then continue
+			if x == "." and not a2.is_empty then continue # skip `././`
+			if x == "" and not a2.is_empty then continue # skip `//`
 			if x == ".." and not a2.is_empty and a2.last != ".." then
-				a2.pop
-				continue
+				if a2.last == "." then # do not skip `./../`
+					a2.pop # reduce `./../` in `../`
+				else # reduce `dir/../` in `/`
+					a2.pop
+					continue
+				end
+			else if not a2.is_empty and a2.last == "." then
+				a2.pop # reduce `./dir` in `dir`
 			end
 			a2.push(x)
 		end
@@ -715,7 +833,6 @@ redef class String
 	# Using a standard "{self}/{path}" does not work in the following cases:
 	#
 	# * `self` is empty.
-	# * `path` ends with `'/'`.
 	# * `path` starts with `'/'`.
 	#
 	# This method ensures that the join is valid.
@@ -836,28 +953,47 @@ redef class String
 	end
 
 	# Create a directory (and all intermediate directories if needed)
-	fun mkdir
+	#
+	# Return an error object in case of error.
+	#
+	#    assert "/etc/".mkdir != null
+	fun mkdir: nullable Error
 	do
 		var dirs = self.split_with("/")
 		var path = new FlatBuffer
-		if dirs.is_empty then return
+		if dirs.is_empty then return null
 		if dirs[0].is_empty then
 			# it was a starting /
 			path.add('/')
 		end
+		var error: nullable Error = null
 		for d in dirs do
 			if d.is_empty then continue
 			path.append(d)
 			path.add('/')
-			path.to_s.to_cstring.file_mkdir
+			var res = path.to_s.to_cstring.file_mkdir
+			if not res and error == null then
+				error = new IOError("Cannot create directory `{path}`: {sys.errno.strerror}")
+			end
 		end
+		return error
 	end
 
 	# Delete a directory and all of its content, return `true` on success
 	#
 	# Does not go through symbolic links and may get stuck in a cycle if there
 	# is a cycle in the filesystem.
-	fun rmdir: Bool do return to_path.rmdir
+	#
+	# Return an error object in case of error.
+	#
+	#     assert "/fail/does not/exist".rmdir != null
+	fun rmdir: nullable Error
+	do
+		var res = to_path.rmdir
+		if res then return null
+		var error = new IOError("Cannot change remove `{self}`: {sys.errno.strerror}")
+		return error
+	end
 
 	# Change the current working directory
 	#
@@ -866,8 +1002,18 @@ redef class String
 	#     "..".chdir
 	#     assert getcwd == "/"
 	#
-	# TODO: errno
-	fun chdir do to_cstring.file_chdir
+	# Return an error object in case of error.
+	#
+	#     assert "/etc".chdir == null
+	#     assert "/fail/does no/exist".chdir != null
+	#     assert getcwd == "/etc" # unchanger
+	fun chdir: nullable Error
+	do
+		var res = to_cstring.file_chdir
+		if res then return null
+		var error = new IOError("Cannot change directory to `{self}`: {sys.errno.strerror}")
+		return error
+	end
 
 	# Return right-most extension (without the dot)
 	#
@@ -897,126 +1043,202 @@ redef class String
 		end
 	end
 
-	# returns files contained within the directory represented by self
-	fun files: Array[String] is extern import Array[String], Array[String].add, NativeString.to_s, String.to_cstring `{
-		char *dir_path;
-		DIR *dir;
-
-		dir_path = String_to_cstring( recv );
-		if ((dir = opendir(dir_path)) == NULL)
-		{
-			perror( dir_path );
-			exit( 1 );
-		}
-		else
-		{
-			Array_of_String results;
-			String file_name;
-			struct dirent *de;
+	# Returns entries contained within the directory represented by self.
+	#
+	#     var files = "/etc".files
+	#     assert files.has("issue")
+	#
+	# Returns an empty array in case of error
+	#
+	#     files = "/etc/issue".files
+	#     assert files.is_empty
+	#
+	# TODO find a better way to handle errors and to give them back to the user.
+	fun files: Array[String]
+	do
+		var res = new Array[String]
+		var d = new NativeDir.opendir(to_cstring)
+		if d.address_is_null then return res
+
+		loop
+			var de = d.readdir
+			if de.address_is_null then break
+			var name = de.to_s_with_copy
+			if name == "." or name == ".." then continue
+			res.add name
+		end
+		d.closedir
 
-			results = new_Array_of_String();
+		return res
+	end
+end
 
-			while ( ( de = readdir( dir ) ) != NULL )
-				if ( strcmp( de->d_name, ".." ) != 0 &&
-					strcmp( de->d_name, "." ) != 0 )
-				{
-					file_name = NativeString_to_s( strdup( de->d_name ) );
-					Array_of_String_add( results, file_name );
-				}
+redef class NativeString
+	private fun file_exists: Bool `{
+		FILE *hdl = fopen(self,"r");
+		if(hdl != NULL){
+			fclose(hdl);
+		}
+		return hdl != NULL;
+	`}
 
-			closedir( dir );
-			return results;
+	private fun file_stat: NativeFileStat `{
+		struct stat buff;
+		if(stat(self, &buff) != -1) {
+			struct stat* stat_element;
+			stat_element = malloc(sizeof(struct stat));
+			return memcpy(stat_element, &buff, sizeof(struct stat));
 		}
+		return 0;
 	`}
-end
 
-redef class NativeString
-	private fun file_exists: Bool is extern "string_NativeString_NativeString_file_exists_0"
-	private fun file_stat: NativeFileStat is extern "string_NativeString_NativeString_file_stat_0"
 	private fun file_lstat: NativeFileStat `{
 		struct stat* stat_element;
 		int res;
 		stat_element = malloc(sizeof(struct stat));
-		res = lstat(recv, stat_element);
+		res = lstat(self, stat_element);
 		if (res == -1) return NULL;
 		return stat_element;
 	`}
-	private fun file_mkdir: Bool is extern "string_NativeString_NativeString_file_mkdir_0"
-	private fun rmdir: Bool `{ return rmdir(recv); `}
-	private fun file_delete: Bool is extern "string_NativeString_NativeString_file_delete_0"
-	private fun file_chdir is extern "string_NativeString_NativeString_file_chdir_0"
-	private fun file_realpath: NativeString is extern "file_NativeString_realpath"
+
+	private fun file_mkdir: Bool `{ return !mkdir(self, 0777); `}
+
+	private fun rmdir: Bool `{ return !rmdir(self); `}
+
+	private fun file_delete: Bool `{
+		return remove(self) == 0;
+	`}
+
+	private fun file_chdir: Bool `{ return !chdir(self); `}
+
+	private fun file_realpath: NativeString `{ return realpath(self, NULL); `}
 end
 
 # This class is system dependent ... must reify the vfs
-extern class NativeFileStat `{ struct stat * `}
+private extern class NativeFileStat `{ struct stat * `}
+
 	# Returns the permission bits of file
-	fun mode: Int is extern "file_FileStat_FileStat_mode_0"
+	fun mode: Int `{ return self->st_mode; `}
+
 	# Returns the last access time
-	fun atime: Int is extern "file_FileStat_FileStat_atime_0"
+	fun atime: Int `{ return self->st_atime; `}
+
 	# Returns the last status change time
-	fun ctime: Int is extern "file_FileStat_FileStat_ctime_0"
+	fun ctime: Int `{ return self->st_ctime; `}
+
 	# Returns the last modification time
-	fun mtime: Int is extern "file_FileStat_FileStat_mtime_0"
+	fun mtime: Int `{ return self->st_mtime; `}
+
 	# Returns the size
-	fun size: Int is extern "file_FileStat_FileStat_size_0"
+	fun size: Int `{ return self->st_size; `}
 
 	# Returns true if it is a regular file (not a device file, pipe, sockect, ...)
-	fun is_reg: Bool `{ return S_ISREG(recv->st_mode); `}
+	fun is_reg: Bool `{ return S_ISREG(self->st_mode); `}
+
 	# Returns true if it is a directory
-	fun is_dir: Bool `{ return S_ISDIR(recv->st_mode); `}
+	fun is_dir: Bool `{ return S_ISDIR(self->st_mode); `}
+
 	# Returns true if it is a character device
-	fun is_chr: Bool `{ return S_ISCHR(recv->st_mode); `}
+	fun is_chr: Bool `{ return S_ISCHR(self->st_mode); `}
+
 	# Returns true if it is a block device
-	fun is_blk: Bool `{ return S_ISBLK(recv->st_mode); `}
+	fun is_blk: Bool `{ return S_ISBLK(self->st_mode); `}
+
 	# Returns true if the type is fifo
-	fun is_fifo: Bool `{ return S_ISFIFO(recv->st_mode); `}
+	fun is_fifo: Bool `{ return S_ISFIFO(self->st_mode); `}
+
 	# Returns true if the type is a link
-	fun is_lnk: Bool `{ return S_ISLNK(recv->st_mode); `}
+	fun is_lnk: Bool `{ return S_ISLNK(self->st_mode); `}
+
 	# Returns true if the type is a socket
-	fun is_sock: Bool `{ return S_ISSOCK(recv->st_mode); `}
+	fun is_sock: Bool `{ return S_ISSOCK(self->st_mode); `}
 end
 
 # Instance of this class are standard FILE * pointers
 private extern class NativeFile `{ FILE* `}
-	fun io_read(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_read_2"
-	fun io_write(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_write_2"
-	fun io_close: Int is extern "file_NativeFile_NativeFile_io_close_0"
-	fun file_stat: NativeFileStat is extern "file_NativeFile_NativeFile_file_stat_0"
-	fun fileno: Int `{ return fileno(recv); `}
+	fun io_read(buf: NativeString, len: Int): Int `{
+		return fread(buf, 1, len, self);
+	`}
+
+	fun io_write(buf: NativeString, from, len: Int): Int `{
+		return fwrite(buf+from, 1, len, self);
+	`}
+
+	fun write_byte(value: Byte): Int `{
+		unsigned char b = (unsigned char)value;
+		return fwrite(&b, 1, 1, self);
+	`}
+
+	fun io_close: Int `{ return fclose(self); `}
+
+	fun file_stat: NativeFileStat `{
+		struct stat buff;
+		if(fstat(fileno(self), &buff) != -1) {
+			struct stat* stat_element;
+			stat_element = malloc(sizeof(struct stat));
+			return memcpy(stat_element, &buff, sizeof(struct stat));
+		}
+		return 0;
+	`}
+
+	fun fileno: Int `{ return fileno(self); `}
+
 	# Flushes the buffer, forcing the write operation
-	fun flush: Int is extern "fflush"
+	fun flush: Int `{ return fflush(self); `}
+
 	# Used to specify how the buffering will be handled for the current stream.
-	fun set_buffering_type(buf_length: Int, mode: Int): Int is extern "file_NativeFile_NativeFile_set_buffering_type_0"
+	fun set_buffering_type(buf_length: Int, mode: Int): Int `{
+		return setvbuf(self, NULL, mode, buf_length);
+	`}
+
+	new io_open_read(path: NativeString) `{ return fopen(path, "r"); `}
+
+	new io_open_write(path: NativeString) `{ return fopen(path, "w"); `}
+
+	new native_stdin `{ return stdin; `}
+
+	new native_stdout `{ return stdout; `}
 
-	new io_open_read(path: NativeString) is extern "file_NativeFileCapable_NativeFileCapable_io_open_read_1"
-	new io_open_write(path: NativeString) is extern "file_NativeFileCapable_NativeFileCapable_io_open_write_1"
-	new native_stdin is extern "file_NativeFileCapable_NativeFileCapable_native_stdin_0"
-	new native_stdout is extern "file_NativeFileCapable_NativeFileCapable_native_stdout_0"
-	new native_stderr is extern "file_NativeFileCapable_NativeFileCapable_native_stderr_0"
+	new native_stderr `{ return stderr; `}
 end
 
-redef class Sys
+# Standard `DIR*` pointer
+private extern class NativeDir `{ DIR* `}
 
-	init do
-		if stdout isa FileStream then stdout.as(FileStream).set_buffering_mode(256, buffer_mode_line)
-	end
+	# Open a directory
+	new opendir(path: NativeString) `{ return opendir(path); `}
+
+	# Close a directory
+	fun closedir `{ closedir(self); `}
+
+	# Read the next directory entry
+	fun readdir: NativeString `{
+		struct dirent *de;
+		de = readdir(self);
+		if (!de) return NULL;
+		return de->d_name;
+	`}
+end
+
+redef class Sys
 
 	# Standard input
-	var stdin: PollableReader = new Stdin is protected writable
+	var stdin: PollableReader = new Stdin is protected writable, lazy
 
 	# Standard output
-	var stdout: Writer = new Stdout is protected writable
+	var stdout: Writer = new Stdout is protected writable, lazy
 
 	# Standard output for errors
-	var stderr: Writer = new Stderr is protected writable
+	var stderr: Writer = new Stderr is protected writable, lazy
 
 	# Enumeration for buffer mode full (flushes when buffer is full)
-	fun buffer_mode_full: Int is extern "file_Sys_Sys_buffer_mode_full_0"
+	fun buffer_mode_full: Int `{ return _IOFBF; `}
+
 	# Enumeration for buffer mode line (flushes when a `\n` is encountered)
-	fun buffer_mode_line: Int is extern "file_Sys_Sys_buffer_mode_line_0"
+	fun buffer_mode_line: Int `{ return _IONBF; `}
+
 	# Enumeration for buffer mode none (flushes ASAP when something is written)
-	fun buffer_mode_none: Int is extern "file_Sys_Sys_buffer_mode_none_0"
+	fun buffer_mode_none: Int `{ return _IOLBF; `}
 
 	# returns first available stream to read or write to
 	# return null on interruption (possibly a signal)
@@ -1042,10 +1264,10 @@ redef class Sys
 		end
 	end
 
-	private fun intern_poll(in_fds: Array[Int], out_fds: Array[Int]) : nullable Int is extern import Array[Int].length, Array[Int].[], Int.as(nullable Int) `{
+	private fun intern_poll(in_fds: Array[Int], out_fds: Array[Int]): nullable Int
+	import Array[Int].length, Array[Int].[], Int.as(nullable Int) `{
 		int in_len, out_len, total_len;
 		struct pollfd *c_fds;
-		sigset_t sigmask;
 		int i;
 		int first_polled_fd = -1;
 		int result;
@@ -1097,30 +1319,40 @@ redef class Sys
 end
 
 # Print `objects` on the standard output (`stdout`).
-protected fun printn(objects: Object...)
+fun printn(objects: Object...)
 do
-	sys.stdout.write(objects.to_s)
+	sys.stdout.write(objects.plain_to_s)
 end
 
 # Print an `object` on the standard output (`stdout`) and add a newline.
-protected fun print(object: Object)
+fun print(object: Object)
 do
 	sys.stdout.write(object.to_s)
 	sys.stdout.write("\n")
 end
 
+# Print `object` on the error output (`stderr` or a log system)
+fun print_error(object: Object)
+do
+	sys.stderr.write object.to_s
+	sys.stderr.write "\n"
+end
+
 # Read a character from the standard input (`stdin`).
-protected fun getc: Char
+fun getc: Char
 do
-	return sys.stdin.read_char.ascii
+	var c = sys.stdin.read_char
+	if c == null then return '\1'
+	return c
 end
 
 # Read a line from the standard input (`stdin`).
-protected fun gets: String
+fun gets: String
 do
 	return sys.stdin.read_line
 end
 
 # Return the working (current) directory
-protected fun getcwd: String do return file_getcwd.to_s
-private fun file_getcwd: NativeString is extern "string_NativeString_NativeString_file_getcwd_0"
+fun getcwd: String do return native_getcwd.to_s
+
+private fun native_getcwd: NativeString `{ return getcwd(NULL, 0); `}