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

diff --git a/lib/standard/file.nit b/lib/standard/file.nit
index bbb45d2..f82a1fd 100644
--- a/lib/standard/file.nit
+++ b/lib/standard/file.nit
@@ -12,99 +12,114 @@
 # You  are  allowed  to  redistribute it and sell it, alone or is a part of
 # another product.
 
-# This module handle file input and output
-package file
+# File manipulations (create, read, write, etc.)
+module file
 
 intrude import stream
-intrude import string
+intrude import ropes
 import string_search
+import time
+
+in "C Header" `{
+	#include <dirent.h>
+	#include <string.h>
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <unistd.h>
+`}
 
 redef class Object
 # Simple I/O
 
-	# Print `objects' on the standard output (`stdout').
-	protected meth printn(objects: Object...)
+	# Print `objects` on the standard output (`stdout`).
+	protected fun printn(objects: Object...)
 	do
-		stdout.write(objects.to_s)
+		sys.stdout.write(objects.to_s)
 	end
 
-	# Print an `object' on the standard output (`stdout') and add a newline.
-	protected meth print(object: Object)
+	# Print an `object` on the standard output (`stdout`) and add a newline.
+	protected fun print(object: Object)
 	do
-		stdout.write(object.to_s)
-		stdout.write("\n")
+		sys.stdout.write(object.to_s)
+		sys.stdout.write("\n")
 	end
 
-	# Read a character from the standard input (`stdin').
-	protected meth getc: Char
+	# Read a character from the standard input (`stdin`).
+	protected fun getc: Char
 	do
-		return stdin.read_char.ascii
+		return sys.stdin.read_char.ascii
 	end
 
-	# Read a line from the standard input (`stdin').
-	protected meth gets: String
+	# Read a line from the standard input (`stdin`).
+	protected fun gets: String
 	do
-		return stdin.read_line
+		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"
 end
 
 # File Abstract Stream
-class FStream
-special IOS
-special NativeFileCapable
+abstract class FStream
+	super IOS
 	# The path of the file.
-	readable attr _path: nullable String = null
+	var path: nullable String = null
 
 	# The FILE *.
-	attr _file: nullable NativeFile = null
+	var _file: nullable NativeFile = null
 
-	meth file_stat: FileStat
+	fun file_stat: FileStat
 	do return _file.file_stat end
 end
 
 # File input stream
 class IFStream
-special FStream
-special BufferedIStream
+	super FStream
+	super BufferedIStream
 	# Misc
 
-	meth reopen
+	# Open the same file again.
+	# The original path is reused, therefore the reopened file can be a different file.
+	fun reopen
 	do
 		if not eof then close
-		_file = io_open_read(_path.to_cstring)
-		_end_reached = false
+		_file = new NativeFile.io_open_read(path.to_cstring)
+		end_reached = false
 		_buffer_pos = 0
 		_buffer.clear
 	end
 
-	redef meth close
+	redef fun close
 	do
 		var i = _file.io_close
-		_end_reached = true
+		end_reached = true
 	end
 
-	# Fill the internal read buffer. Needed by read operations.
-	redef meth fill_buffer
+	redef fun fill_buffer
 	do
-		var nb = _file.io_read(_buffer._items, _buffer._capacity)
+		var nb = _file.io_read(_buffer.items, _buffer.capacity)
 		if nb <= 0 then
-			_end_reached = true
+			end_reached = true
 			nb = 0
 		end
-		_buffer._length = nb
+		_buffer.length = nb
 		_buffer_pos = 0
 	end
 	
 	# End of file?
-	redef readable attr _end_reached: Bool = false
+	redef var end_reached: Bool = false
 
-	# Open the file at `path' for reading.
+	# Open the file at `path` for reading.
 	init open(path: String)
 	do
-		_path = path
+		self.path = path
 		prepare_buffer(10)
