implement Sh;include "sys.m";	sys: Sys;include "draw.m";include "sh.m";	sh: Sh;	myself: Shellbuiltin;	mysh: Sh; Namespace: adt {	name: string;	madecmd: array of int;	mods: list of (string, Shellbuiltin);	builtins: array of list of (string, Shellbuiltin);};Builtin, Sbuiltin: con iota; namespaces: list of ref Namespace;pending: list of (string, int, Shellbuiltin);lock: chan of int;BUILTINPATH: con "/dis/sh"; initbuiltin(c: ref Sh->Context, shmod: Sh): string{	sys = load Sys Sys->PATH;	sh = shmod;	mysh = load Sh "$self";	myself = load Shellbuiltin "$self";	sh->c.addbuiltin("mload", myself);	sh->c.addbuiltin("munload", myself);	lock = chan[1] of int;	return nil;} runbuiltin(ctxt: ref Sh->Context, nil: Sh,			argv: list of ref Sh->Listnode, last: int): string{	cmd := (hd argv).word;	case cmd {	"mload" or "munload" =>		if(tl argv == nil)			ctxt.fail("usage", "usage: "+cmd+" name [module...]"); 		# by doing this lock, we're relying on modules not to invoke a command		# in initbuiltin that calls back into mload. since they shouldn't be running		# any commands in initbuiltin anyway, this seems like a reasonable assumption.		lock <-= 1;		{			name := (hd tl argv).word;			for(argv = tl tl argv; argv != nil; argv = tl argv){				if((hd argv).cmd != nil)					ctxt.fail("usage", "usage: "+cmd+" namespace [module...]");				if(cmd == "mload")					mload(ctxt, name, (hd argv).word);				else					munload(ctxt, name, (hd argv).word);			}		}exception{		"fail:*" =>			<-lock;			raise;		}		<-lock;		return nil;	* =>		if(len argv < 2)			ctxt.fail("usage", sys->sprint("usage: %s command", (hd argv).word)); 		b := lookup(ctxt, (hd argv).word, (hd tl argv).word, Builtin, nil);		return b->runbuiltin(ctxt, mysh, tl argv, last);	}} mload(ctxt: ref Sh->Context, name, modname: string): string{	ns := nslookup(name);	if(ns == nil){		ns = ref Namespace(name, array[2] of {* => 0}, nil, array[2] of list of (string, Shellbuiltin));		namespaces = ns :: namespaces;	}	for(nsm := ns.mods; nsm != nil; nsm = tl nsm)		if((hd nsm).t0 == modname)			return nil;	path := modname;	if (len path < 4 || path[len path-4:] != ".dis")		path += ".dis";	if (path[0] != '/' && path[0:2] != "./")		path = BUILTINPATH + "/" + path;	mod := load Shellbuiltin path;	if (mod == nil)		ctxt.fail("bad module", sys->sprint("load: cannot load %s: %r", path));	s := mod->initbuiltin(ctxt, mysh);	if(s != nil){		munload(ctxt, name, modname);		pending = nil;		ctxt.fail("init", "mload: init "+modname+" failed: "+s);	}	mod = mod->getself();	ns.mods = (modname, mod) :: ns.mods;	for(; pending != nil; pending = tl pending){		(cmd, which, pmod) := hd pending;		if(pmod != mod)			sys->fprint(sys->fildes(2), "mload: unexpected module when loading %#q", name);		else			lookup(ctxt, name, cmd, which, mod);	}			return nil;} munload(ctxt: ref Sh->Context, name, modname: string): string{	ns := nslookup(name);	if(ns == nil){		sys->fprint(sys->fildes(2), "munload: no such namespace %#q\n", name);		return "fail";	}	nm: list of (string, Shellbuiltin);	mod: Shellbuiltin;	for(m := ns.mods; m != nil; m = tl m)		if((hd m).t0 == modname)			mod = (hd m).t1;		else			nm = hd m :: nm;	if(mod == nil){		sys->fprint(sys->fildes(2), "munload: no such module %#q\n", modname);		return "fail";	}	ns.mods = nm;	for(i := 0; i < 2; i++){		nb: list of (string, Shellbuiltin) = nil;		for(b := ns.builtins[i]; b != nil; b = tl b)			if((hd b).t1 != mod)				nb = hd b :: nb;		ns.builtins[i] = nb;		if(ns.builtins[i] == nil){			if(i == Builtin)				sh->ctxt.removebuiltin(name, myself);			else				sh->ctxt.removesbuiltin(name, myself);		}				}	return nil;}  runsbuiltin(ctxt: ref Sh->Context, nil: Sh,			argv: list of ref Sh->Listnode): list of ref Sh->Listnode{	if(len argv < 2)		ctxt.fail("usage", sys->sprint("usage: %s command", (hd argv).word));	b := lookup(ctxt, (hd argv).word, (hd tl argv).word, Sbuiltin, nil);	return b->runsbuiltin(ctxt, mysh, tl argv);} searchns(mod: Shellbuiltin): string{	for(m := namespaces; m != nil; m = tl m)		for(b := (hd m).mods; b != nil; b = tl b)			if((hd b).t1 == mod)				return (hd m).name;	return nil;} lookup(ctxt: ref Sh->Context, name, cmd: string, which: int, sb: Shellbuiltin): Shellbuiltin{	for(m := namespaces; m != nil; m = tl m)		if((hd m).name == name)			break;	if(m == nil)		ctxt.fail("unknown", sys->sprint("unknown namespace %q", name));	ns := hd m;	for(b := ns.builtins[which]; b != nil; b = tl b)			if((hd b).t0 == cmd)				break;	if(b == nil){		if(sb != nil){			ns.builtins[which] = (cmd, sb) :: ns.builtins[which];			if(!ns.madecmd[which]){				if(which == Builtin)					sh->ctxt.addbuiltin(name, myself);				else					sh->ctxt.addsbuiltin(name, myself);				ns.madecmd[which] = 1;			}			return sb;		}		ctxt.fail("unknown cmd", sys->sprint("unknown command %q", cmd));	}	return (hd b).t1;} Context.addbuiltin(c: self ref Context, modname: string, mod: Shellbuiltin){	name := searchns(mod);	if(name == nil)		pending = (modname, Builtin, mod) :: pending;	else		lookup(c, name, modname, Builtin, mod);} Context.addsbuiltin(c: self ref Context, modname: string, mod: Shellbuiltin){	name := searchns(mod);	if(name == nil)		pending = (modname, Sbuiltin, mod) :: pending;	else		lookup(c, name, modname, Sbuiltin, mod);} Context.removebuiltin(c: self ref Context, nil: string, nil: Shellbuiltin){	c.fail("nope", "mload: remove builtin not implemented");} Context.removesbuiltin(c: self ref Context, nil: string, nil: Shellbuiltin){	c.fail("nope", "mload: remove sbuiltin not implemented");} Context.addmodule(nil: self ref Context, name: string, nil: Shellbuiltin){	sys->fprint(sys->fildes(2), "mload: addmodule not allowed (%s)\n", name);} nslookup(name: string): ref Namespace{	for(m := namespaces; m != nil; m = tl m)		if((hd m).name == name)			return hd m;	return nil;} whatis(nil: ref Sh->Context, nil: Sh, nil: string, nil: int): string{	return nil;} getself(): Shellbuiltin{	return myself;} initialise(){	return sh->initialise();} init(ctxt: ref Draw->Context, argv: list of string){	return sh->init(ctxt, argv);} system(ctxt: ref Draw->Context, cmd: string): string{	return sh->system(ctxt, cmd);} run(ctxt: ref Draw->Context, argv: list of string): string{	return sh->run(ctxt, argv);}	parse(s: string): (ref Cmd, string){	return sh->parse(s);} cmd2string(c: ref Cmd): string{	return sh->cmd2string(c);} list2stringlist(nl: list of ref Listnode): list of string{	return sh->list2stringlist(nl);} stringlist2list(sl: list of string): list of ref Listnode{	return sh->stringlist2list(sl);} quoted(val: list of ref Listnode, quoteblocks: int): string{	return sh->quoted(val, quoteblocks);} Context.new(drawcontext: ref Draw->Context): ref Context{	return sh->Context.new(drawcontext);} Context.get(c: self ref Context, name: string): list of ref Listnode{	return sh->c.get(name);} Context.set(c: self ref Context, name: string, val: list of ref Listnode){	return sh->c.set(name, val);} Context.setlocal(c: self ref Context, name: string, val: list of ref Listnode){	return sh->c.setlocal(name, val);} Context.envlist(c: self ref Context): list of (string, list of ref Listnode){	return sh->c.envlist();} Context.push(c: self ref Context){	return sh->c.push();} Context.pop(c: self ref Context){	return sh->c.pop();} Context.copy(c: self ref Context, copyenv: int): ref Context{	return sh->c.copy(copyenv);} Context.run(c: self ref Context, args: list of ref Listnode, last: int): string{	return sh->c.run(args, last);} Context.fail(c: self ref Context, ename, msg: string){	return sh->c.fail(ename, msg);} Context.options(c: self ref Context): int{	return sh->c.options();} Context.setoptions(c: self ref Context, flags, on: int): int{	return sh->c.setoptions(flags, on);}