# 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
# File Abstract Stream
-class FStream
+abstract class FStream
super IOS
- super NativeFileCapable
# The path of the file.
readable var _path: nullable String = null
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
_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)
# 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
super FStream
super OStream
- # Write a string.
redef fun write(s)
do
assert _writable
# 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
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
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
class Stderr
super OFStream
private init do
- _file = native_stderr
+ _file = new NativeFile.native_stderr
_path = "/dev/stderr"
_writable = true
end
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
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)
return n.strip_extension(ext)
end
+ # Extract the dirname of a path
fun dirname: String
do
var pos = last_index_of_from('/', _length - 1)
end
end
- fun file_path: String
+ # 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 "//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 "."
+ 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)
path.to_s.to_cstring.file_mkdir
end
end
+
+ # Return right-most extension (without the dot)
+ fun file_extension : nullable String
+ do
+ var last_slash = 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, 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"
end
-extern 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 extern NativeFile
- super Pointer
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
nitlanguage / nit.git / blobdiff