-		_file = io_open_read(_path.to_cstring)
-		assert cant_open_file: _file != null
+		_file = new NativeFile.io_open_read(path.to_cstring)
+		assert not _file.address_is_null else
+			print "Error: Opening file at '{path}' failed with '{sys.errno.strerror}'"
+		end
 	end
 
 	private init do end
@@ -113,29 +128,32 @@ end
 
 # File output stream
 class OFStream
-special FStream
-special OStream
+	super FStream
+	super OStream
 	
-	# Write a string.
-	redef meth write(s)
+	redef fun write(s)
 	do
 		assert _writable
-		write_native(s.to_cstring, s.length)
+		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
 	end
 
-	redef meth is_writable do return _writable
+	redef fun is_writable do return _writable
 	
-	redef meth close
+	redef fun close
 	do
 		var i = _file.io_close
 		_writable = false
 	end
 
 	# Is the file open in write mode
-	attr _writable: Bool
+	var _writable: Bool
 	
-	# Write `len' bytes from `native'.
-	private meth write_native(native: NativeString, len: Int)
+	# Write `len` bytes from `native`.
+	private fun write_native(native: NativeString, len: Int)
 	do
 		assert _writable
 		var err = _file.io_write(native, len)
@@ -145,12 +163,14 @@ special OStream
 		end
 	end
 	
-	# Open the file at `path' for writing.
+	# Open the file at `path` for writing.
 	init open(path: String)
 	do
-		_file = io_open_write(path.to_cstring)
-		assert cant_open_file: _file != null
-		_path = path
+		_file = new NativeFile.io_open_write(path.to_cstring)
+		assert not _file.address_is_null else
+			print "Error: Opening file at '{path}' failed with '{sys.errno.strerror}'"
+		end
+		self.path = path
 		_writable = true
 	end
 	
@@ -161,43 +181,88 @@ end
 ###############################################################################
 
 class Stdin
-special IFStream
+	super IFStream
+	super PollableIStream
+
 	private init do
-		_file = native_stdin
-		_path = "/dev/stdin"
+		_file = new NativeFile.native_stdin
+		path = "/dev/stdin"
 		prepare_buffer(1)
 	end
+
+	redef fun poll_in: Bool is extern "file_stdin_poll_in"
 end
 
 class Stdout
-special OFStream
+	super OFStream
 	private init do
-		_file = native_stdout
-		_path = "/dev/stdout"
+		_file = new NativeFile.native_stdout
+		path = "/dev/stdout"
 		_writable = true
 	end
 end
 
 class Stderr
-special OFStream
+	super OFStream
 	private init do
-		_file = native_stderr
-		_path = "/dev/stderr"
+		_file = new NativeFile.native_stderr
+		path = "/dev/stderr"
 		_writable = true
 	end
 end
 
 ###############################################################################
 
+redef class Streamable
+	# Like `write_to` but take care of creating the file
+	fun write_to_file(filepath: String)
+	do
+		var stream = new OFStream.open(filepath)
+		write_to(stream)
+		stream.close
+	end
+end
+
 redef class String
 	# return true if a file with this names exists
-	meth file_exists: Bool do return to_cstring.file_exists
+	fun file_exists: Bool do return to_cstring.file_exists
+
+	# The status of a file. see POSIX stat(2).
+	fun file_stat: FileStat do return to_cstring.file_stat
 
-	meth file_stat: FileStat do return to_cstring.file_stat
+	# The status of a file or of a symlink. see POSIX lstat(2).
+	fun file_lstat: FileStat do return to_cstring.file_lstat
 
-	meth file_delete: Bool do return to_cstring.file_delete
+	# Remove a file, return true if success
+	fun file_delete: Bool do return to_cstring.file_delete
+
+	# Copy content of file at `self` to `dest`
+	fun file_copy_to(dest: String)
+	do
+		var input = new IFStream.open(self)
+		var output = new OFStream.open(dest)
+
+		while not input.eof do
+			var buffer = input.read(1024)
+			output.write buffer
+		end
+
+		input.close
+		output.close
+	end
 
