ref: a9a7d5b32a9423f871311384af6260a3848291d1
dir: /lib/std/syswrap+plan9.myr/
use sys
use "option"
use "types"
use "errno"
use "result"
use "cstrconv"
use "strfind"
use "getint"
use "syswrap-ss"
pkg std =
type fd = sys.fd
type pid = sys.pid
type fdopt = sys.fdopt
type whence = int64
type sysinfo = struct
system : byte[:]
version : byte[:]
release : byte[:]
arch : byte[:]
;;
const Seekset : whence = 0
const Seekcur : whence = 1
const Seekend : whence = 2
const Failmem : byte# = (-1 : byte#)
const Ordonly : fdopt = (sys.Ordonly : fdopt)
const Owronly : fdopt = (sys.Owronly : fdopt)
const Ordwr : fdopt = (sys.Ordwr : fdopt)
const Otrunc : fdopt = (sys.Otrunc : fdopt)
const Ocexec : fdopt = (sys.Ocexec : fdopt)
const Ocreat : fdopt = 0x1000000 /* emulated by redirecting to creat(). */
const Oappend : fdopt = 0x2000000 /* emulated by seeking to EOF */
const Odir : fdopt = 0x0 /* no-op on plan9 */
/* 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 read : (fd : fd, buf : byte[:] -> result(size, errno))
const write : (fd : fd, buf : byte[:] -> result(size, errno))
const seek : (fd : fd, delta : off, whence : whence -> result(off, errno))
const pipe : (fds : fd[2]# -> 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)
const fisreg : (f : byte[:] -> bool)
/* the important bits that uname provides */
const getsysinfo : (si : sysinfo# -> void)
/* path manipulation */
const mkdir : (path : byte[:], mode : int64 -> errno)
const chdir : (path : byte[:] -> bool)
const remove : (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)
pkglocal const p9errstr : (buf : byte[:] -> byte[:])
/* statbuf offsets */
pkglocal const Sizeoff : int64 = 0
pkglocal const Typeoff : int64 = 2
pkglocal const Devoff : int64 = 4
pkglocal const Qidtypeoff : int64 =8
pkglocal const Qidversoff : int64 = 9
pkglocal const Qidpathoff : int64 = 13
pkglocal const Modeoff : int64 = 21
pkglocal const Atimeoff : int64 = 25
pkglocal const Mtimeoff : int64 = 29
pkglocal const Lengthoff : int64 = 31
pkglocal const Stringsoff : int64 = 39
;;
/* UGLY: circular dependency breaking... */
extern const getenvv : (name : byte[:], default : byte[:] -> byte[:])
/* fd stuff */
const open = {path, opts; -> check(sys.open(path, (opts : sys.fdopt)))}
const openmode = {path, opts, mode;
var fd
if opts & Ocreat != 0
opts &= ~Ocreat
fd = sys.create(path, (opts : sys.fdopt), (mode : int))
else
fd = sys.open(path, (opts : sys.fdopt))
;;
if opts & Oappend != 0
sys.seek(fd, 0, 2)
;;
-> check(fd)
}
/* useful/portable bits of stat */
const fexists = {path
var buf : byte[4] /* big enough for size, nothing else. */
-> sys.stat(path, buf[:]) >= 0
}
const fmtime = {path
var buf : byte[Stringsoff + 512] /* enough space for some strings */
if sys.stat(path, buf[:]) < Stringsoff
-> `Err Emisc
;;
-> `Ok (getle32(buf[Mtimeoff:Mtimeoff + 8]) : time)
}
const fsize = {path
var buf : byte[Stringsoff + 512] /* enough space for some strings */
if sys.stat(path, buf[:]) < Stringsoff
-> `Err Emisc
;;
-> `Ok (getle64(buf[Lengthoff:Lengthoff + 8]) : off)
}
extern const put : (fmt : byte[:], args : ... -> int64)
const fisdir = {path
var buf : byte[Stringsoff + 39] /* enough space for qid type */
if sys.stat(path, buf[:]) < Stringsoff
-> false
;;
-> (getle32(buf[Modeoff:Modeoff + 4]) & sys.Dmdir) != 0
}
const fisreg = {path
var buf : byte[Stringsoff + 512] /* enough space for some strings */
var ty
if sys.stat(path, buf[:]) < Stringsoff
-> false
;;
ty = getle16(buf[Typeoff:Typeoff + 2])
if (getle32(buf[Modeoff:Modeoff + 4]) & sys.Dmdir) != 0
-> false
/* ugh. maybe this call should just be '!fisdir()' */
elif ty == '|' || ty == 's' || ty == 'm'
-> false
else
-> true
;;
}
const getsysinfo = {si
si.system = getenvv("osname", "Plan9")
si.release = "4"
si.version = "0"
si.arch = getenvv("objtype", "amd64")
}
const close = {fd; -> (sys.close((fd : sys.fd)) : errno)}
const read = {fd, buf; -> check(sys.pread((fd : sys.fd), buf, -1))}
const write = {fd, buf; -> check(sys.pwrite((fd : sys.fd), buf, -1))}
const seek = {fd, off, whence; -> check(sys.seek((fd : sys.fd), (off : sys.off), (whence : int64)))}
const pipe = {fds; -> (sys.pipe((fds : sys.fd[2]#)) : errno)}
const dup2 = {ofd, nfd; -> check(sys.dup((ofd : sys.fd), (nfd : sys.fd)))}
/* path manipulation */
const remove = {path; -> sys.remove(path) == 0}
const chdir = {path; -> sys.chdir(path) == 0}
const mkdir = {path, mode;
var fd
fd = sys.create(path, sys.Ordonly, sys.Dmdir | (mode : int))
if fd < 0
-> lasterr()
;;
sys.close(fd)
-> 0
}
/* process stuff */
const getpid = {; -> (sys.tosptr.pid : pid)}
const suicide = {; (0 : byte#)#} /* let's happy segfault!! t */
const fork = {; -> (sys.rfork(sys.Rffdg | sys.Rfrend | sys.Rfproc) : pid)}
const execv = {cmd, args;
sys.exec(cmd, args)
-> lasterr()
}
const execve = {cmd, args, env;
sys.exec(cmd, args)
-> lasterr()
}
/* memory stuff */
const getmem = {sz
var endp, oldp
oldp = sys.curbrk
endp = (sys.curbrk : intptr) + (sz : intptr)
endp = (endp + 4095) & ~4095
if sys.brk_((endp : byte#)) < 0
-> Failmem
;;
sys.curbrk = (endp : byte#)
-> oldp
}
const freemem = {p, sz
/* FIXME: we leak address space */
sys.segfree(p, (sz : sys.size))
}
const curtime = {
-> (sys.nsec()/1000 : time)
}
const p9errstr = {errbuf
var i
sys.errstr(errbuf)
for i = 0; errbuf[i] != 0 && i < errbuf.len; i++
continue
;;
-> errbuf[:i]
}
/* FIXME: will be needed when we resize stat bufs when statting.
const statsz = {buf
-> (buf[0] : int64)) | ((buf[1] << 8 : int64))
}
*/
generic check = {e : @a::(integral, numeric) -> result(@b, errno)
if e < 0
-> `Err lasterr()
else
-> `Ok (e : @b)
;;
}