File.clcl

inherit System
{
    typedef mode_t int;
    typedef dev_t ulong;
    typedef uid_t int;
    typedef gid_t int;
    typedef DIR pointer;
    typedef off_t ulong;
    typedef clockid_t int;

    S_IFMT: static int;
    S_IFDIR: static int;
    S_IFCHR: static int;
    S_IFBLK: static int;
    S_IFREG: static int;
    S_IFIFO: static int;
    S_IFLNK: static int;
    S_IFSOCK: static int;
    S_ISUID: static int;
    S_ISGID: static int;
    S_ISVTX: static int;
    S_IRUSR: static int;
    S_IWUSR: static int;
    S_IXUSR: static int;
    S_IRWXU: static int;
    S_IRGRP: static int;
    S_IWGRP: static int;
    S_IXGRP: static int;
    S_IRWXG: static int;
    S_IROTH: static int;
    S_IWOTH: static int;
    S_IXOTH: static int;
    S_IRWXO: static int;
    R_OK: static int;
    W_OK: static int;
    X_OK: static int;
    F_OK: static int;
    O_APPEND: static int;
    O_ASYNC: static int;
    O_RDONLY: static int;
    O_WRONLY: static int;
    O_RDWR: static int;
    O_CREAT: static int;
    O_DIRECTORY: static int;
    O_EXCL: static int;
    O_NOCTTY: static int;
    O_NOFOLLOW: static int;
    O_TMPFILE: static int;
    O_TRUNC: static int;
    O_TTY_INIT: static int;
    O_CLOEXEC: static int;
    O_DIRECT: static int;
    O_DSYNC: static int;
    O_LARGEFILE: static int;
    O_NOATIME: static int;
    O_NONBLOCK: static int;
    O_PATH: static int;
    O_SYNC : static int;

    FNM_NOESCAPE: static int;
    FNM_PATHNAME: static int;
    FNM_PERIOD: static int;
    FNM_FILE_NAME: static int;
    FNM_LEADING_DIR: static int;
    FNM_CASEFOLD: static int;

    CLOCK_REALTIME: static int;
    CLOCK_REALTIME_COARSE: static int;
    CLOCK_MONOTONIC: static int;
    CLOCK_MONOTONIC_COARSE: static int;
    CLOCK_MONOTONIC_RAW: static int;
    CLOCK_BOOTTIME: static int;
    CLOCK_PROCESS_CPUTIME_ID: static int;
    CLOCK_THREAD_CPUTIME_ID: static int;

    RTLD_LAZY:static int;
    RTLD_NOW:static int;
    RTLD_GLOBAL:static int;
    RTLD_LOCAL:static int;
    RTLD_NODELETE:static int;
    RTLD_NOLOAD:static int;
    RTLD_DEEPBIND:static int;

    RTLD_DEFAULT: static pointer;
    RTLD_NEXT: static pointer;

    EOF: static int;

    stdin: static pointer@FILE;
    stdout: static pointer@FILE;
    stderr: static pointer@FILE;

    BUFSIZ: static int;

    PATH_MAX: static int;

    F_GETFL: static int;
    F_SETFL: static int;

    def initialize_file_system(): static native;

    def initialize(): static {
        inherit();
        initialize_file_system();
    }
    def open(file_name:String, flags:int, mode:mode_t):static native int throws Exception;
    def close(fd:int): static native int throws Exception;
    def read(fd:int, buf:Buffer, size:size_t): static native ssize_t throws Exception;
    def write(fd:int, buf:Buffer, size:size_t): static native ssize_t throws Exception;

    def fcntl(fd:int, flag:int, val:int): static native int throws Exception;

    def time(): static native time_t;
    def localtime(time:time_t, tm_sec:pointer@of_int, tm_min:pointer@of_int, tm_hour:pointer@of_int, tm_mday:pointer@of_int, tm_mon:pointer@of_int, tm_year:pointer@of_int, tm_wday:pointer@of_int, tm_yday:pointer@of_int, tm_isdst:pointer@of_bool): static native throws Exception;
    def mktime(time:tm): static native time_t throws Exception;
    def lstat(path:String, stat_:stat): static native int throws Exception;
    def stat(path:String, stat_:stat): static native int throws Exception;
    def realpath(path:String): static native String throws Exception;
    def dirname(path:String): static native String;
    def basename(path:String): static native String;
    def opendir(path:String): static native DIR throws Exception;
    def readdir(dir:DIR): static native String? throws Exception;
    def closedir(dir:DIR): static native int throws Exception;
    def chmod(path:String, mode:mode_t): static native throws Exception;
    def lchmod(path:String, mode:mode_t): static native throws Exception;
    def fchmod(fd:int, mode:mode_t): static native throws Exception;
    def chown(path:String, owner:uid_t, group:gid_t): static native throws Exception;
    def lchown(path:String, owner:uid_t, group:gid_t): static native throws Exception;
    def fchown(fd:int, owner:uid_t, group:gid_t): static native throws Exception;
    def unlink(path:String): static native throws Exception;
    def access(path:String, mode:int): static native int;
    def utime(path:String, actime:time_t, modtime:time_t): static native throws Exception;
    def fnmatch(pattern:String, path:String, flags:int): static native bool;
    def link(old_path:String, new_path:String): static native throws Exception;
    def symlink(old_path:String, new_path:String): static native throws Exception;
    def readlink(path:String): static native String throws Exception;
    def rename(oldpath:String, newpath:String): static native throws Exception;
    def truncate(path:String, length:off_t): static native throws Exception;
    def ftruncate(fd:int, length:off_t): static native throws Exception;

    def chdir(path:String): static native throws Exception;
    def fchdir(fd:int): static native throws Exception;
    def rmdir(path:String): static native throws Exception;
    def mkdir(path:String, mode:mode_t): static native throws Exception;

    def clock_getres(clk_id:clockid_t, res:timespec): static native throws Exception;
    def clock_gettime(clk_id:clockid_t, tp:timespec): static native throws Exception;
    def clock_settime(clk_id:clockid_t, tp:timespec): static native throws Exception;

    def dlopen(path:String, flags:int): static native pointer throws Exception;
    def dlclose(handle:pointer): static native int throws Exception;
    def dlsym(handle:pointer, symbol:String): static native pointer throws Exception;

    def fopen(path:String, mode:String): static native pointer@FILE throws Exception;
    def fclose(stream:pointer) : static native throws Exception;
    def fwrite(buf:Buffer, size:size_t, stream: pointer@FILE): static native size_t throws Exception;
    def fread(buf:Buffer, size:size_t, stream:pointer@FILE): static native size_t throws Exception;
    def feof(stream: pointer@FILE): static native bool;
    
    def fgetc(stream:pointer@FILE): native static int throws Exception;
    def fgets(buf:Buffer, size:int, stream:pointer@FILE): native static pointer@pchar throws Exception;
    def getchar(): native static int throws Exception;
    def ungetc(c:int, stream:pointer@FILE): native static int throws Exception;

    def getcwd(): native static String throws Exception;

    def put_fun_to_hash_for_native_method(path:String, fun_name:String, native_method:pointer): static native;

    def fileno(stream:pointer@FILE): native static int;
}