-	meth strip_extension(ext: String): String
+	# Remove the trailing extension `ext`.
+	#
+	# `ext` usually starts with a dot but could be anything.
+	#
+	#     assert "file.txt".strip_extension(".txt")  == "file"
+	#     assert "file.txt".strip_extension("le.txt")  == "fi"
+	#     assert "file.txt".strip_extension("xt")  == "file.t"
+	#
+	# if `ext` is not present, `self` is returned unmodified.
+	#
+	#     assert "file.txt".strip_extension(".tar.gz")  == "file.txt"
+	fun strip_extension(ext: String): String
 	do
 		if has_suffix(ext) then
 			return substring(0, length - ext.length)
@@ -205,41 +270,120 @@ redef class String
 		return self
 	end
 
-	meth basename(ext: String): String
+	# Extract the basename of a path and remove the extension
+	#
+	#     assert "/path/to/a_file.ext".basename(".ext")         == "a_file"
+	#     assert "path/to/a_file.ext".basename(".ext")          == "a_file"
+	#     assert "path/to".basename(".ext")                     == "to"
+	#     assert "path/to/".basename(".ext")                    == "to"
+	#     assert "path".basename("")                        == "path"
+	#     assert "/path".basename("")                       == "path"
+	#     assert "/".basename("")                           == "/"
+	#     assert "".basename("")                            == ""
+	fun basename(ext: String): String
 	do
-		var pos = last_index_of_from('/', _length - 1)
+		var l = length - 1 # Index of the last char
+		while l > 0 and self.chars[l] == '/' do l -= 1 # remove all trailing `/`
+		if l == 0 then return "/"
+		var pos = chars.last_index_of_from('/', l)
 		var n = self
 		if pos >= 0 then
-			n = substring_from(pos+1)
+			n = substring(pos+1, l-pos)
 		end
 		return n.strip_extension(ext)
 	end
 
-	meth dirname: String
+	# Extract the dirname of a path
+	#
+	#     assert "/path/to/a_file.ext".dirname         == "/path/to"
+	#     assert "path/to/a_file.ext".dirname          == "path/to"
+	#     assert "path/to".dirname                     == "path"
+	#     assert "path/to/".dirname                    == "path"
+	#     assert "path".dirname                        == "."
+	#     assert "/path".dirname                       == "/"
+	#     assert "/".dirname                           == "/"
+	#     assert "".dirname                            == "."
+	fun dirname: String
 	do
-		var pos = last_index_of_from('/', _length - 1)
-		if pos >= 0 then
+		var l = length - 1 # Index of the last char
+		while l > 0 and self.chars[l] == '/' do l -= 1 # remove all trailing `/`
+		var pos = chars.last_index_of_from('/', l)
+		if pos > 0 then
 			return substring(0, pos)
+		else if pos == 0 then
+			return "/"
 		else
 			return "."
 		end
 	end
 
-	meth file_path: String
+	# Return the canonicalized absolute pathname (see POSIX function `realpath`)
+	fun realpath: String do
+		var cs = to_cstring.file_realpath
+		var res = cs.to_s_with_copy
+		# cs.free_malloc # FIXME memory leak
+		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
+	#
+	# Note that the method only wonrk on the string:
+	#  * no I/O access is performed
+	#  * the validity of the path is not checked
+	#
+	#     assert "some/./complex/../../path/from/../to/a////file//".simplify_path	     ==  "path/to/a/file"
+	#     assert "../dir/file".simplify_path       ==  "../dir/file"
+	#     assert "dir/../../".simplify_path        ==  ".."
+	#     assert "dir/..".simplify_path            ==  "."
+	#     assert "//absolute//path/".simplify_path ==  "/absolute/path"
+	fun simplify_path: String
 	do
