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

diff --git a/lib/standard/file.nit b/lib/standard/file.nit
index 6592b85..239f785 100644
--- a/lib/standard/file.nit
+++ b/lib/standard/file.nit
@@ -12,46 +12,50 @@
 # 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
 import string_search
+import time
 
 redef class Object
 # Simple I/O
 
-	# Print `objects' on the standard output (`stdout').
+	# Print `objects` on the standard output (`stdout`).
 	protected fun printn(objects: Object...)
 	do
 		stdout.write(objects.to_s)
 	end
 
-	# Print an `object' on the standard output (`stdout') and add a newline.
+	# 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")
 	end
 
-	# Read a character from the standard input (`stdin').
+	# Read a character from the standard input (`stdin`).
 	protected fun getc: Char
 	do
 		return stdin.read_char.ascii
 	end
 
-	# Read a line from the standard input (`stdin').
+	# Read a line from the standard input (`stdin`).
 	protected fun gets: String
 	do
 		return 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
+abstract class FStream
 	super IOS
-	super NativeFileCapable
 	# The path of the file.
 	readable var _path: nullable String = null
 
@@ -68,10 +72,12 @@ class IFStream
 	super BufferedIStream
 	# Misc
 
+	# 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)
+		_file = new NativeFile.io_open_read(_path.to_cstring)
 		_end_reached = false
 		_buffer_pos = 0
 		_buffer.clear
@@ -83,7 +89,6 @@ class IFStream
 		_end_reached = true
 	end
 
-	# Fill the internal read buffer. Needed by read operations.
 	redef fun fill_buffer
 	do
 		var nb = _file.io_read(_buffer._items, _buffer._capacity)
@@ -98,12 +103,12 @@ class IFStream
 	# End of file?
 	redef readable 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
 		prepare_buffer(10)
-		_file = io_open_read(_path.to_cstring)
+		_file = new NativeFile.io_open_read(_path.to_cstring)
 		assert cant_open_file: _file != null
 	end
 
@@ -116,7 +121,6 @@ class OFStream
 	super FStream
 	super OStream
 	
-	# Write a string.
 	redef fun write(s)
 	do
 		assert _writable
@@ -134,7 +138,7 @@ class OFStream
 	# Is the file open in write mode
 	var _writable: Bool
 	
-	# Write `len' bytes from `native'.
+	# Write `len` bytes from `native`.
 	private fun write_native(native: NativeString, len: Int)
 	do
 		assert _writable
@@ -145,10 +149,10 @@ class OFStream
 		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)
+		_file = new NativeFile.io_open_write(path.to_cstring)
 		assert cant_open_file: _file != null
 		_path = path
 		_writable = true
@@ -163,16 +167,20 @@ end
 class Stdin
 	super IFStream
 	private init do
-		_file = native_stdin
+		_file = new NativeFile.native_stdin
 		_path = "/dev/stdin"
 		prepare_buffer(1)
 	end
+
+	# Is these something to read? (non blocking)
+	# FIXME: should be generalized
+	fun poll_in: Bool is extern "file_stdin_poll_in"
 end
 
 class Stdout
 	super OFStream
 	private init do
-		_file = native_stdout
+		_file = new NativeFile.native_stdout
 		_path = "/dev/stdout"
 		_writable = true
 	end
@@ -181,7 +189,7 @@ end
 class Stderr
 	super OFStream
 	private init do
-		_file = native_stderr
+		_file = new NativeFile.native_stderr
 		_path = "/dev/stderr"
 		_writable = true
 	end
@@ -194,9 +202,12 @@ redef class String
 	fun file_exists: Bool do return to_cstring.file_exists
 
 	fun file_stat: FileStat do return to_cstring.file_stat
+	fun file_lstat: FileStat do return to_cstring.file_lstat
 
+	# Remove a file, return true if success
 	fun file_delete: Bool do return to_cstring.file_delete
 
+	# remove the trailing extension "ext"
 	fun strip_extension(ext: String): String
 	do
 		if has_suffix(ext) then
@@ -205,6 +216,7 @@ redef class String
 		return self
 	end
 
+	# Extract the basename of a path and remove the extension
 	fun basename(ext: String): String
 	do
 		var pos = last_index_of_from('/', _length - 1)
@@ -215,24 +227,90 @@ redef class String
 		return n.strip_extension(ext)
 	end
 
+	# 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
+		if l > 0 and self[l] == '/' then l -= 1 # remove trailing `/`
+		var pos = last_index_of_from('/', l)
+		if pos > 0 then
 			return substring(0, pos)
+		else if pos == 0 then
+			return "/"
 		else
 			return "."
 		end
 	end
 
-	fun 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[0] == '/' then return path
+		return "{self}/{path}"
 	end
 
 	# Create a directory (and all intermediate directories if needed)
@@ -253,6 +331,17 @@ redef class String
 		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)
 	fun file_extension : nullable String
 	do
 		var last_slash = last_index_of('.')
@@ -262,44 +351,61 @@ redef class String
 			return null
 		end
 	end
+
+	# returns files contained within the directory represented by self
+	fun files : Set[ String ] is extern import HashSet, HashSet::add, NativeString::to_s, String::to_cstring, HashSet[String] as( Set[String] ), String as( Object )
 end
 
 redef class NativeString
 	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
-	super Pointer
+extern FileStat `{ struct stat * `}
 # This class is system dependent ... must reify the vfs
 	fun mode: Int is extern "file_FileStat_FileStat_mode_0"
 	fun atime: Int is extern "file_FileStat_FileStat_atime_0"
 	fun ctime: Int is extern "file_FileStat_FileStat_ctime_0"
 	fun mtime: Int is extern "file_FileStat_FileStat_mtime_0"
 	fun size: Int is extern "file_FileStat_FileStat_size_0"
+
+	fun is_reg: Bool `{ return S_ISREG(recv->st_mode); `}
+	fun is_dir: Bool `{ return S_ISDIR(recv->st_mode); `}
+	fun is_chr: Bool `{ return S_ISCHR(recv->st_mode); `}
+	fun is_blk: Bool `{ return S_ISBLK(recv->st_mode); `}
+	fun is_fifo: Bool `{ return S_ISFIFO(recv->st_mode); `}
+	fun is_lnk: Bool `{ return S_ISLNK(recv->st_mode); `}
+	fun is_sock: Bool `{ return S_ISSOCK(recv->st_mode); `}
 end
 
 # Instance of this class are standard FILE * pointers
-private universal NativeFile
-	super Pointer
+private extern NativeFile
 	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"
-end
 
-private interface NativeFileCapable
-	fun io_open_read(path: NativeString): NativeFile is extern "file_NativeFileCapable_NativeFileCapable_io_open_read_1"
-	fun io_open_write(path: NativeString): NativeFile is extern "file_NativeFileCapable_NativeFileCapable_io_open_write_1"
-	fun native_stdin: NativeFile is extern "file_NativeFileCapable_NativeFileCapable_native_stdin_0"
-	fun native_stdout: NativeFile is extern "file_NativeFileCapable_NativeFileCapable_native_stdout_0"
-	fun native_stderr: NativeFile is extern "file_NativeFileCapable_NativeFileCapable_native_stderr_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
 
 # Standard input.
-fun stdin: IFStream do return once new Stdin
+fun stdin: Stdin do return once new Stdin
 
 # Standard output.
 fun stdout: OFStream do return once new Stdout