class tm
{
    include MObjectBase;

    tm_sec:int;
    tm_min:int;
    tm_hour:int;
    tm_mday:int;
    tm_mon:int;
    tm_year:int;
    tm_wday:int;
    tm_yday:int;
    tm_isdst:bool;
    
    def initialize() {
        self.initialize(time());
    }

    def initialize(time:time_t) {
        localtime(time, &self.tm_sec, &self.tm_min, &self.tm_hour, &self.tm_mday, &self.tm_mon, &self.tm_year, &self.tm_wday, &self.tm_yday, &self.tm_isdst);
    }

    def initialize(year:int, month:int, day_of_month:int, hour:int, minuts:int, sec:int, day_of_week:int, day_of_year:int, isdst:bool) 
    {
        self.setYear(year);
        self.setMonth(month);
        self.setDayOfMonth(day_of_month);
        self.setHour(hour);
        self.setMinuts(minuts);
        self.setSecond(sec);
        self.setDayOfWeek(day_of_week);
        self.setDayOfYear(day_of_year);
        self.setDaylightSavingTime(isdst);
    }

    def clone():tm {
        result := tm();

        result.tm_sec = self.tm_sec;
        result.tm_min = self.tm_min;
        result.tm_hour = self.tm_hour;
        result.tm_mday = self.tm_mday;
        result.tm_mon = self.tm_mon;
        result.tm_year = self.tm_year;
        result.tm_wday = self.tm_wday;
        result.tm_yday = self.tm_yday;
        result.tm_isdst = self.tm_isdst;

        return result;
    }