-		var l = _length
-		var pos = last_index_of_from('/', l - 1)
-		if pos >= 0 then
-			return substring(0, pos)
+		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 and a2.last != ".." then
+				a2.pop
+				continue
+			end
+			a2.push(x)
 		end
-		return "."
+		if a2.is_empty then return "."
+		return a2.join("/")
+	end
+
+	# Correctly join two path using the directory separator.
+	#
+	# Using a standard "{self}/{path}" does not work when `self` is the empty string.
+	# This method ensure that the join is valid.
+	#
+	#     assert "hello".join_path("world")      ==  "hello/world"
+	#     assert "hel/lo".join_path("wor/ld")      ==  "hel/lo/wor/ld"
+	#     assert "".join_path("world")      ==  "world"
+	#     assert "/hello".join_path("/world")      ==  "/world"
+	#
+	# Note: you may want to use `simplify_path` on the result
+	#
+	# Note: I you want to join a great number of path, you can write
+	#
+	#     [p1, p2, p3, p4].join("/")
+	fun join_path(path: String): String
+	do
+		if path.is_empty then return self
+		if self.is_empty then return path
+		if path.chars[0] == '/' then return path
+		return "{self}/{path}"
 	end
 
 	# Create a directory (and all intermediate directories if needed)
-	meth mkdir
+	fun mkdir
 	do
 		var dirs = self.split_with("/")
-		var path = new Buffer
+		var path = new FlatBuffer
 		if dirs.is_empty then return
 		if dirs[0].is_empty then
 			# it was a starting /
@@ -252,47 +396,147 @@ redef class String
 			path.to_s.to_cstring.file_mkdir
 		end
 	end
+
+	# Change the current working directory
+	#
+	#     "/etc".chdir
+	#     assert getcwd == "/etc"
+	#     "..".chdir
+	#     assert getcwd == "/"
+	#
+	# TODO: errno
+	fun chdir do to_cstring.file_chdir
+
+	# Return right-most extension (without the dot)
+	#
+	# Only the last extension is returned.
+	# There is no special case for combined extensions.
+	#
+	#     assert "file.txt".file_extension      == "txt"
+	#     assert "file.tar.gz".file_extension   == "gz"
+	#
+	# For file without extension, `null` is returned.
+	# Hoever, for trailing dot, `""` is returned.
+	#
+	#     assert "file".file_extension          == null
+	#     assert "file.".file_extension         == ""
+	#
+	# The starting dot of hidden files is never considered.
+	#
+	#     assert ".file.txt".file_extension     == "txt"
+	#     assert ".file".file_extension         == null
+	fun file_extension: nullable String
+	do
+		var last_slash = chars.last_index_of('.')
+		if last_slash > 0 then
+			return substring( last_slash+1, length )
+		else
+			return null
+		end
+	end
+
+	# returns files contained within the directory represented by self
+	fun files : Set[ String ] is extern import HashSet[String], HashSet[String].add, NativeString.to_s, String.to_cstring, HashSet[String].as(Set[String]) `{
+		char *dir_path;
+		DIR *dir;
+
+		dir_path = String_to_cstring( recv );
+		if ((dir = opendir(dir_path)) == NULL)
+		{
+			perror( dir_path );
+			exit( 1 );
+		}
+		else
+		{
+			HashSet_of_String results;
+			String file_name;
+			struct dirent *de;
+
+			results = new_HashSet_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 ) );
+					HashSet_of_String_add( results, file_name );
+				}
+
+			closedir( dir );
+			return HashSet_of_String_as_Set_of_String( results );
+		}
+	`}
 end
 
 redef class NativeString
