# 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
-redef class Object
-# Simple I/O
-
- # Print `objects' on the standard output (`stdout').
- protected meth printn(objects: Object...)
- do
- stdout.write(objects.to_s)
- end
-
- # Print an `object' on the standard output (`stdout') and add a newline.
- protected meth print(object: Object)
- do
- if object != null then
- stdout.write(object.to_s)
- end
- stdout.write("\n")
- end
-
- # Read a character from the standard input (`stdin').
- protected meth getc: Char
- do
- return stdin.read_char.ascii
- end
-
- # Read a line from the standard input (`stdin').
- protected meth gets: String
- do
- return stdin.read_line
- end
-end
+in "C Header" `{
+ #include <dirent.h>
+ #include <string.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <unistd.h>
+`}
# File Abstract Stream
-class FStream
-special IOS
-special NativeFileCapable
-
+abstract class FStream
+ super IOS
# The path of the file.
- readable attr _path: String = null
+ var path: nullable String = null
# The FILE *.
- attr _file: 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
# 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)
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
###############################################################################
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
- meth strip_extension(ext: String): String
+ # 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
+
+ # 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)
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 /
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
+
+redef class Sys
+
+ # Standard input
+ var stdin: PollableIStream protected writable = new Stdin
+
+ # Standard output
+ var stdout: OStream protected writable = new Stdout
+
+ # Standard output for errors
+ var stderr: OStream protected writable = new Stderr
+
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"
+# Print `objects` on the standard output (`stdout`).
+protected fun printn(objects: Object...)
+do
+ sys.stdout.write(objects.to_s)
end
-# Standard input.
-meth stdin: IFStream do return once new Stdin
+# Print an `object` on the standard output (`stdout`) and add a newline.
+protected fun print(object: Object)
+do
+ sys.stdout.write(object.to_s)
+ sys.stdout.write("\n")
+end
-# Standard output.
-meth stdout: OFStream do return once new Stdout
+# Read a character from the standard input (`stdin`).
+protected fun getc: Char
+do
+ return sys.stdin.read_char.ascii
+end
+
+# Read a line from the standard input (`stdin`).
+protected fun gets: String
+do
+ return sys.stdin.read_line
+end
-# Standard output for error.
-meth stderr: OFStream do return once new Stderr
+# 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"
nitlanguage / nit.git / blobdiff