    def second():int {
        return self.tm_sec;
    }
    def setSecond(value:int) {
        self.tm_sec = value;
    }
    def minuts():int {
        return self.tm_min;
    }
    def setMinuts(value:int) {
        self.tm_min = value;
    }
    def hour():int {
        return self.tm_hour;
    }
    def setHour(value:int) {
        self.tm_hour = value;
    }
    def dayOfMonth():int {
        return self.tm_mday;
    }
    def setDayOfMonth(value:int) {
        self.tm_mday = value;
    }
    def month():int {
        return self.tm_mon + 1;
    }
    def setMonth(value:int) {
        self.tm_mon = value -1;
    }
    def year():int {
        return self.tm_year + 1900;
    }
    def setYear(value:int) {
        self.tm_year = value - 1900;
    }
    def dayOfWeek():int {
        return self.tm_wday;
    }
    def setDayOfWeek(value:int) {
        self.tm_wday = value;
    }
    def dayOfYear():int {
        return self.tm_yday;
    }
    def setDayOfYear(value:int) {
        self.tm_yday = value;
    }
    def isDaylightSavingTime():bool {
        return self.tm_isdst;
    }
    def setDaylightSavingTime(value:bool) {
        self.tm_isdst = value;
    }

    def toString():String {
        return sprintf("%d-%02d-%02d %02d:%02d", array { self.year().toInteger, self.month().toInteger, self.dayOfMonth().toInteger, self.hour().toInteger, self.minuts().toInteger });
    }

    def to_time_t():time_t throws Exception {
        return mktime(self);
    }
}

class stat
{
    include MObjectBase;

    st_dev:dev_t;
    st_mode:mode_t;
    st_uid:uid_t;
    st_gid:gid_t;
    st_rdev:dev_t;
    st_size: size_t;

    st_atime:time_t;
    st_mtime:time_t;
    st_ctime:time_t;

    def initialize() {}

    def initialize(path:String, lstat:bool) throws Exception {
        if(lstat) {
            System.lstat(path, self);
        }
        else {
            System.stat(path, self);
        }
    }
    def initialize(path:String) throws Exception {
        self.initialize(path, false);
    }
    def clone():stat {
        result := stat();

        result.st_dev = self.st_dev;
        result.st_mode = self.st_mode;
        result.st_uid = self.st_uid;
        result.st_gid = self.st_gid;
        result.st_rdev = self.st_rdev;
        result.st_size = self.st_size;

        result.st_atime = self.st_atime;
        result.st_mtime = self.st_mtime;
        result.st_ctime = self.st_ctime;

        return result;
    }
    def S_ISDIR():bool {
        return (self.st_mode & S_IFMT) == S_IFDIR;
    }
    def S_ISCHR():bool {
        return (self.st_mode & S_IFMT) == S_IFCHR;
    }
    def S_ISBLK():bool {
        return (self.st_mode & S_IFMT) == S_IFBLK;
    }
    def S_ISREG():bool {
        return (self.st_mode & S_IFMT) == S_IFREG;
    }
    def S_ISFIFO():bool {
        return (self.st_mode & S_IFMT) == S_IFIFO;
    }
    def S_ISLNK():bool {
        return (self.st_mode & S_IFMT) == S_IFLNK;
    }
    def S_ISSOCK():bool {
        return (self.st_mode & S_IFMT) == S_IFSOCK;
    }
    def permission():int {
        return self.st_mode & (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO);
    }
    def S_IXUGO():bool {
        return ((self.st_mode & S_IXUSR) == S_IXUSR) && ((self.st_mode & S_IXGRP) == S_IXGRP) && ((self.st_mode & S_IXOTH) == S_IXOTH);
    }
    def atime():tm {
        return tm(self.st_atime);
    }
    def ctime():tm {
        return tm(self.st_ctime);
    }
    def mtime():tm {
        return tm(self.st_mtime);
    }
    def size():size_t {
        return self.st_size;
    }
    def uid():uid_t {
        return self.st_uid;
    }
    def gid():gid_t {
        return self.st_gid;
    }

