op public repos

Blob

Date:: Tue May 5 03:41:15 2020 UTC
Message:: rc: add recursive descent parser The old yacc-based parser is available with the -Y flag, which will probably be removed at some point. The new -D flag dumps a parse tree of the input, without executing it. This allows comparing the output of rc -D and rc -DY on different scripts to see that the two parsers behave the same. The rc paper ends by saying: It is remarkable that in the four most recent editions of the UNIX system programmer’s manual the Bourne shell grammar described in the manual page does not admit the command who|wc. This is surely an oversight, but it suggests something darker: nobody really knows what the Bourne shell’s grammar is. Even examination of the source code is little help. The parser is implemented by recursive descent, but the routines corresponding to the syntactic categories all have a flag argument that subtly changes their operation depending on the context. Rc’s parser is implemented using yacc, so I can say precisely what the grammar is. The new recursive descent parser here has no such flags. It is a straightforward translation of the yacc. The new parser will make it easier to handle free carats in more generality as well as potentially allow the use of unquoted = as a word character. Going through this exercise has highlighted a few dark corners here as well. For example, I was surprised to find that x >f | y >f x | y are different commands (the latter redirects y's output). It is similarly surprising that a=b x | y sets a during the execution of y. It is also a bit counter-intuitive x | y | z x | if(c) y | z are not both 3-phase pipelines. These are certainly not things we should change, but they are not entirely obvious from the man page description, undercutting the quoted claim a bit. On the other hand, who | wc is clearly accepted by the grammar in the manual page, and the new parser still handles that test case.
Actions:: History | Blame | Raw File
1 #include "rc.h"
2 #include "getflags.h"
3 #include "exec.h"
4 #include "io.h"
5 #include "fns.h"
6 /*
7  * Start executing the given code at the given pc with the given redirection
8  */
9 char *argv0="rc";
10 
11 void
12 start(code *c, int pc, var *local)
13 {
14 	struct thread *p = new(struct thread);
15 
16 	p->code = codecopy(c);
17 	p->pc = pc;
18 	p->argv = 0;
19 	p->redir = p->startredir = runq?runq->redir:0;
20 	p->local = local;
21 	p->cmdfile = 0;
22 	p->cmdfd = 0;
23 	p->eof = 0;
24 	p->iflag = 0;
25 	p->lineno = 1;
26 	p->ret = runq;
27 	runq = p;
28 }
29 
30 word*
31 newword(char *wd, word *next)
32 {
33 	word *p = new(word);
34 	p->word = strdup(wd);
35 	p->next = next;
36 	return p;
37 }
38 
39 void
40 pushword(char *wd)
41 {
42 	if(runq->argv==0)
43 		panic("pushword but no argv!", 0);
44 	runq->argv->words = newword(wd, runq->argv->words);
45 }
46 
47 void
48 popword(void)
49 {
50 	word *p;
51 	if(runq->argv==0)
52 		panic("popword but no argv!", 0);
53 	p = runq->argv->words;
54 	if(p==0)
55 		panic("popword but no word!", 0);
56 	runq->argv->words = p->next;
57 	efree(p->word);
58 	efree((char *)p);
59 }
60 
61 void
62 freelist(word *w)
63 {
64 	word *nw;
65 	while(w){
66 		nw = w->next;
67 		efree(w->word);
68 		efree((char *)w);
69 		w = nw;
70 	}
71 }
72 
73 void
74 pushlist(void)
75 {
76 	list *p = new(list);
77 	p->next = runq->argv;
78 	p->words = 0;
79 	runq->argv = p;
80 }
81 
82 void
83 poplist(void)
84 {
85 	list *p = runq->argv;
86 	if(p==0)
87 		panic("poplist but no argv", 0);
88 	freelist(p->words);
89 	runq->argv = p->next;
90 	efree((char *)p);
91 }
92 
93 int
94 count(word *w)
95 {
96 	int n;
97 	for(n = 0;w;n++) w = w->next;
98 	return n;
99 }
100 
101 void
102 pushredir(int type, int from, int to)
103 {
104 	redir * rp = new(redir);
105 	rp->type = type;
106 	rp->from = from;
107 	rp->to = to;
108 	rp->next = runq->redir;
109 	runq->redir = rp;
110 }
111 
112 var*
113 newvar(char *name, var *next)
114 {
115 	var *v = new(var);
116 	v->name = name;
117 	v->val = 0;
118 	v->fn = 0;
119 	v->changed = 0;
120 	v->fnchanged = 0;
121 	v->next = next;
122 	v->changefn = 0;
123 	return v;
124 }
125 /*
126  * get command line flags, initialize keywords & traps.
127  * get values from environment.
128  * set $pid, $cflag, $*
129  * fabricate bootstrap code and start it (*=(argv);. /usr/lib/rcmain $*)
130  * start interpreting code
131  */
132 int
133 main(int argc, char *argv[])
134 {
135 	code bootstrap[32];
136 	char num[12], *rcmain;
137 	int i;
138 
139 	/* needed for rcmain later */
140 	putenv("PLAN9", unsharp("#9"));
141 
142 	argc = getflags(argc, argv, "DSYsrdiIlxepvVc:1m:1[command]", 1);
143 	if(argc==-1)
144 		usage("[file [arg ...]]");
145 	if(argv[0][0]=='-')
146 		flag['l'] = flagset;
147 	if(flag['I'])
148 		flag['i'] = 0;
149 	else if(flag['i']==0 && argc==1 && Isatty(0)) flag['i'] = flagset;
150 	rcmain = flag['m'] ? flag['m'][0] : Rcmain();
151 	err = openfd(2);
152 	kinit();
153 	Trapinit();
154 	Vinit();
155 	inttoascii(num, mypid = getpid());
156 	pathinit();
157 	setvar("pid", newword(num, (word *)0));
158 	setvar("cflag", flag['c']?newword(flag['c'][0], (word *)0)
159 				:(word *)0);
160 	setvar("rcname", newword(argv[0], (word *)0));
161 	i = 0;
162 	bootstrap[i++].i = 1;
163 	bootstrap[i++].f = Xmark;
164 	bootstrap[i++].f = Xword;
165 	bootstrap[i++].s="*";
166 	bootstrap[i++].f = Xassign;
167 	bootstrap[i++].f = Xmark;
168 	bootstrap[i++].f = Xmark;
169 	bootstrap[i++].f = Xword;
170 	bootstrap[i++].s="*";
171 	bootstrap[i++].f = Xdol;
172 	bootstrap[i++].f = Xword;
173 	bootstrap[i++].s = rcmain;
174 	bootstrap[i++].f = Xword;
175 	bootstrap[i++].s=".";
176 	bootstrap[i++].f = Xsimple;
177 	bootstrap[i++].f = Xexit;
178 	bootstrap[i].i = 0;
179 	start(bootstrap, 1, (var *)0);
180 	/* prime bootstrap argv */
181 	pushlist();
182 	argv0 = strdup(argv[0]);
183 	for(i = argc-1;i!=0;--i) pushword(argv[i]);
184 	for(;;){
185 		if(flag['r'])
186 			pfnc(err, runq);
187 		runq->pc++;
188 		(*runq->code[runq->pc-1].f)();
189 		if(ntrap)
190 			dotrap();
191 	}
192 	return 0;  /* not reached; silence OS X Lion gcc */
193 }
194 /*
195  * Opcode routines
196  * Arguments on stack (...)
197  * Arguments in line [...]
198  * Code in line with jump around {...}
199  *
200  * Xappend(file)[fd]			open file to append
201  * Xassign(name, val)			assign val to name
202  * Xasync{... Xexit}			make thread for {}, no wait
203  * Xbackq{... Xreturn}			make thread for {}, push stdout
204  * Xbang				complement condition
205  * Xcase(pat, value){...}		exec code on match, leave (value) on
206  * 					stack
207  * Xclose[i]				close file descriptor
208  * Xconc(left, right)			concatenate, push results
209  * Xcount(name)				push var count
210  * Xdelfn(name)				delete function definition
211  * Xdeltraps(names)			delete named traps
212  * Xdol(name)				get variable value
213  * Xqdol(name)				concatenate variable components
214  * Xdup[i j]				dup file descriptor
215  * Xexit				rc exits with status
216  * Xfalse{...}				execute {} if false
217  * Xfn(name){... Xreturn}			define function
218  * Xfor(var, list){... Xreturn}		for loop
219  * Xjump[addr]				goto
220  * Xlocal(name, val)			create local variable, assign value
221  * Xmark				mark stack
222  * Xmatch(pat, str)			match pattern, set status
223  * Xpipe[i j]{... Xreturn}{... Xreturn}	construct a pipe between 2 new threads,
224  * 					wait for both
225  * Xpipefd[type]{... Xreturn}		connect {} to pipe (input or output,
226  * 					depending on type), push /dev/fd/??
227  * Xpopm(value)				pop value from stack
228  * Xrdwr(file)[fd]			open file for reading and writing
229  * Xread(file)[fd]			open file to read
230  * Xsettraps(names){... Xreturn}		define trap functions
231  * Xshowtraps				print trap list
232  * Xsimple(args)			run command and wait
233  * Xreturn				kill thread
234  * Xsubshell{... Xexit}			execute {} in a subshell and wait
235  * Xtrue{...}				execute {} if true
236  * Xunlocal				delete local variable
237  * Xword[string]			push string
238  * Xwrite(file)[fd]			open file to write
239  */
240 
241 void
242 Xappend(void)
243 {
244 	char *file;
245 	int f;
246 	switch(count(runq->argv->words)){
247 	default:
248 		Xerror1(">> requires singleton");
249 		return;
250 	case 0:
251 		Xerror1(">> requires file");
252 		return;
253 	case 1:
254 		break;
255 	}
256 	file = runq->argv->words->word;
257 	if((f = open(file, 1))<0 && (f = Creat(file))<0){
258 		pfmt(err, "%s: ", file);
259 		Xerror("can't open");
260 		return;
261 	}
262 	Seek(f, 0L, 2);
263 	pushredir(ROPEN, f, runq->code[runq->pc].i);
264 	runq->pc++;
265 	poplist();
266 }
267 
268 void
269 Xsettrue(void)
270 {
271 	setstatus("");
272 }
273 
274 void
275 Xbang(void)
276 {
277 	setstatus(truestatus()?"false":"");
278 }
279 
280 void
281 Xclose(void)
282 {
283 	pushredir(RCLOSE, runq->code[runq->pc].i, 0);
284 	runq->pc++;
285 }
286 
287 void
288 Xdup(void)
289 {
290 	pushredir(RDUP, runq->code[runq->pc].i, runq->code[runq->pc+1].i);
291 	runq->pc+=2;
292 }
293 
294 void
295 Xeflag(void)
296 {
297 	if(eflagok && !truestatus()) Xexit();
298 }
299 
300 void
301 Xexit(void)
302 {
303 	struct var *trapreq;
304 	struct word *starval;
305 	static int beenhere = 0;
306 	if(getpid()==mypid && !beenhere){
307 		trapreq = vlook("sigexit");
308 		if(trapreq->fn){
309 			beenhere = 1;
310 			--runq->pc;
311 			starval = vlook("*")->val;
312 			start(trapreq->fn, trapreq->pc, (struct var *)0);
313 			runq->local = newvar(strdup("*"), runq->local);
314 			runq->local->val = copywords(starval, (struct word *)0);
315 			runq->local->changed = 1;
316 			runq->redir = runq->startredir = 0;
317 			return;
318 		}
319 	}
320 	Exit(getstatus());
321 }
322 
323 void
324 Xfalse(void)
325 {
326 	if(truestatus()) runq->pc = runq->code[runq->pc].i;
327 	else runq->pc++;
328 }
329 int ifnot;		/* dynamic if not flag */
330 
331 void
332 Xifnot(void)
333 {
334 	if(ifnot)
335 		runq->pc++;
336 	else
337 		runq->pc = runq->code[runq->pc].i;
338 }
339 
340 void
341 Xjump(void)
342 {
343 	runq->pc = runq->code[runq->pc].i;
344 }
345 
346 void
347 Xmark(void)
348 {
349 	pushlist();
350 }
351 
352 void
353 Xpopm(void)
354 {
355 	poplist();
356 }
357 
358 void
359 Xread(void)
360 {
361 	char *file;
362 	int f;
363 	switch(count(runq->argv->words)){
364 	default:
365 		Xerror1("< requires singleton\n");
366 		return;
367 	case 0:
368 		Xerror1("< requires file\n");
369 		return;
370 	case 1:
371 		break;
372 	}
373 	file = runq->argv->words->word;
374 	if((f = open(file, 0))<0){
375 		pfmt(err, "%s: ", file);
376 		Xerror("can't open");
377 		return;
378 	}
379 	pushredir(ROPEN, f, runq->code[runq->pc].i);
380 	runq->pc++;
381 	poplist();
382 }
383 
384 void
385 Xrdwr(void)
386 {
387 	char *file;
388 	int f;
389 
390 	switch(count(runq->argv->words)){
391 	default:
392 		Xerror1("<> requires singleton\n");
393 		return;
394 	case 0:
395 		Xerror1("<> requires file\n");
396 		return;
397 	case 1:
398 		break;
399 	}
400 	file = runq->argv->words->word;
401 	if((f = open(file, ORDWR))<0){
402 		pfmt(err, "%s: ", file);
403 		Xerror("can't open");
404 		return;
405 	}
406 	pushredir(ROPEN, f, runq->code[runq->pc].i);
407 	runq->pc++;
408 	poplist();
409 }
410 
411 void
412 turfredir(void)
413 {
414 	while(runq->redir!=runq->startredir)
415 		Xpopredir();
416 }
417 
418 void
419 Xpopredir(void)
420 {
421 	struct redir *rp = runq->redir;
422 	if(rp==0)
423 		panic("turfredir null!", 0);
424 	runq->redir = rp->next;
425 	if(rp->type==ROPEN)
426 		close(rp->from);
427 	efree((char *)rp);
428 }
429 
430 void
431 Xreturn(void)
432 {
433 	struct thread *p = runq;
434 	turfredir();
435 	while(p->argv) poplist();
436 	codefree(p->code);
437 	runq = p->ret;
438 	efree((char *)p);
439 	if(runq==0)
440 		Exit(getstatus());
441 }
442 
443 void
444 Xtrue(void)
445 {
446 	if(truestatus()) runq->pc++;
447 	else runq->pc = runq->code[runq->pc].i;
448 }
449 
450 void
451 Xif(void)
452 {
453 	ifnot = 1;
454 	if(truestatus()) runq->pc++;
455 	else runq->pc = runq->code[runq->pc].i;
456 }
457 
458 void
459 Xwastrue(void)
460 {
461 	ifnot = 0;
462 }
463 
464 void
465 Xword(void)
466 {
467 	pushword(runq->code[runq->pc++].s);
468 }
469 
470 void
471 Xwrite(void)
472 {
473 	char *file;
474 	int f;
475 	switch(count(runq->argv->words)){
476 	default:
477 		Xerror1("> requires singleton\n");
478 		return;
479 	case 0:
480 		Xerror1("> requires file\n");
481 		return;
482 	case 1:
483 		break;
484 	}
485 	file = runq->argv->words->word;
486 	if((f = Creat(file))<0){
487 		pfmt(err, "%s: ", file);
488 		Xerror("can't open");
489 		return;
490 	}
491 	pushredir(ROPEN, f, runq->code[runq->pc].i);
492 	runq->pc++;
493 	poplist();
494 }
495 
496 char*
497 list2str(word *words)
498 {
499 	char *value, *s, *t;
500 	int len = 0;
501 	word *ap;
502 	for(ap = words;ap;ap = ap->next)
503 		len+=1+strlen(ap->word);
504 	value = emalloc(len+1);
505 	s = value;
506 	for(ap = words;ap;ap = ap->next){
507 		for(t = ap->word;*t;) *s++=*t++;
508 		*s++=' ';
509 	}
510 	if(s==value)
511 		*s='\0';
512 	else s[-1]='\0';
513 	return value;
514 }
515 
516 void
517 Xmatch(void)
518 {
519 	word *p;
520 	char *subject;
521 	subject = list2str(runq->argv->words);
522 	setstatus("no match");
523 	for(p = runq->argv->next->words;p;p = p->next)
524 		if(match(subject, p->word, '\0')){
525 			setstatus("");
526 			break;
527 		}
528 	efree(subject);
529 	poplist();
530 	poplist();
531 }
532 
533 void
534 Xcase(void)
535 {
536 	word *p;
537 	char *s;
538 	int ok = 0;
539 	s = list2str(runq->argv->next->words);
540 	for(p = runq->argv->words;p;p = p->next){
541 		if(match(s, p->word, '\0')){
542 			ok = 1;
543 			break;
544 		}
545 	}
546 	efree(s);
547 	if(ok)
548 		runq->pc++;
549 	else
550 		runq->pc = runq->code[runq->pc].i;
551 	poplist();
552 }
553 
554 word*
555 conclist(word *lp, word *rp, word *tail)
556 {
557 	char *buf;
558 	word *v;
559 	if(lp->next || rp->next)
560 		tail = conclist(lp->next==0?lp:lp->next, rp->next==0?rp:rp->next,
561 			tail);
562 	buf = emalloc(strlen(lp->word)+strlen(rp->word)+1);
563 	strcpy(buf, lp->word);
564 	strcat(buf, rp->word);
565 	v = newword(buf, tail);
566 	efree(buf);
567 	return v;
568 }
569 
570 void
571 Xconc(void)
572 {
573 	word *lp = runq->argv->words;
574 	word *rp = runq->argv->next->words;
575 	word *vp = runq->argv->next->next->words;
576 	int lc = count(lp), rc = count(rp);
577 	if(lc!=0 || rc!=0){
578 		if(lc==0 || rc==0){
579 			Xerror1("null list in concatenation");
580 			return;
581 		}
582 		if(lc!=1 && rc!=1 && lc!=rc){
583 			Xerror1("mismatched list lengths in concatenation");
584 			return;
585 		}
586 		vp = conclist(lp, rp, vp);
587 	}
588 	poplist();
589 	poplist();
590 	runq->argv->words = vp;
591 }
592 
593 void
594 Xassign(void)
595 {
596 	var *v;
597 	if(count(runq->argv->words)!=1){
598 		Xerror1("variable name not singleton!");
599 		return;
600 	}
601 	deglob(runq->argv->words->word);
602 	v = vlook(runq->argv->words->word);
603 	poplist();
604 	globlist();
605 	freewords(v->val);
606 	v->val = runq->argv->words;
607 	v->changed = 1;
608 	if(v->changefn)
609 		v->changefn(v);
610 	runq->argv->words = 0;
611 	poplist();
612 }
613 /*
614  * copy arglist a, adding the copy to the front of tail
615  */
616 
617 word*
618 copywords(word *a, word *tail)
619 {
620 	word *v = 0, **end;
621 	for(end=&v;a;a = a->next,end=&(*end)->next)
622 		*end = newword(a->word, 0);
623 	*end = tail;
624 	return v;
625 }
626 
627 void
628 Xdol(void)
629 {
630 	word *a, *star;
631 	char *s, *t;
632 	int n;
633 	if(count(runq->argv->words)!=1){
634 		Xerror1("variable name not singleton!");
635 		return;
636 	}
637 	s = runq->argv->words->word;
638 	deglob(s);
639 	n = 0;
640 	for(t = s;'0'<=*t && *t<='9';t++) n = n*10+*t-'0';
641 	a = runq->argv->next->words;
642 	if(n==0 || *t)
643 		a = copywords(vlook(s)->val, a);
644 	else{
645 		star = vlook("*")->val;
646 		if(star && 1<=n && n<=count(star)){
647 			while(--n) star = star->next;
648 			a = newword(star->word, a);
649 		}
650 	}
651 	poplist();
652 	runq->argv->words = a;
653 }
654 
655 void
656 Xqdol(void)
657 {
658 	word *a, *p;
659 	char *s;
660 	int n;
661 	if(count(runq->argv->words)!=1){
662 		Xerror1("variable name not singleton!");
663 		return;
664 	}
665 	s = runq->argv->words->word;
666 	deglob(s);
667 	a = vlook(s)->val;
668 	poplist();
669 	n = count(a);
670 	if(n==0){
671 		pushword("");
672 		return;
673 	}
674 	for(p = a;p;p = p->next) n+=strlen(p->word);
675 	s = emalloc(n);
676 	if(a){
677 		strcpy(s, a->word);
678 		for(p = a->next;p;p = p->next){
679 			strcat(s, " ");
680 			strcat(s, p->word);
681 		}
682 	}
683 	else
684 		s[0]='\0';
685 	pushword(s);
686 	efree(s);
687 }
688 
689 word*
690 copynwords(word *a, word *tail, int n)
691 {
692 	word *v, **end;
693 
694 	v = 0;
695 	end = &v;
696 	while(n-- > 0){
697 		*end = newword(a->word, 0);
698 		end = &(*end)->next;
699 		a = a->next;
700 	}
701 	*end = tail;
702 	return v;
703 }
704 
705 word*
706 subwords(word *val, int len, word *sub, word *a)
707 {
708 	int n, m;
709 	char *s;
710 	if(!sub)
711 		return a;
712 	a = subwords(val, len, sub->next, a);
713 	s = sub->word;
714 	deglob(s);
715 	m = 0;
716 	n = 0;
717 	while('0'<=*s && *s<='9')
718 		n = n*10+ *s++ -'0';
719 	if(*s == '-'){
720 		if(*++s == 0)
721 			m = len - n;
722 		else{
723 			while('0'<=*s && *s<='9')
724 				m = m*10+ *s++ -'0';
725 			m -= n;
726 		}
727 	}
728 	if(n<1 || n>len || m<0)
729 		return a;
730 	if(n+m>len)
731 		m = len-n;
732 	while(--n > 0)
733 		val = val->next;
734 	return copynwords(val, a, m+1);
735 }
736 
737 void
738 Xsub(void)
739 {
740 	word *a, *v;
741 	char *s;
742 	if(count(runq->argv->next->words)!=1){
743 		Xerror1("variable name not singleton!");
744 		return;
745 	}
746 	s = runq->argv->next->words->word;
747 	deglob(s);
748 	a = runq->argv->next->next->words;
749 	v = vlook(s)->val;
750 	a = subwords(v, count(v), runq->argv->words, a);
751 	poplist();
752 	poplist();
753 	runq->argv->words = a;
754 }
755 
756 void
757 Xcount(void)
758 {
759 	word *a;
760 	char *s, *t;
761 	int n;
762 	char num[12];
763 	if(count(runq->argv->words)!=1){
764 		Xerror1("variable name not singleton!");
765 		return;
766 	}
767 	s = runq->argv->words->word;
768 	deglob(s);
769 	n = 0;
770 	for(t = s;'0'<=*t && *t<='9';t++) n = n*10+*t-'0';
771 	if(n==0 || *t){
772 		a = vlook(s)->val;
773 		inttoascii(num, count(a));
774 	}
775 	else{
776 		a = vlook("*")->val;
777 		inttoascii(num, a && 1<=n && n<=count(a)?1:0);
778 	}
779 	poplist();
780 	pushword(num);
781 }
782 
783 void
784 Xlocal(void)
785 {
786 	if(count(runq->argv->words)!=1){
787 		Xerror1("variable name must be singleton\n");
788 		return;
789 	}
790 	deglob(runq->argv->words->word);
791 	runq->local = newvar(strdup(runq->argv->words->word), runq->local);
792 	runq->local->val = copywords(runq->argv->next->words, (word *)0);
793 	runq->local->changed = 1;
794 	poplist();
795 	poplist();
796 }
797 
798 void
799 Xunlocal(void)
800 {
801 	var *v = runq->local, *hid;
802 	if(v==0)
803 		panic("Xunlocal: no locals!", 0);
804 	runq->local = v->next;
805 	hid = vlook(v->name);
806 	hid->changed = 1;
807 	efree(v->name);
808 	freewords(v->val);
809 	efree((char *)v);
810 }
811 
812 void
813 freewords(word *w)
814 {
815 	word *nw;
816 	while(w){
817 		efree(w->word);
818 		nw = w->next;
819 		efree((char *)w);
820 		w = nw;
821 	}
822 }
823 
824 void
825 Xfn(void)
826 {
827 	var *v;
828 	word *a;
829 	int end;
830 	end = runq->code[runq->pc].i;
831 	for(a = runq->argv->words;a;a = a->next){
832 		v = gvlook(a->word);
833 		if(v->fn)
834 			codefree(v->fn);
835 		v->fn = codecopy(runq->code);
836 		v->pc = runq->pc+2;
837 		v->fnchanged = 1;
838 	}
839 	runq->pc = end;
840 	poplist();
841 }
842 
843 void
844 Xdelfn(void)
845 {
846 	var *v;
847 	word *a;
848 	for(a = runq->argv->words;a;a = a->next){
849 		v = gvlook(a->word);
850 		if(v->fn)
851 			codefree(v->fn);
852 		v->fn = 0;
853 		v->fnchanged = 1;
854 	}
855 	poplist();
856 }
857 
858 char*
859 concstatus(char *s, char *t)
860 {
861 	static char v[NSTATUS+1];
862 	int n = strlen(s);
863 	strncpy(v, s, NSTATUS);
864 	if(n<NSTATUS){
865 		v[n]='|';
866 		strncpy(v+n+1, t, NSTATUS-n-1);
867 	}
868 	v[NSTATUS]='\0';
869 	return v;
870 }
871 
872 void
873 Xpipewait(void)
874 {
875 	char status[NSTATUS+1];
876 	if(runq->pid==-1)
877 		setstatus(concstatus(runq->status, getstatus()));
878 	else{
879 		strncpy(status, getstatus(), NSTATUS);
880 		status[NSTATUS]='\0';
881 		Waitfor(runq->pid, 1);
882 		runq->pid=-1;
883 		setstatus(concstatus(getstatus(), status));
884 	}
885 }
886 
887 void
888 Xrdcmds(void)
889 {
890 	struct thread *p = runq;
891 	word *prompt;
892 	flush(err);
893 	nerror = 0;
894 	if(flag['s'] && !truestatus())
895 		pfmt(err, "status=%v\n", vlook("status")->val);
896 	if(runq->iflag){
897 		prompt = vlook("prompt")->val;
898 		if(prompt)
899 			promptstr = prompt->word;
900 		else
901 			promptstr="% ";
902 	}
903 	Noerror();
904 	if((flag['Y'] ? yyparse : parse)()){
905 		if(!p->iflag || p->eof && !Eintr()){
906 			if(p->cmdfile)
907 				efree(p->cmdfile);
908 			closeio(p->cmdfd);
909 			Xreturn();	/* should this be omitted? */
910 		}
911 		else{
912 			if(Eintr()){
913 				pchr(err, '\n');
914 				p->eof = 0;
915 			}
916 			--p->pc;	/* go back for next command */
917 		}
918 	}
919 	else{
920 		ntrap = 0;	/* avoid double-interrupts during blocked writes */
921 		--p->pc;	/* re-execute Xrdcmds after codebuf runs */
922 		start(codebuf, 1, runq->local);
923 	}
924 	freenodes();
925 }
926 
927 void
928 Xerror(char *s)
929 {
930 	if(strcmp(argv0, "rc")==0 || strcmp(argv0, "/bin/rc")==0)
931 		pfmt(err, "rc: %s: %r\n", s);
932 	else
933 		pfmt(err, "rc (%s): %s: %r\n", argv0, s);
934 	flush(err);
935 	setstatus("error");
936 	while(!runq->iflag) Xreturn();
937 }
938 
939 void
940 Xerror1(char *s)
941 {
942 	if(strcmp(argv0, "rc")==0 || strcmp(argv0, "/bin/rc")==0)
943 		pfmt(err, "rc: %s\n", s);
944 	else
945 		pfmt(err, "rc (%s): %s\n", argv0, s);
946 	flush(err);
947 	setstatus("error");
948 	while(!runq->iflag) Xreturn();
949 }
950 
951 void
952 setstatus(char *s)
953 {
954 	setvar("status", newword(s, (word *)0));
955 }
956 
957 char*
958 getstatus(void)
959 {
960 	var *status = vlook("status");
961 	return status->val?status->val->word:"";
962 }
963 
964 int
965 truestatus(void)
966 {
967 	char *s;
968 	for(s = getstatus();*s;s++)
969 		if(*s!='|' && *s!='0')
970 			return 0;
971 	return 1;
972 }
973 
974 void
975 Xdelhere(void)
976 {
977 	Unlink(runq->code[runq->pc++].s);
978 }
979 
980 void
981 Xfor(void)
982 {
983 	if(runq->argv->words==0){
984 		poplist();
985 		runq->pc = runq->code[runq->pc].i;
986 	}
987 	else{
988 		freelist(runq->local->val);
989 		runq->local->val = runq->argv->words;
990 		runq->local->changed = 1;
991 		runq->argv->words = runq->argv->words->next;
992 		runq->local->val->next = 0;
993 		runq->pc++;
994 	}
995 }
996 
997 void
998 Xglob(void)
999 {
1000 	globlist();
1001 }