X-Git-Url: http://nitlanguage.org diff --git a/lib/standard/file.nit b/lib/standard/file.nit index 8cf529b..956d72f 100644 --- a/lib/standard/file.nit +++ b/lib/standard/file.nit @@ -6,7 +6,7 @@ # # This file is free software, which comes along with NIT. This software is # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; -# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. You can modify it is you want, provided this header # is kept unaltered, and a notification of the changes is added. # You are allowed to redistribute it and sell it, alone or is a part of @@ -16,9 +16,10 @@ module file intrude import stream -intrude import string +intrude import ropes import string_search import time +import gc in "C Header" `{ #include @@ -26,210 +27,358 @@ in "C Header" `{ #include #include #include + #include + #include + #include `} -redef class Object -# Simple I/O +# `Stream` used to interact with a File or FileDescriptor +abstract class FileStream + super Stream + # The path of the file. + var path: nullable String = null - # Print `objects` on the standard output (`stdout`). - protected fun printn(objects: Object...) - do - stdout.write(objects.to_s) - end + # The FILE *. + private var file: nullable NativeFile = null - # Print an `object` on the standard output (`stdout`) and add a newline. - protected fun print(object: Object) + # The status of a file. see POSIX stat(2). + # + # 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 - stdout.write(object.to_s) - stdout.write("\n") + var stat = _file.file_stat + if stat.address_is_null then return null + return new FileStat(stat) end - # Read a character from the standard input (`stdin`). - protected fun getc: Char - do - return stdin.read_char.ascii - end + # File descriptor of this file + fun fd: Int do return _file.fileno - # Read a line from the standard input (`stdin`). - protected fun gets: String + redef fun close do - return stdin.read_line + 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 - # 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 -abstract class FStream - super IOS - # The path of the file. - readable var _path: nullable String = null - - # The FILE *. - var _file: nullable NativeFile = null - - fun file_stat: FileStat - do return _file.file_stat 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 + 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 + last_error = new IOError("Error while changing buffering type for FileStream, returned error {sys.errno.strerror}") + end + end end -# File input stream -class IFStream - super FStream - super BufferedIStream +# `Stream` that can read from a File +class FileReader + super FileStream + super BufferedReader + super PollableReader # Misc # 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 then close - _file = new NativeFile.io_open_read(_path.to_cstring) - _end_reached = false + if not eof and not _file.address_is_null then close + last_error = null + _file = new NativeFile.io_open_read(path.to_cstring) + if _file.address_is_null then + last_error = new IOError("Error: Opening file at '{path.as(not null)}' failed with '{sys.errno.strerror}'") + end_reached = true + return + end + end_reached = false _buffer_pos = 0 _buffer.clear end redef fun close do - var i = _file.io_close - _end_reached = true + super + _buffer.clear + end_reached = true end 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 var _end_reached: Bool = false + redef var end_reached: Bool = 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 - _path = path + self.path = path prepare_buffer(10) - _file = new NativeFile.io_open_read(_path.to_cstring) - assert cant_open_file: _file != null + _file = new NativeFile.io_open_read(path.to_cstring) + if _file.address_is_null then + last_error = new IOError("Error: Opening file at '{path}' failed with '{sys.errno.strerror}'") + end_reached = true + end end - private init do end - private init without_file do 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) + _file = fd.fd_to_stream(read_only) + if _file.address_is_null then + last_error = new IOError("Error: Converting fd {fd} to stream failed with '{sys.errno.strerror}'") + end_reached = true + end + end end -# File output stream -class OFStream - super FStream - super OStream - +# `Stream` that can write to a File +class FileWriter + super FileStream + super Writer + redef fun write(s) do - assert _writable - write_native(s.to_cstring, s.length) + 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) + end end - redef fun is_writable do return _writable - redef fun close do - var i = _file.io_close - _writable = false + super + _is_writable = false end + redef var is_writable = false - # Is the file open in write mode - var _writable: Bool - # Write `len` bytes from `native`. private fun write_native(native: NativeString, len: Int) do - assert _writable + 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 + last_error = new IOError("Writing on a null stream") + _is_writable = false + return + end var err = _file.io_write(native, len) if err != len then # Big problem - printn("Problem in writing : ", err, " ", len, "\n") + last_error = new IOError("Problem in writing : {err} {len} \n") end end - + # Open the file at `path` for writing. init open(path: String) do _file = new NativeFile.io_open_write(path.to_cstring) - assert cant_open_file: _file != null - _path = path - _writable = true + self.path = path + _is_writable = true + if _file.address_is_null then + last_error = new IOError("Error: Opening file at '{path}' failed with '{sys.errno.strerror}'") + is_writable = false + end + end + + # Creates a new File stream from a file descriptor + init from_fd(fd: Int) do + self.path = "" + _file = fd.fd_to_stream(wipe_write) + _is_writable = true + if _file.address_is_null then + last_error = new IOError("Error: Opening stream from file descriptor {fd} failed with '{sys.errno.strerror}'") + _is_writable = false + end end - - private init do end - private init without_file do end end +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" +end + +# Constant for read-only file streams +private fun read_only: NativeString do return "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 + ############################################################################### +# Standard input stream. +# +# The class of the default value of `sys.stdin`. class Stdin - super IFStream - private init do + super FileReader + + init do _file = new NativeFile.native_stdin - _path = "/dev/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" + redef fun poll_in: Bool is extern "file_stdin_poll_in" end +# Standard output stream. +# +# The class of the default value of `sys.stdout`. class Stdout - super OFStream - private init do + super FileWriter + init do _file = new NativeFile.native_stdout - _path = "/dev/stdout" - _writable = true + 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 OFStream - private init do + super FileWriter + init do _file = new NativeFile.native_stderr - _path = "/dev/stderr" - _writable = true + path = "/dev/stderr" + _is_writable = true end end ############################################################################### -redef class Streamable +redef class Writable # Like `write_to` but take care of creating the file fun write_to_file(filepath: String) do - var stream = new OFStream.open(filepath) + var stream = new FileWriter.open(filepath) write_to(stream) stream.close end end -redef class String - # return true if a file with this names exists - fun file_exists: Bool do return to_cstring.file_exists +# Utility class to access file system services +# +# Usually created with `Text::to_path`. +class Path - fun file_stat: FileStat do return to_cstring.file_stat - fun file_lstat: FileStat do return to_cstring.file_lstat + private var path: String - # Remove a file, return true if success - fun file_delete: Bool do return to_cstring.file_delete + # Path to this file + redef fun to_s do return path - # Copy content of file at `self` to `dest` - fun file_copy_to(dest: String) + # Name of the file name at `to_s` + # + # ~~~ + # var path = "/tmp/somefile".to_path + # assert path.filename == "somefile" + # ~~~ + var filename: String = path.basename("") is lazy + + # Does the file at `path` exists? + fun exists: Bool do return stat != null + + # Information on the file at `self` following symbolic links + # + # 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 + # if stat != null then # Does `p` exist? + # print "It's size is {stat.size}" + # if stat.is_dir then print "It's a directory" + # end + # ~~~ + fun stat: nullable FileStat do - var input = new IFStream.open(self) - var output = new OFStream.open(dest) + var stat = path.to_cstring.file_stat + if stat.address_is_null then return null + return new FileStat(stat) + end + + # Information on the file or link at `self` + # + # Do not follow symbolic links. + fun link_stat: nullable FileStat + do + var stat = path.to_cstring.file_lstat + if stat.address_is_null then return null + return new FileStat(stat) + end + + # Delete a file from the file system, return `true` on success + fun delete: Bool do return path.to_cstring.file_delete + + # Copy content of file at `path` to `dest` + # + # Require: `exists` + fun copy(dest: Path) + do + var input = open_ro + var output = dest.open_wo while not input.eof do var buffer = input.read(1024) @@ -240,7 +389,295 @@ redef class String output.close end - # remove the trailing extension "ext" + # Open this file for reading + # + # Require: `exists and not link_stat.is_dir` + fun open_ro: FileReader + do + # TODO manage streams error when they are merged + return new FileReader.open(path) + end + + # Open this file for writing + # + # Require: `not exists or not stat.is_dir` + fun open_wo: FileWriter + do + # TODO manage streams error when they are merged + return new FileWriter.open(path) + end + + # Read all the content of the file + # + # ~~~ + # var content = "/etc/issue".to_path.read_all + # print content + # ~~~ + # + # See `Reader::read_all` for details. + fun read_all: String + do + var s = open_ro + var res = s.read_all + s.close + return res + end + + # Read all the lines of the file + # + # ~~~ + # var lines = "/etc/passwd".to_path.read_lines + # + # print "{lines.length} users" + # + # for l in lines do + # var fields = l.split(":") + # print "name={fields[0]} uid={fields[2]}" + # end + # ~~~ + # + # See `Reader::read_lines` for details. + fun read_lines: Array[String] + do + var s = open_ro + var res = s.read_lines + s.close + return res + end + + # Return an iterator on each line of the file + # + # ~~~ + # for l in "/etc/passwd".to_path.each_line do + # var fields = l.split(":") + # print "name={fields[0]} uid={fields[2]}" + # end + # ~~~ + # + # Note: the stream is automatically closed at the end of the file (see `LineIterator::close_on_finish`) + # + # See `Reader::each_line` for details. + fun each_line: LineIterator + do + var s = open_ro + var res = s.each_line + res.close_on_finish = true + return res + end + + + # Lists the name of the files contained within the directory at `path` + # + # Require: `exists and is_dir` + fun files: Array[Path] + do + var files = new Array[Path] + for filename in path.files do + files.add new Path(path / filename) + end + return files + 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 file system. + fun rmdir: Bool + do + var ok = true + for file in self.files do + var stat = file.link_stat + if stat.is_dir then + ok = file.rmdir and ok + else + ok = file.delete and ok + end + end + + # Delete the directory itself + if ok then path.to_cstring.rmdir + + return ok + end + + redef fun ==(other) do return other isa Path and path.simplify_path == other.path.simplify_path + redef fun hash do return path.simplify_path.hash +end + +# Information on a file +# +# Created by `Path::stat` and `Path::link_stat`. +# +# The information within this class is gathered when the instance is initialized +# it will not be updated if the targeted file is modified. +class FileStat + super Finalizable + + # TODO private init + + # The low-level status of a file + # + # See: POSIX stat(2) + private var stat: NativeFileStat + + private var finalized = false + + redef fun finalize + do + if not finalized then + stat.free + finalized = true + end + end + + # Returns the last access time in seconds since Epoch + fun last_access_time: Int + do + assert not finalized + 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 + assert not finalized + 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 + assert not finalized + return stat.size + end + + # 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 + assert not finalized + return stat.is_dir + end + + # Is this a symbolic link? + fun is_link: Bool + do + assert not finalized + return stat.is_lnk + end + + # FIXME Make the following POSIX only? or implement in some other way on Windows + + # Returns the last status change time in seconds since Epoch + fun last_status_change_time: Int + do + assert not finalized + 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 + assert not finalized + return stat.mode + end + + # Is this a character device? + fun is_chr: Bool + do + assert not finalized + return stat.is_chr + end + + # Is this a block device? + fun is_blk: Bool + do + assert not finalized + return stat.is_blk + end + + # Is this a FIFO pipe? + fun is_fifo: Bool + do + assert not finalized + return stat.is_fifo + end + + # Is this a UNIX socket + fun is_sock: Bool + do + assert not finalized + return stat.is_sock + end +end + +redef class Text + # Access file system related services on the path at `self` + fun to_path: Path do return new Path(to_s) +end + +redef class String + # return true if a file with this names exists + fun file_exists: Bool do return to_cstring.file_exists + + # The status of a file. see POSIX stat(2). + 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: 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 + + # Copy content of file at `self` to `dest` + fun file_copy_to(dest: String) do to_path.copy(dest.to_path) + + # 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 @@ -261,10 +698,10 @@ redef class String # assert "".basename("") == "" fun basename(ext: String): String do - var l = _length - 1 # Index of the last char + 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 = last_index_of_from('/', l) + var pos = chars.last_index_of_from('/', l) var n = self if pos >= 0 then n = substring(pos+1, l-pos) @@ -284,9 +721,9 @@ redef class String # assert "".dirname == "." fun dirname: String do - var l = _length - 1 # Index of the last char + var l = length - 1 # Index of the last char while l > 0 and self.chars[l] == '/' do l -= 1 # remove all trailing `/` - var pos = last_index_of_from('/', l) + var pos = chars.last_index_of_from('/', l) if pos > 0 then return substring(0, pos) else if pos == 0 then @@ -305,19 +742,24 @@ redef class String 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: + # * ".." are not resolved if they start the path + # * starting "/" is not removed + # * trailing "/" is removed + # + # Note that the method only work 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" + # ~~~ + # 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" + # assert "//absolute//../".simplify_path == "/" + # ~~~ fun simplify_path: String do var a = self.split_with("/") @@ -332,37 +774,139 @@ redef class String a2.push(x) end if a2.is_empty then return "." + if a2.length == 1 and a2.first == "" 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. + # Using a standard "{self}/{path}" does not work in the following cases: + # + # * `self` is empty. + # * `path` starts with `'/'`. # - # 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" + # This method ensures that the join is valid. # - # Note: you may want to use `simplify_path` on the result + # 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" + # assert "hello/".join_path("world") == "hello/world" + # assert "hello/".join_path("/world") == "/world" # - # Note: I you want to join a great number of path, you can write + # Note: You may want to use `simplify_path` on the result. # - # [p1, p2, p3, p4].join("/") + # Note: This method works only with POSIX paths. 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 + if self.last == '/' then return "{self}{path}" return "{self}/{path}" end + # Convert the path (`self`) to a program name. + # + # Ensure the path (`self`) will be treated as-is by POSIX shells when it is + # used as a program name. In order to do that, prepend `./` if needed. + # + # assert "foo".to_program_name == "./foo" + # assert "/foo".to_program_name == "/foo" + # assert "".to_program_name == "./" # At least, your shell will detect the error. + fun to_program_name: String do + if self.has_prefix("/") then + return self + else + return "./{self}" + end + end + + # Alias for `join_path` + # + # assert "hello" / "world" == "hello/world" + # assert "hel/lo" / "wor/ld" == "hel/lo/wor/ld" + # assert "" / "world" == "world" + # assert "/hello" / "/world" == "/world" + # + # This operator is quite useful for chaining changes of path. + # The next one being relative to the previous one. + # + # var a = "foo" + # var b = "/bar" + # var c = "baz/foobar" + # assert a/b/c == "/bar/baz/foobar" + fun /(path: String): String do return join_path(path) + + # Returns the relative path needed to go from `self` to `dest`. + # + # assert "/foo/bar".relpath("/foo/baz") == "../baz" + # assert "/foo/bar".relpath("/baz/bar") == "../../baz/bar" + # + # If `self` or `dest` is relative, they are considered relatively to `getcwd`. + # + # In some cases, the result is still independent of the current directory: + # + # assert "foo/bar".relpath("..") == "../../.." + # + # In other cases, parts of the current directory may be exhibited: + # + # var p = "../foo/bar".relpath("baz") + # var c = getcwd.basename("") + # assert p == "../../{c}/baz" + # + # For path resolution independent of the current directory (eg. for paths in URL), + # or to use an other starting directory than the current directory, + # just force absolute paths: + # + # var start = "/a/b/c/d" + # var p2 = (start/"../foo/bar").relpath(start/"baz") + # assert p2 == "../../d/baz" + # + # + # Neither `self` or `dest` has to be real paths or to exist in directories since + # the resolution is only done with string manipulations and without any access to + # the underlying file system. + # + # If `self` and `dest` are the same directory, the empty string is returned: + # + # assert "foo".relpath("foo") == "" + # assert "foo/../bar".relpath("bar") == "" + # + # The empty string and "." designate both the current directory: + # + # assert "".relpath("foo/bar") == "foo/bar" + # assert ".".relpath("foo/bar") == "foo/bar" + # assert "foo/bar".relpath("") == "../.." + # assert "/" + "/".relpath(".") == getcwd + fun relpath(dest: String): String + do + var cwd = getcwd + var from = (cwd/self).simplify_path.split("/") + if from.last.is_empty then from.pop # case for the root directory + var to = (cwd/dest).simplify_path.split("/") + if to.last.is_empty then to.pop # case for the root directory + + # Remove common prefixes + while not from.is_empty and not to.is_empty and from.first == to.first do + from.shift + to.shift + end + + # Result is going up in `from` with ".." then going down following `to` + var from_len = from.length + if from_len == 0 then return to.join("/") + var up = "../"*(from_len-1) + ".." + if to.is_empty then return up + var res = up + "/" + to.join("/") + return res + end + # Create a directory (and all intermediate directories if needed) 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 / @@ -376,6 +920,12 @@ redef class String end 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 + # Change the current working directory # # "/etc".chdir @@ -387,10 +937,27 @@ redef class String fun chdir do to_cstring.file_chdir # Return right-most extension (without the dot) - fun file_extension : nullable String + # + # 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 = last_index_of('.') - if last_slash >= 0 then + var last_slash = chars.last_index_of('.') + if last_slash > 0 then return substring( last_slash+1, length ) else return null @@ -398,7 +965,7 @@ redef class String 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]) `{ + fun files: Array[String] is extern import Array[String], Array[String].add, NativeString.to_s, String.to_cstring `{ char *dir_path; DIR *dir; @@ -410,30 +977,30 @@ redef class String } else { - HashSet_of_String results; + Array_of_String results; String file_name; struct dirent *de; - results = new_HashSet_of_String(); + 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 ) ); - HashSet_of_String_add( results, file_name ); + Array_of_String_add( results, file_name ); } closedir( dir ); - return HashSet_of_String_as_Set_of_String( results ); + return results; } `} 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 `{ + 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)); @@ -442,18 +1009,19 @@ redef class NativeString 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" end # This class is system dependent ... must reify the vfs -extern class FileStat `{ 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 fun atime: Int is extern "file_FileStat_FileStat_atime_0" - # Returns the last status change time + # 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" @@ -477,11 +1045,16 @@ extern class FileStat `{ struct stat * `} end # Instance of this class are standard FILE * pointers -private extern NativeFile `{ FILE* `} +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" + fun file_stat: NativeFileStat is extern "file_NativeFile_NativeFile_file_stat_0" + fun fileno: Int `{ return fileno(recv); `} + # 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. + fun set_buffering_type(buf_length: Int, mode: Int): Int is extern "file_NativeFile_NativeFile_set_buffering_type_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" @@ -490,11 +1063,127 @@ private extern NativeFile `{ FILE* `} new native_stderr is extern "file_NativeFileCapable_NativeFileCapable_native_stderr_0" end -# Standard input. -fun stdin: Stdin do return once new Stdin +redef class Sys + + # Standard input + var stdin: PollableReader = new Stdin is protected writable, lazy + + # Standard output + var stdout: Writer = new Stdout is protected writable, lazy + + # Standard output for errors + 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" + # 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" + # 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" -# Standard output. -fun stdout: OFStream do return once new Stdout + # returns first available stream to read or write to + # return null on interruption (possibly a signal) + protected fun poll( streams : Sequence[FileStream] ) : nullable FileStream + do + var in_fds = new Array[Int] + var out_fds = new Array[Int] + var fd_to_stream = new HashMap[Int,FileStream] + for s in streams do + var fd = s.fd + if s isa FileReader then in_fds.add( fd ) + if s isa FileWriter then out_fds.add( fd ) + + fd_to_stream[fd] = s + end + + var polled_fd = intern_poll( in_fds, out_fds ) + + if polled_fd == null then + return null + else + return fd_to_stream[polled_fd] + 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) `{ + int in_len, out_len, total_len; + struct pollfd *c_fds; + sigset_t sigmask; + int i; + int first_polled_fd = -1; + int result; + + in_len = Array_of_Int_length( in_fds ); + out_len = Array_of_Int_length( out_fds ); + total_len = in_len + out_len; + c_fds = malloc( sizeof(struct pollfd) * total_len ); + + /* input streams */ + for ( i=0; i 0 ) { + /* analyse results */ + for ( i=0; i