    def userName():String {
        result := "";

        p"/etc/passwd".read().toString().split(/\n/).each(closure(line:String) {
            fields := line.chomp().split(/:/);
            
            if(fields.length() > 2 && fields.items(2).to_int() == self.st_uid) {
                result = fields.items(0);
            }
        });

        return result;
    }

    def groupName():String {
        result := "";

        p"/etc/group".read().toString().split(/\n/).each(closure(line:String) {
            fields := line.chomp().split(/:/);

            if(fields.length() > 2 && fields.items(2).to_int() == self.st_gid) {
                result = fields.items(0);
            }
        });

        return result;
    }
}

inherit String 
{
    def toPath(): Path {
        return Path(self);
    }
}

class File
{
    include MObjectBase;

    fd:int;
    fileName:String?;
    stream:pointer?@FILE;

    def initialize() {
        self.fd = -1;
        self.fileName = null;
        self.stream = null;
    }

    def initialize(file_name:String, flags:int, mode:mode_t) throws Exception 
    {
        self.fd = open(file_name, flags, mode);
        self.fileName = file_name;
        self.stream = null;
    }
    
    def initialize(file_name:String, mode:String) throws Exception {
        self.fd = -1;
        self.fileName = file_name;
        self.stream = fopen(file_name, mode);
    }

    def initialize(file_name:String) throws Exception {
        self.initialize(file_name, "r");
    }

    def finalize() {
        self.close();
    }

    def clone(): File {
        result := File();

        result.fd = self.fd;
        if(self.fileName.identifyWith(null)) {
            result.fileName = null;
        }
        else {
            result.fileName = self.fileName.clone();
        }
        result.stream = self.stream;

        return result;
    }

    def close() {
        if(self.fd != -1) {
            System.close(self.fd);

            self.fd = -1;
            self.fileName = null;
        }
        if(self.stream != null) {
            fclose(self.stream);
            
            self.stream = null;
            self.fileName = null;
        }
    }

    def read(size:size_t): Buffer throws Exception {
        if(self.fd == -1 && self.stream == null) {
            throw Exception("File is not opened");
        }
        
        if(self.stream != null) {
            result := Buffer(size+1);
            fread(result, size, self.stream);
            return result;
        }
        else {
            result := Buffer(size+1);
            System.read(self.fd, result, size);
            return result;
        }
    }

    def to_stat(): stat throws Exception {
        if(self.fileName.identifyWith(null)) {
            throw Exception("File is not opened");
        }

        return stat(self.fileName);
    }
    def to_lstat(): stat throws Exception {
        if(self.fileName.identifyWith(null)) {
            throw Exception("File is not opened");
        }

        return stat(self.fileName, true);
    }

    def read(file_name:String): static Buffer throws Exception {
        f:File = File(file_name);
        result := f.read();
        f.close();

        return result;
    }

    def read(): Buffer throws Exception {
        if(self.fd == -1 && self.stream == null) {
            throw Exception("File is not opened");
        }

        if(self.stream != null) {
            size:size_t = self.to_stat().size();

            result := Buffer(size+1.to_ulong);
            fread(result, size, self.stream);
            return result;
        }
        else {
            size:size_t = self.to_stat().size();

            result := Buffer(size+1.to_ulong);
            System.read(self.fd, result, size);
            return result;
        }
    }

    def write(buf:Buffer, size:size_t):int throws Exception {
        if(self.fd == -1 && self.stream == null) {
            throw Exception("File is not opened");
        }

        if(self.stream != null) {
            return fwrite(buf, size, self.stream);
        }
        else {
            return System.write(self.fd, buf, size);
        }
    }

    def write(buf:Buffer):int throws Exception {
        return self.write(buf, buf.len);
    }
    def write(str:String):int throws Exception {
        buf := str.toBuffer();
        return self.write(buf);
    }

