X-Git-Url: http://nitlanguage.org diff --git a/lib/standard/file.nit b/lib/standard/file.nit index b0fa322..46c52ec 100644 --- a/lib/standard/file.nit +++ b/lib/standard/file.nit @@ -32,9 +32,9 @@ in "C Header" `{ #include `} -# File Abstract Stream -abstract class FStream - super IOS +# `Stream` used to interact with a File or FileDescriptor +abstract class FileStream + super Stream # The path of the file. var path: nullable String = null @@ -42,12 +42,37 @@ abstract class FStream 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 - # Sets the buffering mode for the current FStream + redef fun close + do + 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 + + # Sets the buffering mode for the current FileStream # # If the buf_size is <= 0, its value will be 512 by default # @@ -58,20 +83,25 @@ abstract class FStream 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 FStream, returned error {sys.errno.strerror}") + 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 - super PollableIStream +# `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 and not _file.address_is_null then close @@ -83,33 +113,41 @@ class IFStream return end end_reached = false - _buffer_pos = 0 - _buffer.clear + buffer_reset end redef fun close do - if _file.address_is_null then return - var i = _file.io_close - _buffer.clear + super + 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 @@ -121,6 +159,9 @@ class IFStream end 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) @@ -132,38 +173,53 @@ class IFStream 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_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") + 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 - _file.flush + for i in s.substrings do write_native(i.to_cstring, i.length) end - redef fun close + 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 _file.address_is_null then - if last_error != null then return - last_error = new IOError("Cannot close unopened write stream") + last_error = new IOError("Writing on a null stream") _is_writable = false return end - var i = _file.io_close - if i != 0 then - last_error = new IOError("Close failed due to error {sys.errno.strerror}") + + var err = _file.write_byte(value) + if err != 1 then + # Big problem + last_error = new IOError("Problem writing a byte: {err}") end + end + + redef fun close + do + super _is_writable = false end redef var is_writable = false @@ -220,20 +276,22 @@ 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 IFStream + super FileReader init do _file = new NativeFile.native_stdin @@ -241,22 +299,27 @@ 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 OFStream + super FileWriter init do _file = new NativeFile.native_stdout 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 + super FileWriter init do _file = new NativeFile.native_stderr path = "/dev/stderr" @@ -266,11 +329,11 @@ 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 @@ -301,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 @@ -327,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` @@ -351,35 +416,53 @@ class Path # Open this file for reading # # Require: `exists and not link_stat.is_dir` - fun open_ro: IFStream + fun open_ro: FileReader do # TODO manage streams error when they are merged - return new IFStream.open(path) + return new FileReader.open(path) end # Open this file for writing # # Require: `not exists or not stat.is_dir` - fun open_wo: OFStream + fun open_wo: FileWriter do # TODO manage streams error when they are merged - return new OFStream.open(path) + return new FileWriter.open(path) end # Read all the content of the file # - # See `IStream::read_all` for details. - fun read_all: String + # ~~~ + # var content = "/etc/issue".to_path.read_all + # print content + # ~~~ + # + # See `Reader::read_all` for details. + 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 # Read all the lines of the file # - # See `IStream::read_lines` for details. + # ~~~ + # 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 @@ -389,9 +472,17 @@ class Path 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 `IStream::each_line` for details. + # See `Reader::each_line` for details. fun each_line: LineIterator do var s = open_ro @@ -430,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 @@ -472,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 @@ -479,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 @@ -486,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 @@ -516,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 @@ -562,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 @@ -648,11 +768,12 @@ 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 @@ -688,7 +809,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. @@ -809,28 +929,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 # @@ -839,8 +978,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) # @@ -870,37 +1019,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 @@ -910,19 +1056,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 @@ -935,28 +1081,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. @@ -969,20 +1119,34 @@ private extern class NativeFile `{ FILE* `} new native_stderr is extern "file_NativeFileCapable_NativeFileCapable_native_stderr_0" end -redef class Sys +# Standard `DIR*` pointer +private extern class NativeDir `{ DIR* `} - init do - if stdout isa FStream then stdout.as(FStream).set_buffering_mode(256, buffer_mode_line) - end + # 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 - var stdin: PollableIStream = new Stdin is protected writable + var stdin: PollableReader = new Stdin is protected writable, lazy # Standard output - var stdout: OStream = new Stdout is protected writable + var stdout: Writer = new Stdout is protected writable, lazy # Standard output for errors - var stderr: OStream = new Stderr is protected writable + 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" @@ -993,15 +1157,15 @@ redef class Sys # returns first available stream to read or write to # return null on interruption (possibly a signal) - protected fun poll( streams : Sequence[FStream] ) : nullable FStream + 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,FStream] + var fd_to_stream = new HashMap[Int,FileStream] for s in streams do var fd = s.fd - if s isa IFStream then in_fds.add( fd ) - if s isa OFStream then out_fds.add( 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 @@ -1070,30 +1234,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"