-	private meth file_exists: Bool is extern "string_NativeString_NativeString_file_exists_0"
-	private meth file_stat: FileStat is extern "string_NativeString_NativeString_file_stat_0"
-	private meth file_mkdir: Bool is extern "string_NativeString_NativeString_file_mkdir_0"
-	private meth file_delete: Bool is extern "string_NativeString_NativeString_file_delete_0"
+	private fun file_exists: Bool is extern "string_NativeString_NativeString_file_exists_0"
+	private fun file_stat: FileStat is extern "string_NativeString_NativeString_file_stat_0"
+	private fun file_lstat: FileStat `{
+		struct stat* stat_element;
+		int res;
+		stat_element = malloc(sizeof(struct stat));
+		res = lstat(recv, 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 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"
 end
 
-universal FileStat
-special Pointer
 # This class is system dependent ... must reify the vfs
-	meth mode: Int is extern "file_FileStat_FileStat_mode_0"
-	meth atime: Int is extern "file_FileStat_FileStat_atime_0"
-	meth ctime: Int is extern "file_FileStat_FileStat_ctime_0"
-	meth mtime: Int is extern "file_FileStat_FileStat_mtime_0"
-	meth size: Int is extern "file_FileStat_FileStat_size_0"
+extern class FileStat `{ struct stat * `}
+	# Returns the permission bits of file
+	fun mode: Int is extern "file_FileStat_FileStat_mode_0"
+	# Returns the last access time
+	fun atime: Int is extern "file_FileStat_FileStat_atime_0"
+	# Returns the last status change time 
+	fun ctime: Int is extern "file_FileStat_FileStat_ctime_0"
+	# Returns the last modification time
+	fun mtime: Int is extern "file_FileStat_FileStat_mtime_0"
+	# Returns the size
+	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); `}
+	# Returns true if it is a directory
+	fun is_dir: Bool `{ return S_ISDIR(recv->st_mode); `}
+	# Returns true if it is a character device
+	fun is_chr: Bool `{ return S_ISCHR(recv->st_mode); `}
+	# Returns true if it is a block device
+	fun is_blk: Bool `{ return S_ISBLK(recv->st_mode); `}
+	# Returns true if the type is fifo
+	fun is_fifo: Bool `{ return S_ISFIFO(recv->st_mode); `}
+	# Returns true if the type is a link
+	fun is_lnk: Bool `{ return S_ISLNK(recv->st_mode); `}
+	# Returns true if the type is a socket
+	fun is_sock: Bool `{ return S_ISSOCK(recv->st_mode); `}
 end
 
 # Instance of this class are standard FILE * pointers
-private universal NativeFile
-special Pointer
-	meth io_read(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_read_2"
-	meth io_write(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_write_2"
-	meth io_close: Int is extern "file_NativeFile_NativeFile_io_close_0"
-	meth file_stat: FileStat is extern "file_NativeFile_NativeFile_file_stat_0"
+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: FileStat is extern "file_NativeFile_NativeFile_file_stat_0"
+
+	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"
 end
 
-private interface NativeFileCapable
-	meth io_open_read(path: NativeString): NativeFile is extern "file_NativeFileCapable_NativeFileCapable_io_open_read_1"
-	meth io_open_write(path: NativeString): NativeFile is extern "file_NativeFileCapable_NativeFileCapable_io_open_write_1"
-	meth native_stdin: NativeFile is extern "file_NativeFileCapable_NativeFileCapable_native_stdin_0"
-	meth native_stdout: NativeFile is extern "file_NativeFileCapable_NativeFileCapable_native_stdout_0"
-	meth native_stderr: NativeFile is extern "file_NativeFileCapable_NativeFileCapable_native_stderr_0"
-end
+redef class Sys
 
-# Standard input.
-meth stdin: IFStream do return once new Stdin
+	# Standard input
+	var stdin: PollableIStream protected writable = new Stdin
 
-# Standard output.
-meth stdout: OFStream do return once new Stdout
+	# Standard output
+	var stdout: OStream protected writable = new Stdout
 
-# Standard output for error.
-meth stderr: OFStream do return once new Stderr
+	# Standard output for errors
+	var stderr: OStream protected writable = new Stderr
+
+end