ref: bef630973910df30c0647daa2c6c8cbae4c6a50e
dir: /lib/std/syswrap+posixy.myr/
use sys use "cstrconv.use" use "errno.use" use "option.use" use "result.use" use "types.use" pkg std = type fd = sys.fd type pid = sys.pid type fdopt = sys.fdopt type whence = sys.whence type sysinfo = struct system : byte[:] version : byte[:] release : byte[:] arch : byte[:] uname : sys.utsname /* storage */ ;; const Failmem : byte# = -1 castto(byte#) const Seekset : whence = sys.Seekset castto(whence) const Seekcur : whence = sys.Seekcur castto(whence) const Seekend : whence = sys.Seekend castto(whence) const Ordonly : fdopt = sys.Ordonly castto(fdopt) const Owronly : fdopt = sys.Owronly castto(fdopt) const Ordwr : fdopt = sys.Ordwr castto(fdopt) const Ocreat : fdopt = sys.Ocreat castto(fdopt) const Otrunc : fdopt = sys.Otrunc castto(fdopt) const Odir : fdopt = sys.Odir castto(fdopt) /* fd stuff */ const open : (path : byte[:], opts : fdopt -> result(fd, errno)) const openmode : (path : byte[:], opts : fdopt, mode : int64 -> result(fd, errno)) const close : (fd : fd -> errno) const creat : (path : byte[:], mode : int64 -> result(fd, errno)) const read : (fd : fd, buf : byte[:] -> result(size, errno)) const write : (fd : fd, buf : byte[:] -> result(size, errno)) const pipe : (fds : fd[2]# -> errno) const seek : (fd : fd, delta : off, whence : whence -> result(off, errno)) const dup2 : (ofd : fd, nfd : fd -> result(fd, errno)) /* useful/portable bits of stat */ const fmtime : (f : byte[:] -> result(time, errno)) const fsize : (f : byte[:] -> result(off, errno)) const fexists : (f : byte[:] -> bool) const fisdir : (f : byte[:] -> bool) /* useful/portable bits of uname */ const getsysinfo : (si : sysinfo# -> void) /* path manipulation */ const mkdir : (path : byte[:], mode : int64 -> errno) const remove : (path : byte[:] -> bool) const chdir : (path : byte[:] -> bool) /* process stuff */ const getpid : ( -> pid) const suicide : ( -> void) const fork : (-> pid) const execv : (cmd : byte[:], args : byte[:][:] -> errno) const execve : (cmd : byte[:], args : byte[:][:], env : byte[:][:] -> errno) pkglocal const Canunmap : bool = true pkglocal const getmem : (sz : size -> byte#) pkglocal const freemem : (p : byte#, sz : size -> void) pkglocal const curtime : (-> time) ;; /* fd stuff */ const open = {path, opts; -> check(sys.open(path, opts castto(sys.fdopt)))} const openmode = {path, opts, mode; -> check(sys.openmode(path, opts castto(sys.fdopt), mode))} const close = {fd; -> sys.close(fd castto(sys.fd)) castto(errno)} const creat = {path, mode; -> check(sys.creat(path, mode))} const read = {fd, buf; -> check(sys.read(fd castto(sys.fd), buf))} const write = {fd, buf; -> check(sys.write(fd castto(sys.fd), buf))} const pipe = {fds; -> sys.pipe(fds castto(sys.fd[2]#)) castto(errno)} const seek = {fd, delta, whence; -> check(sys.lseek(fd castto(sys.fd), delta castto(sys.off), whence castto(sys.whence)))} const dup2 = {ofd, nfd; -> check(sys.dup2(ofd castto(sys.fd), nfd castto(sys.fd)) castto(fd))} /* path manipulation */ const mkdir = {path, mode; -> sys.mkdir(path, mode) castto(errno)} const chdir = {path; -> sys.chdir(path) == 0} const remove = {path; -> sys.unlink(path) == 0} /* useful/portable bits of uname */ const getsysinfo = {si sys.uname(&si.uname) si.system = cstrconv(si.uname.system[:]) si.version = cstrconv(si.uname.version[:]) si.release = cstrconv(si.uname.release[:]) si.arch = cstrconv(si.uname.machine[:]) } /* process stuff */ const getpid = {; -> sys.getpid() castto(pid)} const suicide = {; sys.kill(sys.getpid(), 6)} /* kill self with sigabort */ const fork = {; -> sys.fork() castto(pid)} const execv = {cmd, args; -> sys.execv(cmd, args) castto(errno)} const execve = {cmd, args, env; -> sys.execve(cmd, args, env) castto(errno)} const sleep = {time; sys.sleep(time)} /* memory stuff */ const getmem = {sz; -> sys.mmap(0 castto(byte#), sz castto(sys.size), sys.Mprotrw, sys.Mpriv | sys.Manon, -1, 0)} const freemem = {p, sz; sys.munmap(p, sz castto(sys.size))} const curtime = { var tm, sec, nsec if sys.clock_gettime(`sys.Clockrealtime, &tm) == 0 sec = tm.sec nsec = tm.nsec castto(uint64) -> (sec*1_000_000 + nsec/1000) castto(time) else -> -1 ;; } const fexists = {path var sb -> sys.stat(path, &sb) == 0 } const fisdir = {path var sb if sys.stat(path, &sb) >= 0 -> sb.mode & sys.Sifdir != 0 else -> false ;; } const fmtime = {path var sb, r var sec, nsec r = sys.stat(path, &sb) if r >= 0 sec = sb.mtime.sec castto(time) nsec = sb.mtime.nsec castto(time) -> `Ok sec*1000 + nsec/1_000_000 else -> check(r) ;; } const fsize = {path var sb, r r = sys.stat(path, &sb) if r >= 0 -> `Ok (sb.size castto(off)) else -> check(r) ;; } generic check = {e : @a::(integral, numeric) -> result(@b, errno) if e < 0 -> `Fail e castto(errno) else -> `Ok e castto(@b) ;; }