    def write(file_name:String, buf:Buffer, mode:mode_t): static int throws Exception 
    {
        f := File(file_name, O_CREAT|O_TRUNC|O_WRONLY, mode);
        result := f.write(buf);
        f.close();

        return result;
    }
    def write(file_name:String, buf:Buffer, mode:String): static throws Exception
    {
        f := File(file_name, mode);
        f.write(buf);
        f.close();
    }
    def write(file_name:String, buf:Buffer, append:bool=false): static throws Exception {
        if(append) {
            File.write(file_name, buf, "a");
        }
        else {
            File.write(file_name, buf, "w");
        }
    }
}

class Path 
{
    include MObjectBase;

    path: delegate String;

    def initialize() {}

    def initialize(path:String) {
        self.path = path;
    }

    def clone():Path {
        result := Path();

        if(self.path.identifyWith(null).negative()) {
            result.path = self.path.clone();
        }

        return result;
    }

    def to_stat():stat {
        return stat(self.path);
    }
    def to_lstat():stat {
        return stat(self.path,true);
    }

    def toString(): String {
        return self.path;
    }

    def equals(path:Path):bool {
        if(path.is("WildCard")) {
            return true;
        }
        else {
            return self.path.equals(path.path)
        }
    }

    def equals(right:WildCard):bool {
        return true;
    }
    def compare(item:Path): int {
        return self.path.compare(item.path);
    }

    def add(right:Path): Path {
        result := self.clone();
        result.path.append(right.path);
        return result;
    }

    def realpath():Path throws Exception {
        return System.realpath(self.path).toPath();
    }
    def dirname(): Path {
        return System.dirname(self.path).toPath();
    }
    def basename():Path {
        return System.basename(self.path).toPath();
    }

    def extname(): Path {
        index := -1;
        for(i := self.path.len-1; i>=0; i--) {
            if(self.path.chars(i) == '.') {
                index = i;
                break;
            }
        }
        dirname := self.dirname();

        if(index == -1 || index == 0 || self.path.chars(index-1) == '/' 
            || index < dirname.path.length()) 
        {
            return p"";
        }
        else {
            return self.path.subString(index+1, -1).toPath();
        }
    }
    def read(): Buffer {
        return File.read(self.path);
    }
    def write(buf:Buffer, append:bool=false) {
        File.write(self.path, buf, append);
    }

    def chmod(mode:mode_t) throws Exception {
        System.chmod(self.toString(), mode);
    }
    def lchmod(mode:mode_t) throws Exception {
        System.lchmod(self.toString(), mode);
    }
    def chown(owner:uid_t, group:gid_t) throws Exception {
        System.chown(self.toString(), owner, group);
    }
    def lchown(owner:uid_t, group:gid_t) throws Exception {
        System.lchown(self.toString(), owner, group);
    }
    def unlink() throws Exception {
        System.unlink(self.toString());
    }
    def access(mode:int):int {
        return System.access(self.toString(), mode);
    }
    def utime(actime:time_t, modtime:time_t) throws Exception {
        System.utime(self.toString(), actime, modtime);
    }
    def fnmatch(pattern:String, flags:int): bool {
        return System.fnmatch(pattern, self.toString(), flags);
    }
    def fnmatch(pattern:String): bool {
        return self.fnmatch(pattern, 0);
    }
    def link(new_path:String) throws Exception {
        System.link(self.toString(), new_path);
    }
    def symlink(new_path:String) throws Exception {
        System.symlink(self.toString(), new_path);
    }
    def readlink(): String throws Exception {
        return System.readlink(self.toString());
    }
    def rename(path:String) throws Exception {
        System.rename(self.toString(), path);
    }
    def truncate(length:off_t) throws Exception {
        System.truncate(self.toString(), length);
    }

    def chdir() throws Exception {
        System.chdir(self.toString());
    }

    def rmdir() throws Exception {
        System.rmdir(self.toString());
    }

    def mkdir(mode:mode_t) throws Exception {
        System.mkdir(self.toString(), mode);
    }

    def mkdir() throws Exception {
        System.mkdir(self.toString(), 0755);
    }

    def entries(): SortableList<String> throws Exception {
        return Directory.entries(self.toString());
    }

    def glob(pattern:String, flags:int): SortableList<String> throws Exception {
        return Directory.glob(self.toString(), pattern, flags);
    }

