shithub: mc

ref: fcb38bff6b06d23a3499bd13bc683754cb10dec0
dir: /lib/std/syswrap+plan9-x6.myr/

use sys
use "types"

pkg std =
	type fd		= sys.fd
	type pid	= sys.pid
	type fdopt	= sys.fdopt

	const Failmem	: byte#	= -1 castto(byte#)

	const Ordonly  	: fdopt = sys.Ordonly	castto(fdopt)
	const Owronly  	: fdopt = sys.Owronly	castto(fdopt)
	const Ordwr    	: fdopt = sys.Ordwr	castto(fdopt)
	const Otrunc   	: fdopt = sys.Otrunc	castto(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 -> fd)
	const openmode	: (path : byte[:], opts : fdopt, mode : int64 -> fd)
	const close	: (fd : fd -> int64)
	const creat	: (path : byte[:], mode : int64 -> fd)
	const read	: (fd : fd, buf : byte[:] -> size)
	const write	: (fd : fd, buf : byte[:] -> size)
	const pipe	: (fds : fd[2]# -> int64)

	/* path manipulation */
	const mkdir	: (path : byte[:], mode : int64 -> int64)
	const unlink	: (path : byte[:] -> int)

	/* process stuff */
	const getpid	: ( -> pid)
	const suicide	: ( -> void)
	const fork	: (-> pid)
	const execv	: (cmd : byte[:], args : byte[:][:] -> int64)
	const execve	: (cmd : byte[:], args : byte[:][:], env : byte[:][:] -> int64)
	const exit	: (status:int -> void)
	const waitpid	: (pid:pid, loc:int32#, opt : int64	-> int64)
	const getmem	: (sz : size -> byte#)
	const freemem	: (p : byte#, sz : size -> void)
;;

/* fd stuff */
const open	= {path, opts;	-> sys.open(path, opts castto(sys.fdopt)) castto(fd)}
const openmode	= {path, opts, mode;
	var fd


	if opts & Ocreat != 0
		fd = sys.create(path, opts castto(sys.fdopt), mode castto(int))
	else
		fd = sys.open(path, opts castto(sys.fdopt))
	;;
	if opts & Oappend != 0
		sys.seek(fd, 0, 2)
	;;
	-> fd castto(fd)
}

const close	= {fd;		-> sys.close(fd castto(sys.fd)) castto(int64)}
const read	= {fd, buf;	-> sys.pread(fd castto(sys.fd), buf, -1) castto(size)}
const write	= {fd, buf;	-> sys.pwrite(fd castto(sys.fd), buf, -1) castto(size)}
const pipe	= {fds;		-> sys.pipe(fds castto(sys.fd[2]#)) castto(int64)}

/* path manipulation */
const unlink	= {path;	-> sys.remove(path)}
const mkdir	= {path, mode;
	var fd

	fd = sys.create(path, sys.Ordonly, sys.Dmdir | (mode castto(int)))
	if fd < 0
		-> -1
	;;
	sys.close(fd)
	-> 0
}

/* process stuff */
const getpid	= {;	-> sys.gettos().pid castto(pid)}
const suicide	= {;	(0 castto(byte#))#}	/* let's happy segfault!! t */
const fork	= {;		-> sys.rfork(sys.Rffdg | sys.Rfrend | sys.Rfproc) castto(pid)}
const execv	= {cmd, args;	-> sys.exec(cmd, args) castto(int64)}
const execve	= {cmd, args, env;	-> sys.exec(cmd, args) castto(int64)}
const exit	= {status;
	if status == 0
		sys.exits("")
	else
		sys.exits("failure")
	;;
}

/* FIXME: horribly broken. We wait for a pid to exit, and lie about which one. */
const waitpid	= {pid, loc, opt;
	var buf : byte[512]
	var n

	n = sys.await(buf[:])
	-> pid
}

/* 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))}