include "sys.m";
include "styx.m";
include "styxservers.m";
nametree := load Nametree Nametree->PATH;
	Tree: import nametree;

Tree: adt {
    create: fn(t: self ref Tree, parentpath: big, d: Sys->Dir): string;
    remove: fn(t: self ref Tree, path: big): string;
    wstat:   fn(t: self ref Tree, path: big, d: Sys->Dir);
    quit:   fn(t: self ref Tree);
};
init:       fn();
start:      fn(): (ref Tree, chan of ref Styxservers->Navop);

Note that the full set of operations on Nametree (i.e. stat, walk, readdir, wstate, create and remove), is only available in conjunction with Styxserver's Navigator interface. Files in the name space are ultimately identified by a 64-bit path value, which forms the path component of the file's Qid. (See intro(5) for a description of the system's interpretation of Qids.)

The Tree operations are:

t.create(parentpath, d)

Create a new file or directory. D gives the directory information that will be stored for the file, including its own path value, given by d.qid.path. If the file referenced by parentpath does not exist, creation will not be allowed, other than in the special case when d.qid.path is equal to parentpath, in which case it is assumed to be a root directory and may be created. This potentially allows a single Nametree instance to hold many distinct directory hierarchies. Note that no attempt is made to ensure that parentpath refers to a directory; the check is assumed to have been made previously. When a hierarchy is traversed, Nametree interprets the name `..' itself as `parent directory', and that name should not be created explicitly.

t.remove(path)

Remove the file referred to by path, and all its descendants.

t.wstat(path, d)

Change the directory information held on file path. The Qid path itself cannot be changed by d.

t.quit()

Shut down the nametree process.

implement Tst;
include "sys.m";
	sys: Sys;
include "draw.m";
include "styx.m";
include "styxservers.m";
	styxservers: Styxservers;
	Styxserver, Navigator: import styxservers;
	nametree: Nametree;
	Tree: import nametree;

Tst: module
{
	init: fn(nil: ref Draw->Context, argv: list of string);
};

Qroot, Qctl, Qdata: con big iota;	# paths
init(nil: ref Draw->Context, args: list of string)
{
	sys = load Sys Sys->PATH;
	styx := load Styx Styx->PATH;
	styx->init();
	styxservers = load Styxservers Styxservers->PATH;
	styxservers->init(styx);
	nametree = load Nametree Nametree->PATH;
	nametree->init();
	sys->pctl(Sys->FORKNS, nil);
	(tree, treeop) := nametree->start();
	tree.create(Qroot, dir(".", 8r555|Sys->DMDIR, Qroot));
	tree.create(Qroot, dir("ctl", 8r666, Qctl));
	tree.create(Qroot, dir("data", 8r444, Qdata));
	(tchan, srv) := Styxserver.new(sys->fildes(0),
						Navigator.new(treeop), Qroot);
	while((gm := <-tchan) != nil) {
		# normally a pick on gm would act on
		# Tmsg.Read and Tmsg.Write at least
		srv.default(gm);
	}
	tree.quit();
}

dir(name: string, perm: int, qid: big): Sys->Dir
{
	d := sys->zerodir;
	d.name = name;
	d.uid = "me";
	d.gid = "me";
	d.qid.path = qid;
	if (perm & Sys->DMDIR)
		d.qid.qtype = Sys->QTDIR;
	else
		d.qid.qtype = Sys->QTFILE;
	d.mode = perm;
	return d;
}