git: plan9front

--- a/sys/src/cmd/mk/arc.c

+++ b/sys/src/cmd/mk/arc.c

@@ -8,7 +8,7 @@

 	a = (Arc *)Malloc(sizeof(Arc));

 	a->n = n;

 	a->r = r;

-	a->stem = strdup(stem);

+	a->stem = Strdup(stem);

 	rcopy(a->match, match, NREGEXP);

 	a->next = 0;

 	a->flag = 0;

@@ -17,6 +17,13 @@

 void

+freearc(Arc *a)

+{

+	free(a->stem);

+	free(a);

+}

+void

 dumpa(char *s, Arc *a)

 	char buf[1024];

@@ -36,15 +43,10 @@

 void

 nrep(void)

-	Symtab *sym;

 	Word *w;

-	sym = symlook("NREP", S_VAR, 0);

-	if(sym){

-		w = sym->u.ptr;

-		if (w && w->s && *w->s)

-			nreps = atoi(w->s);

-	}

+	if(!empty(w = getvar("NREP")))

+		nreps = atoi(w->s);

 	if(nreps < 1)

 		nreps = 1;

 	if(DEBUG(D_GRAPH))

--- a/sys/src/cmd/mk/archive.c

+++ b/sys/src/cmd/mk/archive.c

@@ -7,9 +7,9 @@

 long

 atimeof(int force, char *name)

+	char buf[512], *archive, *member;

 	Symtab *sym;

 	long t;

-	char *archive, *member, buf[512];

 	archive = split(name, &member);

 	if(archive == 0)