    def glob(pattern:String): SortableList<String> throws Exception {
        return Directory.glob(self.toString(), pattern, 0);
    }
}

inherit Global
{
    def glob(pattern:String): static SortableList<String> throws Exception {
        return Directory.glob(".", pattern, 0);
    }
}

class Directory 
{
    include MObjectBase;

    path:String;
    dir:DIR;

    def initialize() {}

    def initialize(path:String) throws Exception {
        self.path = path;
        self.dir = opendir(path);
    }

    def finalize() {
        if(self.dir != 0.to_pointer) {
            System.closedir(self.dir);
        }
    }

    def clone(): Directory {
        result := Directory();

        if(self.path.identifyWith(null).negative()) {
            result.path = self.path.clone();
        }
        result.dir = self.dir;

        return result;
    }
    
    def readdir(): String? throws Exception {
        if(self.dir == 0.to_pointer) {
            throw Exception("This directory is not opened");
        }

        return System.readdir(self.dir);
    }

    def closedir() {
        if(self.dir != 0.to_pointer) {
            System.closedir(self.dir);
            self.dir = 0.to_pointer;
        }
    }

    def entries(path:String): static SortableList<String> throws Exception {
        dir := Directory(path);
        result:SortableList<String> = SortableList<String>();

        while(true) {
            entry:String? = dir.readdir();

            if(entry.identifyWith(null)) {
                break;
            }

            if(!entry.equals(".") && !entry.equals("..")) {
                if(path.chars(-1) == '/') {
                    entry2:String = sprintf("%s%s", array { path, entry });
                    result.add(entry2);
                }
                else {
                    entry2:String = sprintf("%s/%s", array { path, entry });
                    result.add(entry2);
                }
            }
        }
        dir.closedir();

        return result;
    }

    def glob(path:String, pattern:String, flags:int): static SortableList<String> throws Exception {
        dir := Directory(path);
        result:SortableList<String> = SortableList<String>();

        while(true) {
            entry:String? = dir.readdir();

            if(entry.identifyWith(null)) {
                break;
            }

            if(fnmatch(pattern, entry, flags)) {
                if(path.chars(-1) == '/') {
                    entry2:String = sprintf("%s%s", array { path, entry });
                    result.add(entry2);
                }
                else {
                    entry2:String = sprintf("%s/%s", array { path, entry });
                    result.add(entry2);
                }
            }
        }
        dir.closedir();

        return result;
    }

    def glob(path:String, pattern:String): static SortableList<String> throws Exception {
        return Directory.glob(path, pattern, 0);
    }

    def glob(pattern:String, flags:int):static SortableList<String> throws Exception {
        return Directory.glob(".", pattern, flags);
    }

    def glob(pattern:String):static SortableList<String> throws Exception {
        return Directory.glob(".", pattern, 0);
    }

    def globWithOnePath(path:String, flags:int):static SortableList<String> throws Exception 
    {
        dir := System.dirname(path);
        if(dir.equals(".")) {
            return sortable_list { path };
        }
        else {
            pattern := path.subString(dir.length()+1, -1);
            return Directory.glob(dir, pattern, flags);
        }
    }

    def globWithOnePath(path:String):static SortableList<String> throws Exception {
        return Directory.globWithOnePath(path, 0);
    }

    def isGlobString(str:String):static bool {
        for(i:=0; i<str.length(); i++) {
            c:char = str.chars(i);
            if(c == '*' || c == '?' || c == '[' || c == ']') {
                return true;
            }
        }

        return false;
    }
}

inherit Clover 
{
    def time(block_:lambda()):static time_t {
        time1:time_t = System.time();
        block_();
        time2:time_t = System.time();

        return time2 - time1;
    }
    def realtime(block_:lambda()):static timespec {
        ts1 := timespec();
        clock_gettime(CLOCK_MONOTONIC, ts1);
        block_();
        ts2 := timespec();
        clock_gettime(CLOCK_MONOTONIC, ts2);

        return ts2.minus(ts1);
    }
}

inherit String
{
    def write(file_name:String, append:bool =false) {
        File.write(file_name, self.toBuffer(), append);
    }
}

inherit Buffer
{
    def write(file_name:String, append:bool=false) {
        File.write(file_name, self, append);
    }
}