# another product.
# File manipulations (create, read, write, etc.)
-package file
+module file
intrude import stream
intrude import string
import string_search
+import time
+
+in "C Header" `{
+ #include <dirent.h>
+ #include <string.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <unistd.h>
+`}
redef class Object
# Simple I/O
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
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
nb = 0
end
- _buffer._length = nb
+ _buffer.length = nb
_buffer_pos = 0
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
+ # 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"
fun strip_extension(ext: String): String
do
# Extract the basename of a path and remove the extension
fun basename(ext: String): String
do
- var pos = last_index_of_from('/', _length - 1)
+ var pos = last_index_of_from('/', length - 1)
var n = self
if pos >= 0 then
n = substring_from(pos+1)
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.chars[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
+ # 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
# * no I/O access is performed
# * the validity of the path is not checked
#
- # "some/./complex/../../path/from/../to/a////file//".simplify_path # -> "path/to/a/file"
- # "../dir/file".simplify_path # -> "../dir/file"
- # "dir/../../".simplify_path # -> ".."
- # "//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"
fun simplify_path: String
do
var a = self.split_with("/")
end
a2.push(x)
end
+ if a2.is_empty then return "."
return a2.join("/")
end
# Using a standard "{self}/{path}" does not work when `self` is the empty string.
# This method ensure that the join is valid.
#
- # "hello".join_path("world") # -> "hello/world"
- # "hel/lo".join_path("wor/ld") # -> "hel/lo/wor/ld"
- # "".join_path("world") # -> "world"
- # "/hello".join_path("/world") # -> "/world"
+ # 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
#
do
if path.is_empty then return self
if self.is_empty then return path
- if path[0] == '/' then return path
+ if path.chars[0] == '/' then return path
return "{self}/{path}"
end
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 /
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
end
# returns files contained within the directory represented by self
- fun files : Set[ String ] is extern import HashSet, HashSet::add, String::from_cstring, String::to_cstring, HashSet[String] as( Set[String] ), String as( Object )
+ 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 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
-extern FileStat
+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