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

diff --git a/lib/standard/file.nit b/lib/standard/file.nit
index 81341ad..9687b0c 100644
--- a/lib/standard/file.nit
+++ b/lib/standard/file.nit
@@ -42,7 +42,17 @@ 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
@@ -87,6 +97,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
@@ -98,32 +113,41 @@ class FileReader
 			return
 		end
 		end_reached = false
-		_buffer_pos = 0
-		_buffer.clear
+		buffer_reset
 	end
 
 	redef fun close
 	do
 		super
-		_buffer.clear
+		buffer_reset
 		end_reached = true
 	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
@@ -136,6 +160,8 @@ class FileReader
 	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)
@@ -152,17 +178,42 @@ 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, 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")
+			return
+		end
+		for i in s.substrings do write_native(i.to_cstring, i.length)
+	end
+
+	redef fun write_byte(value)
+	do
+		if last_error != null then return
+		if not _is_writable then
 			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)
+		if _file.address_is_null then
+			last_error = new IOError("Writing on a null stream")
+			_is_writable = false
+			return
+		end
+
+		var err = _file.write_byte(value)
+		if err != 1 then
+			# Big problem
+			last_error = new IOError("Problem writing a byte: {err}")
 		end
 	end
 
@@ -225,18 +276,20 @@ redef class Int
 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
 
@@ -246,10 +299,12 @@ class Stdin
 		prepare_buffer(1)
 	end
 
-	redef fun poll_in: Bool is extern "file_stdin_poll_in"
+	redef fun poll_in is extern "file_stdin_poll_in"
 end
 
 # Standard output stream.
+#
+# The class of the default value of `sys.stdout`.
 class Stdout
 	super FileWriter
 	init do
@@ -261,6 +316,8 @@ class Stdout
 end
 
 # Standard error stream.
+#
+# The class of the default value of `sys.stderr`.
 class Stderr
 	super FileWriter
 	init do
@@ -307,6 +364,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
@@ -333,8 +394,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`
@@ -380,10 +439,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
@@ -460,7 +521,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
@@ -502,6 +563,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
@@ -509,6 +575,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
@@ -516,13 +588,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
@@ -546,6 +621,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
@@ -592,10 +672,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
@@ -677,12 +767,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
@@ -694,17 +786,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
@@ -718,7 +822,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.
@@ -839,28 +942,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
 	#
@@ -869,8 +991,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)
 	#
@@ -900,37 +1032,34 @@ 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;
-
-			results = new_Array_of_String();
-
-			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 );
-				}
+	# 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
 
-			closedir( dir );
-			return results;
-		}
-	`}
+		return res
+	end
 end
 
 redef class NativeString
@@ -940,19 +1069,19 @@ redef class NativeString
 		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 rmdir: Bool `{ return !rmdir(self); `}
 	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_chdir: Bool is extern "string_NativeString_NativeString_file_chdir_0"
 	private fun file_realpath: NativeString is extern "file_NativeString_realpath"
 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"
 	# Returns the last access time
@@ -965,28 +1094,32 @@ extern class NativeFileStat `{ struct stat * `}
 	fun size: Int is extern "file_FileStat_FileStat_size_0"
 
 	# 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 write_byte(value: Int): Int `{
+		unsigned char b = (unsigned char)value;
+		return fwrite(&b, 1, 1, self);
+	`}
 	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 fileno: Int `{ return fileno(self); `}
 	# Flushes the buffer, forcing the write operation
 	fun flush: Int is extern "fflush"
 	# Used to specify how the buffering will be handled for the current stream.
@@ -999,6 +1132,24 @@ private extern class NativeFile `{ FILE* `}
 	new native_stderr is extern "file_NativeFileCapable_NativeFileCapable_native_stderr_0"
 end
 
+# Standard `DIR*` pointer
+private extern class NativeDir `{ DIR* `}
+
+	# 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
@@ -1096,30 +1247,39 @@ 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
+fun getcwd: String do return file_getcwd.to_s
 private fun file_getcwd: NativeString is extern "string_NativeString_NativeString_file_getcwd_0"