@@ -26,7 +26,7 @@

 	else{

 		atimes(archive);

 		/* mark the aggegate as having been done */

-		symlook(strdup(archive), S_AGG, "")->u.value = t;

+		symlook(archive, S_AGG, 1)->u.value = t;

 		/* truncate long member name to sizeof of name field in archive header */

 	snprint(buf, sizeof(buf), "%s(%.*s)", archive, utfnlen(member, SARNAME), member);

@@ -113,7 +113,7 @@

 			i--;

 		h.name[i+1]=0;		/* can stomp on date field */

 		snprint(buf, sizeof buf, "%s(%s)", ar, h.name);

-		symlook(strdup(buf), S_TIME, (void*)t)->u.value = t;

+		symlook(buf, S_TIME, 1)->u.value = t;

 		t = atol(h.size);

 		if(t&01) t++;

 		LSEEK(fd, t, 1);

@@ -131,7 +131,7 @@

 	if(fd < 0){

 		if(symlook(file, S_BITCH, 0) == 0){

 			Bprint(&bout, "%s doesn't exist: assuming it will be an archive\n", file);

-			symlook(file, S_BITCH, (void *)file);

+			symlook(file, S_BITCH, 1);

 		return 1;

@@ -148,7 +148,7 @@

 	char *p, *q;

-	p = strdup(name);

+	p = Strdup(name);

 	q = utfrune(p, '(');

 	if(q){

 		*q++ = 0;

@@ -159,8 +159,8 @@

 			*q = 0;

 		if(type(p))

 			return p;

-		free(p);

 		fprint(2, "mk: '%s' is not an archive\n", name);

+	free(p);

 	return 0;

--- a/sys/src/cmd/mk/bufblock.c

+++ b/sys/src/cmd/mk/bufblock.c

@@ -25,6 +25,8 @@

 void

 freebuf(Bufblock *p)

+	assert(p->current >= p->start);

+	p->current = 0;

 	p->next = freelist;

 	freelist = p;

@@ -39,6 +41,7 @@

 	n = p->end-p->start+QUANTA;

 		/* search the free list for a big buffer */

 	for (f = freelist; f; f = f->next) {

+		assert(f->current == 0);

 		if (f->end-f->start >= n) {

 			memcpy(f->start, p->start, p->end-p->start);

 			cp = f->start;

@@ -47,7 +50,6 @@

 			cp = f->end;

 			f->end = p->end;

 			p->end = cp;

-			f->current = f->start;

 			break;

@@ -59,9 +61,17 @@

 void

-bufcpy(Bufblock *buf, char *cp, int n)

+bufcpy(Bufblock *buf, char *cp)

+	int c;

+	while (c = *cp++)

+		insert(buf, c);

+}

+void

+bufncpy(Bufblock *buf, char *cp, int n)

+{

 	while (n--)

 		insert(buf, *cp++);

@@ -69,7 +79,6 @@

 void

 insert(Bufblock *buf, int c)

 	if (buf->current >= buf->end)

 		growbuf(buf);

 	*buf->current++ = c;

--- a/sys/src/cmd/mk/env.c

+++ b/sys/src/cmd/mk/env.c

@@ -1,10 +1,10 @@

 #include	"mk.h"

 enum {

-	ENVQUANTA=10

+	ENVQUANTA=64

};

-Envy	*envy;

+static Symtab **envy;

 static int nextv;

 static char	*myenv[] =

@@ -36,72 +36,66 @@

 	char **p;

 	for(p = myenv; *p; p++)

-		symlook(*p, S_INTERNAL, (void *)"");

+		symlook(*p, S_INTERNAL, 1)->u.ptr = 0;

 	readenv();				/* o.s. dependent */

 static void

-envinsert(char *name, Word *value)

+envupd(char *name, Word *value)

+	Symtab *sym = symlook(name, S_INTERNAL, 0);

+	assert(sym != 0);

+	delword(sym->u.ptr);

+	sym->u.ptr = value;

+}

+static void

+envinsert(Symtab *sym)

+{

 	static int envsize;

 	if (nextv >= envsize) {

 		envsize += ENVQUANTA;

-		envy = (Envy *) Realloc((char *) envy, envsize*sizeof(Envy));

+		envy = (Symtab **) Realloc(envy, envsize*sizeof(Symtab*));

-	envy[nextv].name = name;

-	envy[nextv++].values = value;

+	envy[nextv++] = sym;

 static void

-envupd(char *name, Word *value)

+ereset(Symtab *s)

-	Envy *e;

-	for(e = envy; e->name; e++)

-		if(strcmp(name, e->name) == 0){

-			delword(e->values);

-			e->values = value;

-			return;

-		}

-	e->name = name;

-	e->values = value;

-	envinsert(0,0);

+	delword(s->u.ptr);

+	s->u.ptr = 0;

+	envinsert(s);

 static void

 ecopy(Symtab *s)

-	char **p;

 	if(symlook(s->name, S_NOEXPORT, 0))

 		return;

-	for(p = myenv; *p; p++)

-		if(strcmp(*p, s->name) == 0)

-			return;

-	envinsert(s->name, s->u.ptr);

+	if(symlook(s->name, S_INTERNAL, 0))

+		return;

+	envinsert(s);

-void

+Symtab**

 execinit(void)

-	char **p;

 	nextv = 0;

-	for(p = myenv; *p; p++)

-		envinsert(*p, stow(""));

+	symtraverse(S_INTERNAL, ereset);

 	symtraverse(S_VAR, ecopy);

-	envinsert(0, 0);

+	envinsert(0);

+	return envy;

-Envy*

+Symtab**

 buildenv(Job *j, int slot)

 	char **p, *cp, *qp;

 	Word *w, *v, **l;

+	char num[16];

 	int i;

-	char buf[256];

 	envupd("target", wdup(j->t));

 	if(j->r->attr&REGEXP)

@@ -109,10 +103,10 @@

 	else

 		envupd("stem", newword(j->stem));

 	envupd("prereq", wdup(j->p));

-	snprint(buf, sizeof buf, "%d", getpid());

-	envupd("pid", newword(buf));

-	snprint(buf, sizeof buf, "%d", slot);

-	envupd("nproc", newword(buf));

+	snprint(num, sizeof num, "%d", getpid());

+	envupd("pid", newword(num));

+	snprint(num, sizeof num, "%d", slot);

+	envupd("nproc", newword(num));

 	envupd("newprereq", wdup(j->np));

 	envupd("alltarget", wdup(j->at));

 	l = &v;

@@ -129,10 +123,7 @@

 				continue;

-		*l = w->next;

-		free(w->s);

-		free(w);

-		w = *l;

+		*l = w = popword(w);

 	envupd("newmember", v);

 		/* update stem0 -> stem9 */

--- a/sys/src/cmd/mk/file.c

+++ b/sys/src/cmd/mk/file.c

@@ -21,7 +21,7 @@

 		return mtime(name);

 	sym = symlook(name, S_TIME, 0);

-	if (sym)

+	if(sym)

 		return sym->u.value;		/* uggh */

 	t = mkmtime(name, 0);

@@ -28,7 +28,7 @@

 	if(t == 0)

 		return 0;

-	symlook(name, S_TIME, (void*)t);		/* install time in cache */

+	symlook(name, S_TIME, 1)->u.value = t;		/* install time in cache */

 	return t;

@@ -76,7 +76,7 @@

 		} while(*s);

 		c = *s;

 		*s = 0;

-		symlook(strdup(cp), S_TIME, (void *)t)->u.value = t;

+		symlook(cp, S_TIME, 1)->u.value = t;

 		if (c)

 			*s++ = c;

 		while(*s){

--- a/sys/src/cmd/mk/fns.h

+++ b/sys/src/cmd/mk/fns.h

@@ -1,11 +1,13 @@

 void	addrule(char*, Word*, char*, Word*, int, int, char*);

 void	addrules(Word*, Word*, char*, int, int, char*);

-void	addw(Word*, char*);

 int	assline(Biobuf *, Bufblock *);

 long	atimeof(int,char*);

 void	atouch(char*);

-void	bufcpy(Bufblock *, char *, int);

-Envy	*buildenv(Job*, int);

+void	bufcpy(Bufblock *, char *);

+void	bufcpyq(Bufblock *, char *);

+void	bufcpyw(Bufblock *, Word *);

+void	bufncpy(Bufblock *, char *, int);

+Symtab	**buildenv(Job*, int);

 void	catchnotes(void);

 char 	*charin(char *, char *);

 int	chgtime(char*);

@@ -20,23 +22,24 @@

 void	dumpr(char*, Rule*);

 void	dumpv(char*);

 void	dumpw(char*, Word*);

+int	empty(Word*);

 int	escapetoken(Biobuf*, Bufblock*, int, int);

-void	execinit(void);

-int	execsh(char*, char*, Bufblock*, Envy*);

+Symtab	**execinit(void);

+int	execsh(char*, char*, Symtab**, Bufblock*);

 void	Exit(void);

 char	*expandquote(char*, Rune, Bufblock*);

 void	expunge(int, char*);

+void	freearc(Arc*);

 void	freebuf(Bufblock*);

+void	freejob(Job*);

 void	front(char*);

+Word	*getvar(char*);

 Node	*graph(char*);

 void	growbuf(Bufblock *);

 void	initenv(void);

 void	insert(Bufblock *, int);

-void	ipop(void);

-void	ipush(void);

 void	killchildren(char*);

 void	*Malloc(int);

-char	*maketmp(void);

 int	match(char*, char*, char*);

 void	mk(char*);

 ulong	mkmtime(char*, int);

@@ -50,8 +53,9 @@

 void	nproc(void);

 void	nrep(void);

 int	outofdate(Node*, Arc*, int);

-void	parse(char*, int, int);

-int	pipecmd(char*, Envy*, int*);

+void	parse(char*, int);

+int	pipecmd(char*, char*, Symtab**, int*);

+Word	*popword(Word*);

 void	prusage(void);

 void	rcopy(char**, Resub*, int);

 void	readenv(void);

@@ -59,12 +63,13 @@

 void	rinsert(Bufblock *, Rune);

 char	*rulecnt(void);

 void	run(Job*);

-void	setvar(char*, void*);

+void	setvar(char*, Word*);

 char	*shname(char*);

-void	shprint(char*, Envy*, Bufblock*);

+void	shprint(char*, Bufblock*);

 Word	*stow(char*);

+char	*Strdup(char*);

 void	subst(char*, char*, char*, int);

-Symtab	*symlook(char*, int, void*);

+Symtab	*symlook(char*, int, int);

 void	symtraverse(int, void(*)(Symtab*));

 void	timeinit(char*);

 long	timeof(char*, int);

@@ -71,9 +76,12 @@

 void	touch(char*);

 void	update(int, Node*);

 void	usage(void);

+void	varoverride(char*);

 Word	*varsub(char**);

+int	wadd(Word**, char*);

 int	waitfor(char*);

 int	waitup(int, int*);

+int	wcmp(Word*, Word*);

 Word	*wdup(Word*);

 int	work(Node*, Node*, Arc*);

-char	*wtos(Word*, int);

+char	*wtos(Word*);

--- a/sys/src/cmd/mk/graph.c

+++ b/sys/src/cmd/mk/graph.c

@@ -41,7 +41,6 @@

 	sym = symlook(target, S_NODE, 0);

 	if(sym)

 		return sym->u.ptr;

-	target = strdup(target);

 	node = newnode(target);

 	head.n = 0;

 	head.next = 0;

@@ -49,8 +48,7 @@

 	memset((char*)rmatch, 0, sizeof(rmatch));

 	for(r = sym? sym->u.ptr:0; r; r = r->chain){

 		if(r->attr&META) continue;

-		if(strcmp(target, r->target)) continue;

-		if((!r->recipe || !*r->recipe) && (!r->tail || !r->tail->s || !*r->tail->s)) continue;	/* no effect; ignore */

+		if((!r->recipe || !*r->recipe) && empty(r->tail)) continue;	/* no effect; ignore */

 		if(cnt[r->rule] >= nreps) continue;

 		cnt[r->rule]++;

 		node->flags |= PROBABLE;

@@ -62,19 +60,20 @@

  *		if(r->attr&DEL)

  *			node->flags |= DELETE;

*/

-		if(!r->tail || !r->tail->s || !*r->tail->s) {

+		if(empty(r->tail)) {

 			a->next = newarc((Node *)0, r, "", rmatch);

 			a = a->next;

-		} else

+		} else {

 			for(w = r->tail; w; w = w->next){

 				a->next = newarc(applyrules(w->s, cnt), r, "", rmatch);

 				a = a->next;

+			}

 		cnt[r->rule]--;

 		head.n = node;

 	for(r = metarules; r; r = r->next){

-		if((!r->recipe || !*r->recipe) && (!r->tail || !r->tail->s || !*r->tail->s)) continue;	/* no effect; ignore */

+		if((!r->recipe || !*r->recipe) && empty(r->tail)) continue;	/* no effect; ignore */

 		if ((r->attr&NOVIRT) && a != &head && (a->r->attr&VIR))

 			continue;

 		if(r->attr&REGEXP){

@@ -84,7 +83,7 @@

 			if(regexec(r->pat, node->name, rmatch, NREGEXP) == 0)

 				continue;

 		} else {

-			if(!match(node->name, r->target, stem)) continue;

+			if(!match(node->name, r->target->name, stem)) continue;

 		if(cnt[r->rule] >= nreps) continue;

 		cnt[r->rule]++;

@@ -96,7 +95,7 @@

  *		if(r->attr&DEL)

  *			node->flags |= DELETE;

*/

-		if(!r->tail || !r->tail->s || !*r->tail->s) {

+		if(empty(r->tail)){

 			a->next = newarc((Node *)0, r, stem, rmatch);

 			a = a->next;

 		} else

@@ -118,20 +117,20 @@

 static void

 togo(Node *node)

-	Arc *la, *a;

+	Arc **l, *a;

 	/* delete them now */

-	la = 0;

-	for(a = node->prereqs; a; la = a, a = a->next)

+	l = &node->prereqs;

+	while(a = *l){

 		if(a->flag&TOGO){

-			if(a == node->prereqs)

-				node->prereqs = a->next;

-			else

-				la->next = a->next, a = la;

-		}

+			*l = a->next;

+			freearc(a);

+		} else

+			l = &a->next;

+	}

-static

+static int

 vacuous(Node *node)

 	Arc *la, *a;

@@ -149,9 +148,8 @@

 	for(a = node->prereqs; a; a = a->next)

 		if((a->flag&TOGO) == 0)

 			for(la = node->prereqs; la; la = la->next)

-				if((la->flag&TOGO) && (la->r == a->r)){

+				if((la->flag&TOGO) && (la->r == a->r))

 					la->flag &= ~TOGO;

-				}

 	togo(node);

 	if(vac)

 		node->flags |= VACUOUS;

@@ -161,15 +159,17 @@

 static Node *

 newnode(char *name)

-	register Node *node;

+	Symtab *sym;

+	Node *node;

+	sym = symlook(name, S_NODE, 1);

 	node = (Node *)Malloc(sizeof(Node));

-	symlook(name, S_NODE, (void *)node);

-	node->name = name;

+	node->name = sym->name;

 	node->time = timeof(name, 0);

 	node->prereqs = 0;

 	node->flags = node->time? PROBABLE : 0;

 	node->next = 0;

+	sym->u.ptr = node;

 	return(node);

--- a/sys/src/cmd/mk/job.c

+++ b/sys/src/cmd/mk/job.c

@@ -3,7 +3,7 @@

 Job *

 newjob(Rule *r, Node *nlist, char *stem, char **match, Word *pre, Word *npre, Word *tar, Word *atar)

-	register Job *j;

+	Job *j;

 	j = (Job *)Malloc(sizeof(Job));

 	j->r = r;

@@ -20,14 +20,28 @@

 void

+freejob(Job *j)

+{

+	delword(j->p);

+	delword(j->np);

+	delword(j->t);

+	delword(j->at);

+	free(j);

+}

+void

 dumpj(char *s, Job *j, int all)

+	char *t;

 	Bprint(&bout, "%s\n", s);

 	while(j){

 		Bprint(&bout, "job@%p: r=%p n=%p stem='%s' nproc=%d\n",

 			j, j->r, j->n, j->stem, j->nproc);

-		Bprint(&bout, "\ttarget='%s' alltarget='%s' prereq='%s' nprereq='%s'\n",

-			wtos(j->t, ' '), wtos(j->at, ' '), wtos(j->p, ' '), wtos(j->np, ' '));

+		Bprint(&bout, "\ttarget=%s", t = wtos(j->t)), free(t);

+		Bprint(&bout, " alltarget=%s", t = wtos(j->at)), free(t);

+		Bprint(&bout, " prereq=%s", t = wtos(j->p)), free(t);

+		Bprint(&bout, " nprereq=%s\n", t = wtos(j->np)), free(t);

 		j = all? j->next : 0;

--- a/sys/src/cmd/mk/lex.c

+++ b/sys/src/cmd/mk/lex.c

@@ -89,8 +89,7 @@

 			insert(buf, '\n');

 			insert(buf,0);

 			buf->current = buf->start+start;

-			execinit();

-			execsh(0, buf->current, buf, envy);

+			execsh(buf->current, 0, execinit(), buf);

 			return 1;

 		if(c == '\n')

--- a/sys/src/cmd/mk/main.c

+++ b/sys/src/cmd/mk/main.c

@@ -3,36 +3,29 @@

 #define		MKFILE		"mkfile"

 int debug;

-Rule *rules, *metarules;

 int nflag = 0;

+int sflag = 0;

 int tflag = 0;

 int iflag = 0;

 int kflag = 0;

 int aflag = 0;

 int uflag = 0;

+int nreps = 1;

 char *explain = 0;

 Word *target1;

-int nreps = 1;

 Job *jobs;

+Rule *rules, *patrule, *metarules;

 Biobuf bout;

-Rule *patrule;

 void badusage(void);

-#ifdef	PROF

-short buf[10000];

-#endif

 void

 main(int argc, char **argv)

-	Word *w;

-	char *s, *temp;

-	char *files[256], **f = files, **ff;

-	int sflag = 0;

-	int i;

-	int tfd = -1;

-	Biobuf tb;

-	Bufblock *buf;

+	Word **link, *flags, *files, *args;

 	Bufblock *whatif;

+	char *s;

+	int i;

/*

 	 *  start with a copy of the current environment variables

@@ -40,13 +33,14 @@

*/

 	Binit(&bout, 1, OWRITE);

-	buf = newbuf();

 	whatif = 0;

 	USED(argc);

-	for(argv++; *argv && (**argv == '-'); argv++)

+	flags = 0;

+	link = &flags;

+	for(argv++; *argv && (**argv == '-'); argv++, link = &(*link)->next)

-		bufcpy(buf, argv[0], strlen(argv[0]));

-		insert(buf, ' ');

+		*link = newword(*argv);

 		switch(argv[0][1])

 		case 'a':

@@ -67,11 +61,12 @@

 			explain = &argv[0][2];

 			break;

 		case 'f':

-			if(*++argv == 0)

+			argv++;

+			if(*argv == 0 || **argv == 0)

 				badusage();

-			*f++ = *argv;

-			bufcpy(buf, argv[0], strlen(argv[0]));

-			insert(buf, ' ');

+			link = &(*link)->next;

+			*link = newword(*argv);

+			wadd(&files, *argv);

 			break;

 		case 'i':

 			iflag = 1;

@@ -97,11 +92,13 @@

 			else

 				insert(whatif, ' ');

 			if(argv[0][2])

-				bufcpy(whatif, &argv[0][2], strlen(&argv[0][2]));

+				bufcpy(whatif, &argv[0][2]);

 			else {

 				if(*++argv == 0)

 					badusage();

-				bufcpy(whatif, &argv[0][0], strlen(&argv[0][0]));

+				bufcpy(whatif, &argv[0][0]);

+				link = &(*link)->next;

+				*link = newword(*argv);

 			break;

 		default:

@@ -108,12 +105,6 @@

 			badusage();

-#ifdef	PROF

-	{

-		extern etext();

-		monitor(main, etext, buf, sizeof buf, 300);

-	}

-#endif

 	if(aflag)

 		iflag = 1;

@@ -124,54 +115,30 @@

/*

 		assignment args become null strings

*/

-	temp = 0;

+	mkinfile = "command line args";

 	for(i = 0; argv[i]; i++) if(utfrune(argv[i], '=')){

-		bufcpy(buf, argv[i], strlen(argv[i]));

-		insert(buf, ' ');

-		if(tfd < 0){

-			temp = maketmp();

-			if(temp == 0) {

-				perror("temp file");

-				Exit();

-			}

-			if((tfd = create(temp, ORDWR, 0600)) < 0){

-				perror(temp);

-				Exit();

-			}

-			Binit(&tb, tfd, OWRITE);

-		}

-		Bprint(&tb, "%s\n", argv[i]);

+		if(!wadd(&flags, argv[i]))

+			varoverride(argv[i]);

 		*argv[i] = 0;

-	if(tfd >= 0){

-		Bflush(&tb);

-		LSEEK(tfd, 0L, 0);

-		parse("command line args", tfd, 1);

-		remove(temp);

-	}

+	setvar("MKFLAGS", flags);

-	if (buf->current != buf->start) {

-		buf->current--;

-		insert(buf, 0);

-	}

-	symlook("MKFLAGS", S_VAR, (void *) stow(buf->start));

-	buf->current = buf->start;

+	args = 0;

+	link = &args;

 	for(i = 0; argv[i]; i++){

 		if(*argv[i] == 0) continue;

-		if(i)

-			insert(buf, ' ');

-		bufcpy(buf, argv[i], strlen(argv[i]));

+		*link = newword(argv[i]);

+		link = &(*link)->next;

-	insert(buf, 0);

-	symlook("MKARGS", S_VAR, (void *) stow(buf->start));

-	freebuf(buf);

+	setvar("MKARGS", args);

-	if(f == files){

-		if(access(MKFILE, 4) == 0)

-			parse(MKFILE, open(MKFILE, 0), 0);

-	} else

-		for(ff = files; ff < f; ff++)

-			parse(*ff, open(*ff, 0), 0);

+	if(files == 0){

+		if(access(MKFILE, AEXIST) == 0)

+			parse(MKFILE, open(MKFILE, OREAD|OCEXEC));

+	} else {

+		for(; files; files = popword(files))

+			parse(files->s, open(files->s, OREAD|OCEXEC));

+	}

 	if(DEBUG(D_PARSE)){

 		dumpw("default targets", target1);

 		dumpr("rules", rules);

@@ -184,44 +151,26 @@

 		freebuf(whatif);

 	execinit();

-	/* skip assignment args */

-	while(*argv && (**argv == 0))

-		argv++;

 	catchnotes();

-	if(*argv == 0){

-		if(target1)

-			for(w = target1; w; w = w->next)

-				mk(w->s);

-		else {

+	if(args == 0){

+		if(target1 == 0){

 			fprint(2, "mk: nothing to mk\n");

 			Exit();

+		for(; target1; target1 = popword(target1))

+			mk(target1->s);

 	} else {

+		args = wdup(args);

 		if(sflag){

-			for(; *argv; argv++)

-				if(**argv)

-					mk(*argv);

+			for(; args; args = popword(args))

+				mk(args->s);

 		} else {

-			Word *head, *tail, *t;

-			/* fake a new rule with all the args as prereqs */

-			tail = 0;

-			t = 0;

-			for(; *argv; argv++)

-				if(**argv){

-					if(tail == 0)

-						tail = t = newword(*argv);

-					else {

-						t->next = newword(*argv);

-						t = t->next;

-					}

-				}

-			if(tail->next == 0)

-				mk(tail->s);

+			if(args->next == 0)

+				mk(args->s);

 			else {

-				head = newword("command line arguments");

-				addrules(head, tail, strdup(""), VIR, mkinline, 0);

+				Word *head = newword(mkinfile);

+				addrules(head, args, Strdup(""), VIR, 0, 0);

 				mk(head->s);

@@ -234,7 +183,6 @@

 void

 badusage(void)

 	fprint(2, "usage: mk [-f file] [-n] [-a] [-e] [-t] [-k] [-i] [-d[egp]] [targets ...]\n");

 	Exit();

@@ -242,7 +190,7 @@

 void *

 Malloc(int n)

-	register void *s;

+	void *s;

 	s = malloc(n);

 	if(!s) {

@@ -249,6 +197,7 @@

 		fprint(2, "mk: cannot alloc %d bytes\n", n);

 		Exit();

+	setmalloctag(s, getcallerpc(&n));

 	return(s);

@@ -263,9 +212,20 @@

 		fprint(2, "mk: cannot alloc %d bytes\n", n);

 		Exit();

+	setrealloctag(s, getcallerpc(&s));

 	return(s);

+char *

+Strdup(char *s)

+{

+	int n = strlen(s)+1;

+	char *d = Malloc(n);

+	memcpy(d, s, n);

+	setmalloctag(d, getcallerpc(&s));

+	return d;

+}

 void

 regerror(char *s)

@@ -274,6 +234,6 @@

 			patrule->file, patrule->line, s);

 	else

 		fprint(2, "mk: %s:%d: regular expression error; %s\n",

-			infile, mkinline, s);

+			mkinfile, mkinline, s);

 	Exit();

--- a/sys/src/cmd/mk/mk.c

+++ b/sys/src/cmd/mk/mk.c

@@ -172,7 +172,7 @@

 	Arc *a;

 	MADESET(node, fake? BEINGMADE : MADE);

-	if(((node->flags&VIRTUAL) == 0) && (access(node->name, 0) == 0)){

+	if(((node->flags&VIRTUAL) == 0) && (access(node->name, AEXIST) == 0)){

 		node->time = timeof(node->name, 1);

 		node->flags &= ~(CANPRETEND|PRETENDING);

 		for(a = node->prereqs; a; a = a->next)

@@ -188,14 +188,12 @@

 static

-pcmp(char *prog, char *p, char *q)

+pcmp(char *cmd)

-	char buf[3*NAMEBLOCK];

 	int pid;

 	Bflush(&bout);

-	snprint(buf, sizeof buf, "%s '%s' '%s'\n", prog, p, q);

-	pid = pipecmd(buf, 0, 0);

+	pid = pipecmd(cmd, 0, 0, 0);

 	while(waitup(-3, &pid) >= 0)

 	return(pid? 2:1);

@@ -204,25 +202,28 @@

int

 outofdate(Node *node, Arc *arc, int eval)

-	char buf[3*NAMEBLOCK], *str;

-	Symtab *sym;

-	int ret;

-	str = 0;

 	if(arc->prog){

-		snprint(buf, sizeof buf, "%s%c%s", node->name, 0377,

-			arc->n->name);

-		sym = symlook(buf, S_OUTOFDATE, 0);

+		Bufblock *cmd;

+		Symtab *sym;

+		int ret;

+		cmd = newbuf();

+		bufcpy(cmd, arc->prog);

+		insert(cmd, ' ');

+		bufcpyq(cmd, node->name);

+		insert(cmd, ' ');

+		bufcpyq(cmd, arc->n->name);

+		insert(cmd, '\n');

+		insert(cmd, 0);

+		sym = symlook(cmd->start, S_OUTOFDATE, 0);

 		if(sym == 0 || eval){

+			ret = pcmp(cmd->start);

 			if(sym == 0)

-				str = strdup(buf);

-			ret = pcmp(arc->prog, node->name, arc->n->name);

-			if(sym)

-				sym->u.value = ret;

-			else

-				symlook(str, S_OUTOFDATE, (void *)ret);

+				sym = symlook(cmd->start, S_OUTOFDATE, 1);

+			sym->u.value = ret;

 		} else

 			ret = sym->u.value;

+		freebuf(cmd);

 		return(ret-1);

 	} else if(strchr(arc->n->name, '(') && arc->n->time == 0)  /* missing archive member */

 		return 1;

--- a/sys/src/cmd/mk/mk.h

+++ b/sys/src/cmd/mk/mk.h

@@ -15,21 +15,39 @@

 typedef struct Word

-	char 		*s;

 	struct Word 	*next;

+	char 		s[1];

 } Word;

-typedef struct Envy

+typedef struct Symtab

-	char 		*name;

-	Word 		*values;

-} Envy;

+	union{

+		void	*ptr;

+		uintptr	value;

+	} u;

+	struct Symtab	*next;

+	unsigned char	space;

+	char		name[1];

+} Symtab;

-extern Envy *envy;

+enum {

+	S_VAR,		/* variable -> value */

+	S_TARGET,	/* target -> rule */

+	S_TIME,		/* file -> time */

+	S_NODE,		/* target name -> node */

+	S_AGG,		/* aggregate -> time */

+	S_BITCH,	/* bitched about aggregate not there */

+	S_NOEXPORT,	/* var -> noexport */

+	S_OVERRIDE,	/* can't override */

+	S_OUTOFDATE,	/* "cmp 'file1' 'file2'\n" -> 2(outofdate) or 1(not outofdate) */

+	S_BULKED,	/* directory; we have bulked */

+	S_WESET,	/* variable; we set in the mkfile */

+	S_INTERNAL,	/* variable -> value; an internal mk variable (e.g., stem, target) */

+};

 typedef struct Rule

-	char 		*target;	/* one target */

+	Symtab 		*target;	/* one target */

 	Word 		*tail;		/* constituents of targets */

 	char 		*recipe;	/* do it ! */

 	short 		attr;		/* attributes */

@@ -112,50 +130,17 @@

 } Job;

 extern Job *jobs;

-typedef struct Symtab

-{

-	short		space;

-	char		*name;

-	union{

-		void		*ptr;

-		uintptr	value;

-	} u;

-	struct Symtab	*next;

-} Symtab;

-enum {

-	S_VAR,		/* variable -> value */

-	S_TARGET,	/* target -> rule */

-	S_TIME,		/* file -> time */

-	S_PID,		/* pid -> products */

-	S_NODE,		/* target name -> node */

-	S_AGG,		/* aggregate -> time */

-	S_BITCH,	/* bitched about aggregate not there */

-	S_NOEXPORT,	/* var -> noexport */

-	S_OVERRIDE,	/* can't override */

-	S_OUTOFDATE,	/* n1\377n2 -> 2(outofdate) or 1(not outofdate) */

-	S_MAKEFILE,	/* target -> node */

-	S_MAKEVAR,	/* dumpable mk variable */

-	S_EXPORTED,	/* var -> current exported value */

-	S_BULKED,	/* we have bulked this dir */

-	S_WESET,	/* variable; we set in the mkfile */

-	S_INTERNAL,	/* an internal mk variable (e.g., stem, target) */

-};

 extern	int	debug;

 extern	int	nflag, tflag, iflag, kflag, aflag, mflag;

 extern	int	mkinline;

-extern	char	*infile;

+extern	char	*mkinfile;

 extern	int	nreps;

 extern	char	*explain;

-extern	char	*termchars;

-extern	char 	*shell;

-extern	char 	*shellname;

-extern	char 	*shflags;

-extern	int	IWS;

+extern	char	termchars[];

+extern	char 	shell[];

+extern	char 	shellname[];

-#define	SYNERR(l)	(fprint(2, "mk: %s:%d: syntax error; ", infile, ((l)>=0)?(l):mkinline))

-#define	RERR(r)		(fprint(2, "mk: %s:%d: rule error; ", (r)->file, (r)->line))

+#define	SYNERR(l)	(fprint(2, "mk: %s:%d: syntax error; ", mkinfile, ((l)>=0)?(l):mkinline))

 #define	NAMEBLOCK	1000

 #define	BIGBLOCK	20000

--- a/sys/src/cmd/mk/parse.c

+++ b/sys/src/cmd/mk/parse.c

@@ -1,31 +1,30 @@

 #include	"mk.h"

-char *infile;

+char *mkinfile;

 int mkinline;

+static void ipush(char *file);

+static void ipop(void);

+static void doassign(Word *, Word *, int, int);

 static int rhead(char *, Word **, Word **, int *, char **);

 static char *rbody(Biobuf*);

 extern Word *target1;

 void

-parse(char *f, int fd, int varoverride)

+parse(char *f, int fd)

-	int hline;

-	char *body;

+	int hline, attr, pid, newfd;

 	Word *head, *tail;

-	int attr, set, pid;

 	char *prog, *p;

-	int newfd;

-	Biobuf in;

 	Bufblock *buf;

+	Biobuf in;

 	if(fd < 0){

 		perror(f);

 		Exit();

-	ipush();

-	infile = strdup(f);

-	mkinline = 1;

 	Binit(&in, fd, OREAD);

+	ipush(f);

 	buf = newbuf();

 	while(assline(&in, buf)){

 		hline = mkinline;

@@ -32,33 +31,33 @@

 		switch(rhead(buf->start, &head, &tail, &attr, &prog))

 		case '<':

-			p = wtos(tail, ' ');

+			p = wtos(tail);

 			if(*p == 0){

 				SYNERR(-1);

 				fprint(2, "missing include file name\n");

 				Exit();

-			newfd = open(p, OREAD);

+			newfd = open(p, OREAD|OCEXEC);

 			if(newfd < 0){

 				fprint(2, "warning: skipping missing include file: ");

 				perror(p);

 			} else

-				parse(p, newfd, 0);

+				parse(p, newfd);

+			free(p);

 			break;

 		case '|':

-			p = wtos(tail, ' ');

+			p = wtos(tail);

 			if(*p == 0){

 				SYNERR(-1);

 				fprint(2, "missing include program name\n");

 				Exit();

-			execinit();

-			pid=pipecmd(p, envy, &newfd);

+			pid=pipecmd(p, 0, execinit(), &newfd);

 			if(newfd < 0){

 				fprint(2, "warning: skipping missing program file: ");

 				perror(p);

 			} else

-				parse(p, newfd, 0);

+				parse(p, newfd);

 			while(waitup(-3, &pid) >= 0)

 			if(pid != 0){

@@ -65,36 +64,14 @@

 				fprint(2, "bad include program status\n");

 				Exit();

+			free(p);

 			break;

 		case ':':

-			body = rbody(&in);

-			addrules(head, tail, body, attr, hline, prog);

-			break;

+			addrules(head, tail, rbody(&in), attr, hline, prog);

+			continue;	/* don't free head and tail */

 		case '=':

-			if(head->next){

-				SYNERR(-1);

-				fprint(2, "multiple vars on left side of assignment\n");

-				Exit();

-			}

-			if(symlook(head->s, S_OVERRIDE, 0)){

-				set = varoverride;

-			} else {

-				set = 1;

-				if(varoverride)

-					symlook(head->s, S_OVERRIDE, (void *)"");

-			}

-			if(set){

-/*

-char *cp;

-dumpw("tail", tail);

-cp = wtos(tail, ' '); print("assign %s to %s\n", head->s, cp); free(cp);

-*/

-				setvar(head->s, (void *) tail);

-				symlook(head->s, S_WESET, (void *)"");

-			}

-			if(attr)

-				symlook(head->s, S_NOEXPORT, (void *)"");

-			break;

+			doassign(head, tail, attr, 0);

+			continue;

 		default:

 			SYNERR(hline);

 			fprint(2, "expected one of :<=\n");

@@ -101,13 +78,59 @@

 			Exit();

 			break;

+		delword(head);

+		delword(tail);

-	close(fd);

 	freebuf(buf);

 	ipop();

+	close(fd);

+static void

+doassign(Word *head, Word *tail, int attr, int override)

+{

+	int set;

+	if(head->next){

+		SYNERR(-1);

+		fprint(2, "multiple vars on left side of assignment\n");

+		Exit();

+	}

+	if(symlook(head->s, S_OVERRIDE, 0)){

+		set = override;

+	} else {

+		set = 1;

+		if(override)

+			symlook(head->s, S_OVERRIDE, 1);

+	}

+	if(set){

+		setvar(head->s, tail);

+		symlook(head->s, S_WESET, 1);

+		tail = 0;	/* don't free */

+	}

+	if(attr)

+		symlook(head->s, S_NOEXPORT, 1);

+	delword(head);

+	delword(tail);

+}

 void

+varoverride(char *line)

+{

+	Word *head, *tail;

+	char *dummy;

+	int attr;

+	head = tail = 0;

+	if(rhead(line, &head, &tail, &attr, &dummy) == '='){

+		doassign(head, tail, attr, 1);

+		return;

+	}

+	delword(head);

+	delword(tail);

+}

+void

 addrules(Word *head, Word *tail, char *body, int attr, int hline, char *prog)

 	Word *w;

@@ -135,6 +158,10 @@

 	int n;

 	Word *w;

+	*h = *t = 0;

+	*attr = 0;

+	*prog = 0;

 	p = charin(line,":=<");

 	if(p == 0)

 		return('?');

@@ -144,8 +171,6 @@

 		sep = '|';

 		p++;

-	*attr = 0;

-	*prog = 0;

 	if(sep == '='){

 		pp = charin(p, termchars);	/* termchars is shell-dependent */

 		if (pp && *pp == '=') {

@@ -195,7 +220,7 @@

 				if (pp == 0 || *pp == 0)

 					goto eos;

 				*pp = 0;

-				*prog = strdup(p);

+				*prog = Strdup(p);

 				*pp = ':';

 				p = pp;

 				break;

@@ -221,7 +246,7 @@

 	*h = w = stow(line);

-	if(*w->s == 0 && sep != '<' && sep != '|') {

+	if(empty(w) && sep != '<' && sep != '|') {

 		SYNERR(mkinline-1);

 		fprint(2, "no var on left side of assignment/rule\n");

 		Exit();

@@ -257,7 +282,7 @@

 			mkinline++;

 	insert(buf, 0);

-	p = strdup(buf->start);

+	p = Strdup(buf->start);

 	freebuf(buf);

 	return p;

@@ -270,40 +295,29 @@

};

 static struct input *inputs = 0;

-void

-ipush(void)

+static void

+ipush(char *file)

-	struct input *in, *me;

+	struct input *i;

-	me = (struct input *)Malloc(sizeof(*me));

-	me->file = infile;

-	me->line = mkinline;

-	me->next = 0;

-	if(inputs == 0)

-		inputs = me;

-	else {

-		for(in = inputs; in->next; )

-			in = in->next;

-		in->next = me;

-	}

+	i = (struct input *)Malloc(sizeof(*i));

+	i->file = mkinfile;

+	i->line = mkinline;

+	i->next = inputs;

+	inputs = i;

+	mkinfile = Strdup(file);

+	mkinline = 1;

-void

+static void

 ipop(void)

-	struct input *in, *me;

+	struct input *i;

-	assert(/*pop input list*/ inputs != 0);

-	if(inputs->next == 0){

-		me = inputs;

-		inputs = 0;

-	} else {

-		for(in = inputs; in->next->next; )

-			in = in->next;

-		me = in->next;

-		in->next = 0;

-	}

-	infile = me->file;

-	mkinline = me->line;

-	free((char *)me);

+	i = inputs;

+	inputs = i->next;

+	mkinfile = i->file;

+	mkinline = i->line;

+	free(i);

--- a/sys/src/cmd/mk/plan9.c

+++ b/sys/src/cmd/mk/plan9.c

@@ -1,7 +1,8 @@

 #include	"mk.h"

-char 	*shell =	"/bin/rc";

-char 	*shellname =	"rc";

+char 	shell[] =	"/bin/rc";

+char 	shellname[] =	"rc";

+char	envdir[] =	"/env/";

 static	Word	*encodenulls(char*, int);

@@ -11,128 +12,119 @@

 	char *p;

 	int envf, f;

 	Dir *e;

-	char nam[1024];

-	int i, n, len;

+	Bufblock *path;

+	int i, n, len, npath;

 	Word *w;

 	rfork(RFENVG);	/*  use copy of the current environment variables */

-	envf = open("/env", OREAD);

+	envf = open(envdir, OREAD);

 	if(envf < 0)

 		return;

+	path = newbuf();

+	bufcpy(path, envdir);

+	npath = path->current - path->start;

 	while((n = dirread(envf, &e)) > 0){

 		for(i = 0; i < n; i++){

-			len = e[i].length;

 				/* don't import funny names, NULL values,

 				 * or internal mk variables

*/

+			len = e[i].length;

 			if(len <= 0 || *shname(e[i].name) != '\0')

 				continue;

 			if (symlook(e[i].name, S_INTERNAL, 0))

 				continue;

-			snprint(nam, sizeof nam, "/env/%s", e[i].name);

-			f = open(nam, OREAD);

+			path->current = path->start + npath;

+			bufcpy(path, e[i].name);

+			insert(path, 0);

+			f = open(path->start, OREAD);

 			if(f < 0)

 				continue;

 			p = Malloc(len+1);

 			if(read(f, p, len) != len){

-				perror(nam);

+				perror(path->start);

 				close(f);

 				continue;

+			p[len] = '\0';

 			close(f);

-			if (p[len-1] == 0)

-				len--;

-			else

-				p[len] = 0;

 			w = encodenulls(p, len);

 			free(p);

-			p = strdup(e[i].name);

-			setvar(p, (void *) w);

-			symlook(p, S_EXPORTED, (void*)"")->u.ptr = "";

+			setvar(e[i].name, w);

 		free(e);

+	freebuf(path);

 	close(envf);

-/* break string of values into words at 01's or nulls*/

 static Word *

 encodenulls(char *s, int n)

-	Word *w, *head;

-	char *cp;

+	Word *head, **link;

+	int m;

-	head = w = 0;

-	while (n-- > 0) {

-		for (cp = s; *cp && *cp != '\0'; cp++)

-				n--;

-		*cp = 0;

-		if (w) {

-			w->next = newword(s);

-			w = w->next;

-		} else

-			head = w = newword(s);

-		s = cp+1;

+	head = 0;

+	link = &head;

+	while(n > 0){

+		m = strlen(s)+1;

+		n -= m;

+		*link = newword(s);

+		s += m;

+		link = &(*link)->next;

-	if (!head)

-		head = newword("");

 	return head;

-/* as well as 01's, change blanks to nulls, so that rc will

- * treat the words as separate arguments

- */

 void

-exportenv(Envy *e)

+exportenv(Symtab **e)

-	int f, n, hasvalue, first;

+	int f, n, npath;

+	Bufblock *path;

 	Word *w;

-	Symtab *sy;

-	char nam[256];

-	for(;e->name; e++){

-		sy = symlook(e->name, S_VAR, 0);

-		if (e->values == 0 || e->values->s == 0 || e->values->s[0] == 0)

-			hasvalue = 0;

-		else

-			hasvalue = 1;

-		if(sy == 0 && !hasvalue)	/* non-existant null symbol */

+	path = newbuf();

+	bufcpy(path, envdir);

+	npath = path->current - path->start;

+	for(;*e; e++){

+		w = (*e)->u.ptr;

+		path->current = path->start + npath;

+		bufcpy(path, (*e)->name);

+		insert(path, 0);

+		if(w == 0){

+			remove(path->start);

 			continue;

-		snprint(nam, sizeof nam, "/env/%s", e->name);

-		if (sy != 0 && !hasvalue) {	/* Remove from environment */

-				/* we could remove it from the symbol table

-				 * too, but we're in the child copy, and it

-				 * would still remain in the parent's table.

-				 */

-			remove(nam);

-			delword(e->values);

-			e->values = 0;		/* memory leak */

-			continue;

-		f = create(nam, OWRITE, 0666L);

+		f = create(path->start, OWRITE, 0666L);

 		if(f < 0) {

-			fprint(2, "can't create %s, f=%d\n", nam, f);

-			perror(nam);

+			fprint(2, "can't create %s\n", path->start);

+			perror(path->start);

 			continue;

-		first = 1;

-		for (w = e->values; w; w = w->next) {

+		if(w->next == 0){

 			n = strlen(w->s);

-			if (n) {

-				if(first)

-					first = 0;

-				else{

-					if (write (f, "\0", 1) != 1)

-						perror(nam);

-				}

-				if (write(f, w->s, n) != n)

-					perror(nam);

-			}

+			if(n == 0) n = 1;

+			if(write(f, w->s, n) != n)

+				perror(path->start);

+		} else {

+			Bufblock *buf = newbuf();

+			do {

+				bufcpy(buf, w->s);

+				insert(buf, 0);

+				w = w->next;

+			} while(w);

+			n = buf->current - buf->start;

+			if(write(f, buf->start, n) != n)

+				perror(path->start);

+			freebuf(buf);

 		close(f);

+	freebuf(path);

int

@@ -156,83 +148,31 @@

int

-execsh(char *args, char *cmd, Bufblock *buf, Envy *e)

+execsh(char *cmd, char *args, Symtab **env, Bufblock *buf)

-	char *p;

-	int tot, n, pid, in[2], out[2];

+	int fd, tot, n, pid;

-	if(buf && pipe(out) < 0){

-		perror("pipe");

-		Exit();

-	}

-	pid = rfork(RFPROC|RFFDG|RFENVG);

-	if(pid < 0){

-		perror("mk rfork");

-		Exit();

-	}

-	if(pid == 0){

-		if(buf)

-			close(out[0]);

-		if(pipe(in) < 0){

-			perror("pipe");

-			Exit();

-		}

-		pid = fork();

-		if(pid < 0){

-			perror("mk fork");

-			Exit();

-		}

-		if(pid != 0){

-			dup(in[0], 0);

-			if(buf){

-				dup(out[1], 1);

-				close(out[1]);

-			}

-			close(in[0]);

-			close(in[1]);

-			if (e)

-				exportenv(e);

-			if(shflags)

-				execl(shell, shellname, shflags, args, nil);

-			else

-				execl(shell, shellname, args, nil);

-			perror(shell);

-			_exits("exec");

-		}

-		if(buf)

-			close(out[1]);

-		close(in[0]);

-		p = cmd+strlen(cmd);

-		while(cmd < p){

-			n = write(in[1], cmd, p-cmd);

-			if(n < 0)

-				break;

-			cmd += n;

-		}

-		close(in[1]);

-		_exits(0);

-	}

+	pid = pipecmd(cmd, args, env, buf? &fd: 0);

 	if(buf){

-		close(out[1]);

 		tot = 0;

 		for(;;){

-			if (buf->current >= buf->end)

+			if(buf->current >= buf->end)

 				growbuf(buf);

-			n = read(out[0], buf->current, buf->end-buf->current);

+			n = read(fd, buf->current, buf->end-buf->current);

 			if(n <= 0)

 				break;

 			buf->current += n;

 			tot += n;

-		if (tot && buf->current[-1] == '\n')

+		if(tot && buf->current[-1] == '\n')

 			buf->current--;

-		close(out[0]);

+		close(fd);

 	return pid;

int

-pipecmd(char *cmd, Envy *e, int *fd)

+pipecmd(char *cmd, char *args, Symtab **env, int *fd)

 	int pid, pfd[2];

@@ -254,18 +194,22 @@

 			dup(pfd[1], 1);

 			close(pfd[1]);

-		if(e)

-			exportenv(e);

-		if(shflags)

-			execl(shell, shellname, shflags, "-c", cmd, nil);

+		if(env)

+			exportenv(env);

+		if(args)

+			execl(shell, shellname, args, "-Ic", cmd, nil);

 		else

-			execl(shell, shellname, "-c", cmd, nil);

+			execl(shell, shellname, "-Ic", cmd, nil);

 		perror(shell);

 		_exits("exec");

 	if(fd){

+		char name[32];

 		close(pfd[1]);

-		*fd = pfd[0];

+		snprint(name, sizeof(name), "/fd/%d", pfd[0]);

+		*fd = open(name, OREAD|OCEXEC);

+		close(pfd[0]);

 	return pid;

@@ -301,15 +245,6 @@

 	atnotify(notifyf, 1);

-char*

-maketmp(void)

-{

-	static char temp[] = "/tmp/mkargXXXXXX";

-	mktemp(temp);

-	return temp;

-}

int

 chgtime(char *name)

@@ -335,7 +270,7 @@

 			p = match->ep;

 			c = *p;

 			*p = 0;

-			*to = strdup(match->sp);

+			*to = Strdup(match->sp);

 			*p = c;

 		else

@@ -344,95 +279,75 @@

 void

-dirtime(char *dir, char *path)

+dirtime(char *dir)

-	int i, fd, n;

-	long mtime;

+	int i, fd, n, npath;

+	Bufblock *path;

+	ulong t;

 	Dir *d;

-	char buf[4096];

-	fd = open(dir, OREAD);

+	if(symlook(dir, S_BULKED, 0))

+		return;

+	symlook(dir, S_BULKED, 1);

+	path = newbuf();

+	bufcpy(path, dir);

+	if(strcmp(dir, ".") == 0)

+		npath = 0;

+	else {

+		insert(path, '/');

+		npath = path->current - path->start;

+	}

+	insert(path, 0);

+	fd = open(path->start, OREAD);

 	if(fd >= 0){

 		while((n = dirread(fd, &d)) > 0){

 			for(i=0; i<n; i++){

-				mtime = d[i].mtime;

+				t = d[i].mtime;

 				/* defensive driving: this does happen */

-				if(mtime == 0)

-					mtime = 1;

-				snprint(buf, sizeof buf, "%s%s", path,

-					d[i].name);

-				if(symlook(buf, S_TIME, 0) == nil)

-					symlook(strdup(buf), S_TIME,

-						(void*)mtime)->u.value = mtime;

+				if(t == 0) t = 1;

+				path->current = path->start + npath;

+				bufcpy(path, d[i].name);

+				insert(path, 0);

+				symlook(path->start, S_TIME, 1)->u.value = t;

 			free(d);

 		close(fd);

+	freebuf(path);

-void

-bulkmtime(char *dir)

-{

-	char buf[4096];

-	char *ss, *s, *sym;

-	if(dir){

-		sym = dir;

-		s = dir;

-		if(strcmp(dir, "/") == 0)

-			strecpy(buf, buf + sizeof buf - 1, dir);

-		else

-			snprint(buf, sizeof buf, "%s/", dir);

-	}else{

-		s = ".";

-		sym = "";

-		buf[0] = 0;

-	}

-	if(symlook(sym, S_BULKED, 0))

-		return;

-	ss = strdup(sym);

-	symlook(ss, S_BULKED, (void*)ss);

-	dirtime(s, buf);

-}

 ulong

 mkmtime(char *name, int force)

-	Dir *d;

-	char *s, *ss, carry;

+	char *a, *s;

 	ulong t;

-	Symtab *sym;

-	char buf[4096];

-	strecpy(buf, buf + sizeof buf - 1, name);

-	cleanname(buf);

-	name = buf;

-	s = utfrrune(name, '/');

-	if(s == name)

-		s++;

+	t = 0;

+	/* cleanname() needs at least 2 characters */

+	a = Malloc(strlen(name)+2+1);

+	strcpy(a, name);

+	cleanname(a);

+	s = utfrrune(a, '/');

 	if(s){

-		ss = name;

-		carry = *s;

 		*s = 0;

+		dirtime(a);

+		*s = '/';

 	}else{

-		ss = 0;

-		carry = 0;

+		dirtime(".");

-	bulkmtime(ss);

-	if(carry)

-		*s = carry;

 	if(!force){

-		sym = symlook(name, S_TIME, 0);

+		Symtab *sym = symlook(a, S_TIME, 0);

 		if(sym)

-			return sym->u.value;

-		return 0;

+			t = sym->u.value;

+	} else {

+		Dir *d = dirstat(a);

+		if(d){

+			t = d->mtime;

+			free(d);

+		}

-	if((d = dirstat(name)) == nil)

-		return 0;

-	t = d->mtime;

-	free(d);

+	free(a);

 	return t;

--- a/sys/src/cmd/mk/rc.c

+++ b/sys/src/cmd/mk/rc.c

@@ -1,8 +1,6 @@

 #include	"mk.h"

-char	*termchars = "'= \t";	/*used in parse.c to isolate assignment attribute*/

-char	*shflags = "-I";	/* rc flag to force non-interactive mode */

-int	IWS = '\1';		/* inter-word separator in env - not used in plan 9 */

+char	termchars[] = "'= \t";	/*used in parse.c to isolate assignment attribute*/

/*

  *	This file contains functions that depend on rc's syntax.  Most

@@ -172,4 +170,41 @@

 			s = copysingle(s, buf);	/* copy quoted string */

 	return s;

+}

+static int

+needquotes(char *s)

+{

+	Rune r;

+	if(*s == 0)

+		return 1;

+	while(*s){

+		s += chartorune(&r, s);

+		if(needsrcquote(r))

+			return 1;

+	}

+	return 0;

+}

+/*

+ *	append string s into buffer buf with rc quoting as neccessary.

+ */

+void

+bufcpyq(Bufblock *buf, char *s)

+{

+	Rune r;

+	if(!needquotes(s)){

+		bufcpy(buf, s);

+		return;

+	}

+	insert(buf, '\'');

+	while(*s){

+		s += chartorune(&r, s);

+		if(r == '\'')

+			rinsert(buf, r);

+		rinsert(buf, r);

+	}

+	insert(buf, '\'');

--- a/sys/src/cmd/mk/recipe.c

+++ b/sys/src/cmd/mk/recipe.c

@@ -9,7 +9,7 @@

 	Node *n;

 	Rule *r = 0;

 	Symtab *s;

-	Word head, ahead, lp, ln, *w, *ww, *aw;

+	Word *head, *ahead, *lp, *ln, *w, **ww, **aw;

 	aa = 0;

/*

@@ -45,13 +45,11 @@

 		build the node list

*/

 	node->next = 0;

-	head.next = 0;

-	ww = &head;

-	ahead.next = 0;

-	aw = &ahead;

+	head = 0, ww = &head;

+	ahead = 0, aw = &ahead;

 	if(r->attr&REGEXP){

-		ww->next = newword(node->name);

-		aw->next = newword(node->name);

+		*ww = newword(node->name);

+		*aw = newword(node->name);

 	} else {

 		for(w = r->alltargets; w; w = w->next){

 			if(r->attr&META)

@@ -58,11 +56,10 @@

 				subst(aa->stem, w->s, buf, sizeof(buf));

 			else

 				strecpy(buf, buf + sizeof buf - 1, w->s);

-			aw->next = newword(buf);

-			aw = aw->next;

+			*aw = newword(buf), aw = &(*aw)->next;

 			if((s = symlook(buf, S_NODE, 0)) == 0)

 				continue;	/* not a node we are interested in */

-			n = s->u.ptr;

+			n = (Node*)s->u.ptr;

 			if(aflag == 0 && n->time) {

 				for(a = n->prereqs; a; a = a->next)

 					if(a->n && outofdate(n, a, 0))

@@ -70,8 +67,7 @@

 				if(a == 0)

 					continue;

-			ww->next = newword(buf);

-			ww = ww->next;

+			*ww = newword(buf), ww = &(*ww)->next;

 			if(n == node) continue;

 			n->next = node->next;

 			node->next = n;

@@ -83,13 +79,13 @@

/*

 		gather the params for the job

*/

-	lp.next = ln.next = 0;

+	lp = ln = 0;

 	for(n = node; n; n = n->next){

 		for(a = n->prereqs; a; a = a->next){

 			if(a->n){

-				addw(&lp, a->n->name);

+				wadd(&lp, a->n->name);

 				if(outofdate(n, a, 0)){

-					addw(&ln, a->n->name);

+					wadd(&ln, a->n->name);

 					if(explain)

 						fprint(1, "%s(%ld) < %s(%ld)\n",

 							n->name, n->time, a->n->name, a->n->time);

@@ -96,25 +92,11 @@

 			} else {

 				if(explain)

-					fprint(1, "%s has no prerequisites\n",

-							n->name);

+					fprint(1, "%s has no prerequisites\n", n->name);

 		MADESET(n, BEINGMADE);

-/*	print("lt=%s ln=%s lp=%s\n",wtos(head.next, ' '),wtos(ln.next, ' '),wtos(lp.next, ' '));/**/

-	run(newjob(r, node, aa->stem, aa->match, lp.next, ln.next, head.next, ahead.next));

+	run(newjob(r, node, aa->stem, aa->match, lp, ln, head, ahead));

 	return(1);

-}

-void

-addw(Word *w, char *s)

-{

-	Word *lw;

-	for(lw = w; w = w->next; lw = w){

-		if(strcmp(s, w->s) == 0)

-			return;

-	}

-	lw->next = newword(s);

--- a/sys/src/cmd/mk/rule.c

+++ b/sys/src/cmd/mk/rule.c

@@ -1,33 +1,33 @@

 #include	"mk.h"

 static Rule *lr, *lmr;

-static rcmp(Rule *r, char *target, Word *tail);

 static int nrules = 0;

 void

-addrule(char *head, Word *tail, char *body, Word *ahead, int attr, int hline, char *prog)

+addrule(char *head, Word *tail, char *body, Word *ahead, int attr, int line, char *prog)

-	Rule *r;

-	Rule *rr;

+	Rule *r, *rr;

 	Symtab *sym;

 	int reuse;

 	r = 0;

 	reuse = 0;

-	if(sym = symlook(head, S_TARGET, 0)){

-		for(r = sym->u.ptr; r; r = r->chain)

-			if(rcmp(r, head, tail) == 0){

+	sym = symlook(head, S_TARGET, 0);

+	if(sym){

+		for(r = sym->u.ptr; r; r = r->chain){

+			if(wcmp(r->tail, tail) == 0){

 				reuse = 1;

 				break;

+		}

 	if(r == 0)

 		r = (Rule *)Malloc(sizeof(Rule));

-	r->target = head;

 	r->tail = tail;

 	r->recipe = body;

-	r->line = hline;

-	r->file = infile;

+	r->line = line;

+	r->file = mkinfile;

 	r->attr = attr;

 	r->alltargets = ahead;

 	r->prog = prog;

@@ -34,15 +34,19 @@

 	r->rule = nrules++;

 	if(!reuse){

-		rr = symlook(head, S_TARGET, r)->u.ptr;

-		if(rr != r){

+		r->next = 0;

+		r->chain = 0;

+		if(sym == 0){

+			sym = symlook(head, S_TARGET, 1);

+			sym->u.ptr = r;

+		} else {

+			rr = sym->u.ptr;

 			r->chain = rr->chain;

 			rr->chain = r;

-		} else

-			r->chain = 0;

+		}

-	if(!reuse)

-		r->next = 0;

+	r->target = sym;

 	if((attr&REGEXP) || charin(head, "%&")){

 		r->attr |= META;

 		if(reuse)

@@ -73,28 +77,19 @@

 void

 dumpr(char *s, Rule *r)

+	char *t;

 	Bprint(&bout, "%s: start=%p\n", s, r);

 	for(; r; r = r->next){

 		Bprint(&bout, "\tRule %p: %s:%d attr=%x next=%p chain=%p alltarget='%s'",

-			r, r->file, r->line, r->attr, r->next, r->chain, wtos(r->alltargets, ' '));

+			r, r->file, r->line, r->attr, r->next, r->chain,

+			t = wtos(r->alltargets)), free(t);

 		if(r->prog)

 			Bprint(&bout, " prog='%s'", r->prog);

-		Bprint(&bout, "\n\ttarget=%s: %s\n", r->target, wtos(r->tail,' '));

+		Bprint(&bout, "\n\ttarget=%s: %s\n", r->target->name,

+			t = wtos(r->tail)), free(t);

 		Bprint(&bout, "\trecipe@%p='%s'\n", r->recipe, r->recipe);

-}

-static int

-rcmp(Rule *r, char *target, Word *tail)

-{

-	Word *w;

-	if(strcmp(r->target, target))

-		return 1;

-	for(w = r->tail; w && tail; w = w->next, tail = tail->next)

-		if(strcmp(w->s, tail->s))

-			return 1;

-	return(w || tail);

 char *

--- a/sys/src/cmd/mk/run.c

+++ b/sys/src/cmd/mk/run.c

@@ -40,12 +40,12 @@

 static void

 sched(void)

-	char *flags;

-	Job *j;

+	char *t, *flags;

 	Bufblock *buf;

-	int slot;

+	Symtab **env;

 	Node *n;

-	Envy *e;

+	Job *j;

+	int slot;

 	if(jobs == 0){

 		usage();

@@ -54,14 +54,16 @@

 	j = jobs;

 	jobs = j->next;

 	if(DEBUG(D_EXEC))

-		fprint(1, "firing up job for target %s\n", wtos(j->t, ' '));

+		fprint(1, "firing up job for target %s\n",

+			t = wtos(j->t)),

+			free(t);

 	slot = nextslot();

 	events[slot].job = j;

 	buf = newbuf();

-	e = buildenv(j, slot);

-	shprint(j->r->recipe, e, buf);

+	env = buildenv(j, slot);

+	shprint(j->r->recipe, buf);

 	if(!tflag && (nflag || !(j->r->attr&QUIET)))

-		Bwrite(&bout, buf->start, (long)strlen(buf->start));

+		Bwrite(&bout, buf->start, strlen(buf->start));

 	freebuf(buf);

 	if(nflag||tflag){

 		for(n = j->n; n; n = n->next){

@@ -82,11 +84,13 @@

 			flags = 0;

 		else

 			flags = "-e";

-		events[slot].pid = execsh(flags, j->r->recipe, 0, e);

+		events[slot].pid = execsh(j->r->recipe, flags, env, 0);

 		usage();

 		nrunning++;

 		if(DEBUG(D_EXEC))

-			fprint(1, "pid for target %s = %d\n", wtos(j->t, ' '), events[slot].pid);

+			fprint(1, "pid for target %s = %d\n",

+				t = wtos(j->t), events[slot].pid),

+				free(t);

@@ -93,7 +97,6 @@

int

 waitup(int echildok, int *retstatus)

-	Envy *e;

 	int pid;

 	int slot;

 	Symtab *s;

@@ -140,13 +143,14 @@

 		goto again;

 	j = events[slot].job;

+	events[slot].job = 0;

+	events[slot].pid = -1;

 	usage();

 	nrunning--;

-	events[slot].pid = -1;

 	if(buf[0]){

-		e = buildenv(j, slot);

+		buildenv(j, slot);

 		bp = newbuf();

-		shprint(j->r->recipe, e, bp);

+		shprint(j->r->recipe, bp);

 		front(bp->start);

 		fprint(2, "mk: %s: exit status=%s", bp->start, buf);

 		freebuf(bp);

@@ -169,8 +173,9 @@

 	for(w = j->t; w; w = w->next){

 		if((s = symlook(w->s, S_NODE, 0)) == 0)

 			continue;	/* not interested in this node */

-		update(uarg, s->u.ptr);

+		update(uarg, (Node*)s->u.ptr);

+	freejob(j);

 	if(nrunning < nproclimit)

 		sched();

 	return(0);

@@ -179,14 +184,10 @@

 void

 nproc(void)

-	Symtab *sym;

 	Word *w;

-	if(sym = symlook("NPROC", S_VAR, 0)) {

-		w = sym->u.ptr;

-		if (w && w->s && w->s[0])

-			nproclimit = atoi(w->s);

-	}

+	if(!empty(w = getvar("NPROC")))

+		nproclimit = atoi(w->s);

 	if(nproclimit < 1)

 		nproclimit = 1;

 	if(DEBUG(D_EXEC))

@@ -193,7 +194,7 @@

 		fprint(1, "nprocs = %d\n", nproclimit);

 	if(nproclimit > nevents){

 		if(nevents)

-			events = (Event *)Realloc((char *)events, nproclimit*sizeof(Event));

+			events = (Event *)Realloc(events, nproclimit*sizeof(Event));

 		else

 			events = (Event *)Malloc(nproclimit*sizeof(Event));

 		while(nevents < nproclimit)

@@ -281,7 +282,7 @@

 	long t;

 	time(&t);

-	if(tick)

+	if(tick && nrunning < nelem(tslot))

 		tslot[nrunning] += (t-tick);

 	tick = t;

@@ -292,6 +293,6 @@

 	int i;

 	usage();

-	for(i = 0; i <= nevents; i++)

+	for(i = 0; i <= nevents && i < nelem(tslot); i++)

 		fprint(1, "%d: %ld\n", i, tslot[i]);

--- a/sys/src/cmd/mk/shprint.c

+++ b/sys/src/cmd/mk/shprint.c

@@ -1,9 +1,9 @@

 #include	"mk.h"

-static char *vexpand(char*, Envy*, Bufblock*);

+static char *vexpand(char*, Bufblock*);

 void

-shprint(char *s, Envy *env, Bufblock *buf)

+shprint(char *s, Bufblock *buf)

 	int n;

 	Rune r;

@@ -11,7 +11,7 @@

 	while(*s) {

 		n = chartorune(&r, s);

 		if (r == '$')

-			s = vexpand(s, env, buf);

+			s = vexpand(s, buf);

 		else {

 			rinsert(buf, r);

 			s += n;

@@ -21,25 +21,26 @@

 	insert(buf, 0);

-static char *

-mygetenv(char *name, Envy *env)

+static Symtab*

+mygetenv(char *name)

-	if (!env)

-		return 0;

-	if (symlook(name, S_WESET, 0) == 0 && symlook(name, S_INTERNAL, 0) == 0)

-		return 0;

-		/* only resolve internal variables and variables we've set */

-	for(; env->name; env++){

-		if (strcmp(env->name, name) == 0)

-			return wtos(env->values, ' ');

+	Symtab *s;

+	/* only resolve internal variables and variables we've set */

+	s = symlook(name, S_INTERNAL, 0);

+	if(s == 0){

+		s = symlook(name, S_VAR, 0);

+		if(s == 0 || !symlook(name, S_WESET, 0))

+			return  0;

-	return 0;

+	return s;

 static char *

-vexpand(char *w, Envy *env, Bufblock *buf)

+vexpand(char *w, Bufblock *buf)

-	char *s, carry, *p, *q;

+	char carry, *p, *q;

+	Symtab *s;

 	assert(/*vexpand no $*/ *w == '$');

 	p = w+1;	/* skip dollar sign */

@@ -52,15 +53,14 @@

 		q = shname(p);

 	carry = *q;

 	*q = 0;

-	s = mygetenv(p, env);

+	s = mygetenv(p);

 	*q = carry;

 	if (carry == '}')

 		q++;

-	if (s) {

-		bufcpy(buf, s, strlen(s));

-		free(s);

-	} else 		/* copy name intact*/

-		bufcpy(buf, w, q-w);

+	if(s)

+		bufcpyw(buf, s->u.ptr);

+	else 		/* copy $name intact */

+		bufncpy(buf, w, q-w);

 	return(q);

@@ -71,7 +71,7 @@

 	int i, j;

 	char *flds[512];

-	q = strdup(s);

+	q = Strdup(s);

 	i = getfields(q, flds, nelem(flds), 0, " \t\n");

 	if(i > 5){

 		flds[4] = flds[i-1];

--- a/sys/src/cmd/mk/symtab.c

+++ b/sys/src/cmd/mk/symtab.c

@@ -5,7 +5,7 @@

 static Symtab *hash[NHASH];

 Symtab *

-symlook(char *sym, int space, void *install)

+symlook(char *sym, int space, int install)

 	long h;

 	char *p;

@@ -17,17 +17,17 @@

 		h = ~h;

 	h %= NHASH;

 	for(s = hash[h]; s; s = s->next)

-		if((s->space == space) && (strcmp(s->name, sym) == 0))

-			return(s);

+		if(s->space == space && strcmp(s->name, sym) == 0)

+			return s;

 	if(install == 0)

-		return(0);

-	s = (Symtab *)Malloc(sizeof(Symtab));

+		return 0;

+	s = (Symtab *)Malloc(sizeof(Symtab) + (++p - sym));

 	s->space = space;

-	s->name = sym;

-	s->u.ptr = install;

+	s->u.ptr = 0;

+	memcpy(s->name, sym, p - sym);

 	s->next = hash[h];

 	hash[h] = s;

-	return(s);

+	return s;

 void

--- a/sys/src/cmd/mk/var.c

+++ b/sys/src/cmd/mk/var.c

@@ -1,10 +1,20 @@

 #include	"mk.h"

+Word*

+getvar(char *name)

+{

+	Symtab *sym = symlook(name, S_VAR, 0);

+	if(sym)

+		return sym->u.ptr;

+	return 0;

+}

 void

-setvar(char *name, void *value)

+setvar(char *name, Word *value)

-	symlook(name, S_VAR, value)->u.ptr = value;

-	symlook(name, S_MAKEVAR, (void*)"");

+	Symtab *sym = symlook(name, S_VAR, 1);

+	delword(sym->u.ptr);

+	sym->u.ptr = value;

 static void

--- a/sys/src/cmd/mk/varsub.c

+++ b/sys/src/cmd/mk/varsub.c

@@ -5,7 +5,6 @@

 static	Bufblock	*varname(char**);

 static	Word		*extractpat(char*, char**, char*, char*);

 static	int		submatch(char*, Word*, Word*, int*, char**);

-static	Word		*varmatch(char *);

 Word *

 varsub(char **s)

@@ -15,14 +14,12 @@

 	if(**s == '{')		/* either ${name} or ${name: A%B==C%D}*/

 		return expandvar(s);

 	b = varname(s);

 	if(b == 0)

 		return 0;

-	w = varmatch(b->start);

+	w = getvar(b->start);

 	freebuf(b);

-	return w;

+	return wdup(w);

/*

@@ -45,7 +42,7 @@

 		rinsert(b, r);

 		cp += n;

-	if (b->current == b->start){

+	if(b->current == b->start){

 		SYNERR(-1);

 		fprint(2, "missing variable name <%s>\n", *s);

 		freebuf(b);

@@ -57,42 +54,25 @@

 static Word*

-varmatch(char *name)

-{

-	Word *w;

-	Symtab *sym;

-	sym = symlook(name, S_VAR, 0);

-	if(sym){

-			/* check for at least one non-NULL value */

-		for (w = sym->u.ptr; w; w = w->next)

-			if(w->s && *w->s)

-				return wdup(w);

-	}

-	return 0;

-}

-static Word*

 expandvar(char **s)

 	Word *w;

 	Bufblock *buf;

-	Symtab *sym;

 	char *cp, *begin, *end;

 	begin = *s;

 	(*s)++;						/* skip the '{' */

 	buf = varname(s);

-	if (buf == 0)

+	if(buf == 0)

 		return 0;

 	cp = *s;

-	if (*cp == '}') {				/* ${name} variant*/

+	if(*cp == '}') {				/* ${name} variant*/

 		(*s)++;					/* skip the '}' */

-		w = varmatch(buf->start);

+		w = getvar(buf->start);

 		freebuf(buf);

-		return w;

+		return wdup(w);

-	if (*cp != ':') {

+	if(*cp != ':') {

 		SYNERR(-1);

 		fprint(2, "bad variable name <%s>\n", buf->start);

 		freebuf(buf);

@@ -99,7 +79,7 @@

 		return 0;

 	cp++;

-	end = charin(cp , "}");

+	end = charin(cp, "}");

 	if(end == 0){

 		SYNERR(-1);

 		fprint(2, "missing '}': %s\n", begin);

@@ -107,13 +87,10 @@

 	*end = 0;

 	*s = end+1;

-	sym = symlook(buf->start, S_VAR, 0);

-	if(sym == 0 || sym->u.value == 0)

-		w = newword(buf->start);

-	else

-		w = subsub(sym->u.ptr, cp, end);

+	w = getvar(buf->start);

 	freebuf(buf);

+	if(w)

+		w = subsub(w, cp, end);

 	return w;

@@ -120,8 +97,7 @@

 static Word*

 extractpat(char *s, char **r, char *term, char *end)

-	int save;

-	char *cp;

+	char save, *cp;

 	Word *w;

 	cp = charin(s, term);

@@ -144,7 +120,7 @@

 subsub(Word *v, char *s, char *end)

 	int nmid;

-	Word *head, *tail, *w, *h;

+	Word *head, *tail, *w, *h, **l;

 	Word *a, *b, *c, *d;

 	Bufblock *buf;

 	char *cp, *enda;

@@ -164,47 +140,52 @@

 	buf = newbuf();

 	for(; v; v = v->next){

 		h = w = 0;

+		l = &h;

 		if(submatch(v->s, a, b, &nmid, &enda)){

 			/* enda points to end of A match in source;

 			 * nmid = number of chars between end of A and start of B

*/

 			if(c){

-				h = w = wdup(c);

-				while(w->next)

+				*l = w = wdup(c);

+				while(w->next){

+					l = &w->next;

 					w = w->next;

+				}

 			if(PERCENT(*cp) && nmid > 0){

 				if(w){

-					bufcpy(buf, w->s, strlen(w->s));

-					bufcpy(buf, enda, nmid);

+					bufcpy(buf, w->s);

+					bufncpy(buf, enda, nmid);

 					insert(buf, 0);

-					free(w->s);

-					w->s = strdup(buf->start);

+					delword(w);

+					*l = w = newword(buf->start);

 				} else {

-					bufcpy(buf, enda, nmid);

+					bufncpy(buf, enda, nmid);

 					insert(buf, 0);

-					h = w = newword(buf->start);

+					*l = w = newword(buf->start);

 				buf->current = buf->start;

-			if(d && *d->s){

+			if(!empty(d)){

 				if(w){

-					bufcpy(buf, w->s, strlen(w->s));

-					bufcpy(buf, d->s, strlen(d->s));

+					bufcpy(buf, w->s);

+					bufcpy(buf, d->s);

 					insert(buf, 0);

-					free(w->s);

-					w->s = strdup(buf->start);

+					delword(w);

+					*l = w = newword(buf->start);

 					w->next = wdup(d->next);

-					while(w->next)

-						w = w->next;

 					buf->current = buf->start;

-				} else

-					h = w = wdup(d);

+				} else {

+					*l = w = wdup(d);

+				}

+				while(w->next){

+					l = &w->next;

+					w = w->next;

+				}

 		if(w == 0)

-			h = w = newword(v->s);

+			*l = w = newword(v->s);

 		if(head == 0)

 			head = h;

@@ -223,9 +204,9 @@

 static int

 submatch(char *s, Word *a, Word *b, int *nmid, char **enda)

+	char *end;

 	Word *w;

 	int n;

-	char *end;

 	n = 0;

 	for(w = a; w; w = w->next){

--- a/sys/src/cmd/mk/word.c

+++ b/sys/src/cmd/mk/word.c

@@ -5,85 +5,109 @@

 Word*

 newword(char *s)

-	Word *w;

-	w = (Word *)Malloc(sizeof(Word));

-	w->s = strdup(s);

+	int n = strlen(s)+1;

+	Word *w = (Word *)Malloc(sizeof(Word) + n);

+	memcpy(w->s, s, n);

 	w->next = 0;

-	return(w);

+	return w;

+Word*

+popword(Word *w)

+{

+	Word *x = w->next;

+	free(w);

+	return x;

+}

 Word *

 stow(char *s)

-	Word *head, *w, *new;

+	Word *w, *h, **l;

-	w = head = 0;

-	while(*s){

-		new = nextword(&s);

-		if(new == 0)

-			break;

-		if (w)

-			w->next = new;

-		else

-			head = w = new;

+	h = 0;

+	l = &h;

+	while(*s && (*l = w = nextword(&s))){

 		while(w->next)

 			w = w->next;

+		l = &w->next;

-	if (!head)

-		head = newword("");

-	return(head);

+	return h;

 char *

-wtos(Word *w, int sep)

+wtos(Word *w)

 	Bufblock *buf;

-	char *cp;

+	char *s;

 	buf = newbuf();

+	bufcpyw(buf, w);

+	insert(buf, 0);

+	s = Strdup(buf->start);

+	freebuf(buf);

+	return s;

+}

+void

+bufcpyw(Bufblock *buf, Word *w)

+{

 	for(; w; w = w->next){

-		for(cp = w->s; *cp; cp++)

-			insert(buf, *cp);

+		bufcpyq(buf, w->s);

 		if(w->next)

-			insert(buf, sep);

+			insert(buf, ' ');

-	insert(buf, 0);

-	cp = strdup(buf->start);

-	freebuf(buf);

-	return(cp);

+int

+empty(Word *w)

+{

+	return w == 0 || w->s[0] == 0;

+}

+int

+wadd(Word **l, char *s)

+{

+	Word *w;

+	while(w = *l){

+		if(strcmp(w->s, s) == 0)

+			return 1;

+		l = &w->next;

+	}

+	*l = newword(s);

+	return 0;

+}

+int

+wcmp(Word *a, Word *b)

+{

+	for(; a && b; a = a->next, b = b->next)

+		if(strcmp(a->s, b->s))

+			return 1;

+	return(a || b);

+}

 Word*

 wdup(Word *w)

-	Word *v, *new, *base;

+	Word *h, **l;

-	v = base = 0;

+	h = 0;

+	l = &h;

 	while(w){

-		new = newword(w->s);

-		if(v)

-			v->next = new;

-		else

-			base = new;

-		v = new;

+		*l = newword(w->s);

+		l = &(*l)->next;

 		w = w->next;

-	return base;

+	return h;

 void

 delword(Word *w)

-	Word *v;

-	while(v = w){

-		w = w->next;

-		if(v->s)

-			free(v->s);

-		free(v);

-	}

+	while(w)

+		w = popword(w);

/*

@@ -93,19 +117,20 @@

 static Word*

 nextword(char **s)

+	Word *head, *tail, **link, *w, *t;

 	Bufblock *b;

-	Word *head, *tail, *w;

-	Rune r;

-	char *cp;

 	int empty;

+	char *cp;

+	Rune r;

 	cp = *s;

 	b = newbuf();

-restart:

+	empty = 1;

 	head = tail = 0;

+	link = &head;

+restart:

 	while(*cp == ' ' || *cp == '\t')		/* leading white space */

 		cp++;

-	empty = 1;

 	while(*cp){

 		cp += chartorune(&r, cp);

 		switch(r)

@@ -117,12 +142,12 @@

 		case '\\':

 		case '\'':

 		case '"':

-			empty = 0;

 			cp = expandquote(cp, r, b);

 			if(cp == 0){

 				fprint(2, "missing closing quote: %s\n", *s);

 				Exit();

+			empty = 0;

 			break;

 		case '$':

 			w = varsub(&cp);

@@ -133,29 +158,29 @@

 			empty = 0;

 			if(b->current != b->start){

-				bufcpy(b, w->s, strlen(w->s));

+				bufcpy(b, w->s);

 				insert(b, 0);

-				free(w->s);

-				w->s = strdup(b->start);

+				t = popword(w);

+				w = newword(b->start);

+				w->next = t;

 				b->current = b->start;

-			if(head){

-				bufcpy(b, tail->s, strlen(tail->s));

-				bufcpy(b, w->s, strlen(w->s));

+			if(tail){

+				bufcpy(b, tail->s);

+				bufcpy(b, w->s);

 				insert(b, 0);

-				free(tail->s);

-				tail->s = strdup(b->start);

-				tail->next = w->next;

-				free(w->s);

-				free(w);

+				delword(tail);

+				*link = tail = newword(b->start);

+				tail->next = popword(w);

 				b->current = b->start;

 			} else

-				tail = head = w;

-			while(tail->next)

+				*link = tail = w;

+			while(tail->next){

+				link = &tail->next;

 				tail = tail->next;

+			}

 			break;

 		default:

-			empty = 0;

 			rinsert(b, r);

 			break;

@@ -162,18 +187,19 @@

 out:

 	*s = cp;

-	if(b->current != b->start){

-		if(head){

-			cp = b->current;

-			bufcpy(b, tail->s, strlen(tail->s));

-			bufcpy(b, b->start, cp-b->start);

+	if(b->current != b->start || !empty){

+		insert(b, 0);

+		if(tail){

+			cp = Strdup(b->start);

+			b->current = b->start;

+			bufcpy(b, tail->s);

+			bufcpy(b, cp);

+			free(cp);

 			insert(b, 0);

-			free(tail->s);

-			tail->s = strdup(cp);

-		} else {

-			insert(b, 0);

-			head = newword(b->start);

-		}

+			delword(tail);

+			*link = newword(b->start);

+		} else

+			*link = newword(b->start);

 	freebuf(b);

 	return head;

code: plan9front