xref: /illumos-gate/usr/src/cmd/csh/sh.func.c (revision 6c02b4a4)
1 /*
2  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
7 /*	  All Rights Reserved  	*/
8 
9 /*
10  * Copyright (c) 1980 Regents of the University of California.
11  * All rights reserved.  The Berkeley Software License Agreement
12  * specifies the terms and conditions for redistribution.
13  */
14 
15 #pragma ident	"%Z%%M%	%I%	%E% SMI"
16 
17 #include "sh.h"
18 #include <locale.h>	/* For LC_ALL */
19 #include "sh.tconst.h"
20 #include <sys/types.h>
21 #include <stdlib.h>
22 
23 /*
24  * N.B.: Some of the limits change from SunOS 4.x to SunOS 5.0.  In
25  * particular, RLIMIT_RSS is gone and RLIMIT_VMEM is new.  Beware of consusing
26  * the keywords that the command prints for these two.  The old one was
27  * "memoryuse" and the new one is "memorysize".  Note also that a given limit
28  * doesn't necessarily appear in the same position in the two releases.
29  */
30 struct limits {
31 	int	limconst;
32 	tchar *limname;
33 	int	limdiv;
34 	tchar *limscale;
35 } limits[] = {
36 	RLIMIT_CPU,	S_cputime,	/* "cputime" */
37 		1,	S_seconds,	/* "seconds" */
38 	RLIMIT_FSIZE,	S_filesize,	/* "filesize" */
39 		1024,	S_kbytes,	/* "kbytes" */
40 	RLIMIT_DATA,	S_datasize,	/* "datasize" */
41 		1024,	S_kbytes,	/* "kbytes" */
42 	RLIMIT_STACK,	S_stacksize,	/* "stacksize" */
43 		1024,	S_kbytes,	/* "kbytes" */
44 	RLIMIT_CORE,	S_coredumpsize, /* "coredumpsize" */
45 		1024,	S_kbytes,	/* "kbytes" */
46 	RLIMIT_NOFILE,	S_descriptors,	/* "descriptors" */
47 		1,	S_,		/* "" */
48 	RLIMIT_VMEM,	S_memorysize,	/* "memorysize" */
49 		1024,	S_kbytes,	/* "kbytes" */
50 	-1,		0,
51 };
52 
53 
54 static int getval(struct limits *lp, tchar **v, rlim_t *);
55 void islogin(void);
56 int dolabel(void);
57 void reexecute(struct command *kp);
58 void preread_(void);
59 void doagain(void);
60 void toend(void);
61 void wfree(void);
62 void echo(tchar sep, tchar **v);
63 void local_setenv(tchar *name, tchar *val);
64 void local_unsetenv(tchar *name);
65 void limtail(tchar *cp, tchar *str0);
66 void plim(struct limits *lp, tchar hard);
67 void search();
68 
69 #define	BUFSZ	1028
70 
71 /*
72  * C shell
73  */
74 
75 struct biltins *
76 isbfunc(struct command *t)
77 {
78 	tchar *cp = t->t_dcom[0];
79 	struct biltins *bp, *bp1, *bp2;
80 	int dofg1(), dobg1();
81 
82 	static struct biltins label = { S_, dolabel, 0, 0 };
83 	static struct biltins foregnd = { S_Pjob, dofg1, 0, 0 };
84 	static struct biltins backgnd = { S_PjobAND, dobg1, 0, 0 };
85 #ifdef TRACE
86 	tprintf("TRACE- isbfunc()\n");
87 #endif
88 	if (lastchr(cp) == ':') {
89 		label.bname = cp;
90 		return (&label);
91 	}
92 	if (*cp == '%') {
93 		if (t->t_dflg & FAND) {
94 			t->t_dflg &= ~FAND;
95 			backgnd.bname = cp;
96 			return (&backgnd);
97 		}
98 		foregnd.bname = cp;
99 		return (&foregnd);
100 	}
101 	/*
102 	 * Binary search
103 	 * Bp1 is the beginning of the current search range.
104 	 * Bp2 is one past the end.
105 	 */
106 	for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2; ) {
107 		int i;
108 
109 		bp = bp1 + (bp2 - bp1 >> 1);
110 		if ((i = *cp - *bp->bname) == 0 &&
111 		    (i = strcmp_(cp, bp->bname)) == 0) {
112 			return (bp);
113 		}
114 		if (i < 0) {
115 			bp2 = bp;
116 		} else {
117 			bp1 = bp + 1;
118 		}
119 	}
120 	return (0);
121 }
122 
123 void
124 func(struct command *t, struct biltins *bp)
125 {
126 	int i;
127 
128 #ifdef TRACE
129 	tprintf("TRACE- func()\n");
130 #endif
131 	xechoit(t->t_dcom);
132 	setname(bp->bname);
133 	i = blklen(t->t_dcom) - 1;
134 	if (i < bp->minargs) {
135 		bferr("Too few arguments");
136 	}
137 	if (i > bp->maxargs) {
138 		bferr("Too many arguments");
139 	}
140 	(*bp->bfunct)(t->t_dcom, t);
141 }
142 
143 int
144 dolabel(void)
145 {
146 #ifdef TRACE
147 	tprintf("TRACE- dolabel()\n");
148 #endif
149 	return (0);
150 }
151 
152 void
153 doonintr(tchar **v)
154 {
155 	tchar *cp;
156 	tchar *vv = v[1];
157 
158 #ifdef TRACE
159 	tprintf("TRACE- doonintr()\n");
160 #endif
161 	if (parintr == SIG_IGN) {
162 		return;
163 	}
164 	if (setintr && intty) {
165 		bferr("Can't from terminal");
166 	}
167 	cp = gointr, gointr = 0, xfree(cp);
168 	if (vv == 0) {
169 		if (setintr) {
170 			(void) sigblock(sigmask(SIGINT));
171 		} else {
172 			(void) signal(SIGINT, SIG_DFL);
173 		}
174 		gointr = 0;
175 	} else if (eq((vv = strip(vv)), S_MINUS)) {
176 		(void) signal(SIGINT, SIG_IGN);
177 		gointr = S_MINUS;
178 	} else {
179 		gointr = savestr(vv);
180 		(void) signal(SIGINT, pintr);
181 	}
182 }
183 
184 void
185 donohup(void)
186 {
187 
188 #ifdef TRACE
189 	tprintf("TRACE- donohup()\n");
190 #endif
191 	if (intty) {
192 		bferr("Can't from terminal");
193 	}
194 	if (setintr == 0) {
195 		(void) signal(SIGHUP, SIG_IGN);
196 #ifdef CC
197 		submit(getpid());
198 #endif
199 	}
200 }
201 
202 void
203 dozip(void)
204 {
205 	;
206 }
207 
208 void
209 prvars(void)
210 {
211 #ifdef TRACE
212 	tprintf("TRACE- prvars()\n");
213 #endif
214 
215 	plist(&shvhed);
216 }
217 
218 void
219 doalias(tchar **v)
220 {
221 	struct varent *vp;
222 	tchar *p;
223 
224 #ifdef TRACE
225 	tprintf("TRACE- doalias()\n");
226 #endif
227 	v++;
228 	p = *v++;
229 	if (p == 0) {
230 		plist(&aliases);
231 	} else if (*v == 0) {
232 		vp = adrof1(strip(p), &aliases);
233 		if (vp) {
234 			blkpr(vp->vec), printf("\n");
235 		}
236 	} else {
237 		if (eq(p, S_alias) ||
238 		    eq(p, S_unalias)) {
239 			setname(p);
240 			bferr("Too dangerous to alias that");
241 		}
242 		set1(strip(p), saveblk(v), &aliases);
243 	}
244 }
245 
246 void
247 unalias(tchar **v)
248 {
249 
250 #ifdef TRACE
251 	tprintf("TRACE- unalias()\n");
252 #endif
253 	unset1(v, &aliases);
254 }
255 
256 void
257 dologout(void)
258 {
259 
260 #ifdef TRACE
261 	tprintf("TRACE- dologout()\n");
262 #endif
263 	islogin();
264 	goodbye();
265 }
266 
267 void
268 dologin(tchar **v)
269 {
270 
271 	char *v_;	/* work */
272 #ifdef TRACE
273 	tprintf("TRACE- dologin()\n");
274 #endif
275 	islogin();
276 	rechist();
277 	(void) signal(SIGTERM, parterm);
278 	if (v[1] != NULL) {
279 		v_ = tstostr(NULL, v[1]);	/* No need to free */
280 	} else {
281 		v_ = 0;
282 	}
283 	execl("/bin/login", "login", v_, 0);
284 	untty();
285 	exit(1);
286 }
287 
288 #ifdef NEWGRP
289 void
290 donewgrp(tchar **v)
291 {
292 
293 	char *v_;	/* work */
294 #ifdef TRACE
295 	tprintf("TRACE- donewgrp()\n");
296 #endif
297 	if (chkstop == 0 && setintr) {
298 		panystop(0);
299 	}
300 	(void) signal(SIGTERM, parterm);
301 
302 	if (v[1] != NULL) {
303 		v_ = tstostr(NOSTR, v[1]);	/* No need to free */
304 	} else {
305 		v_ = 0;
306 	}
307 	execl("/bin/newgrp", "newgrp", v_, 0);
308 	execl("/usr/bin/newgrp", "newgrp", v_, 0);
309 	untty();
310 	exit(1);
311 }
312 #endif
313 
314 void
315 islogin(void)
316 {
317 
318 #ifdef TRACE
319 	tprintf("TRACE- islogin()\n");
320 #endif
321 	if (chkstop == 0 && setintr) {
322 		panystop(0);
323 	}
324 	if (loginsh) {
325 		return;
326 	}
327 	error("Not login shell");
328 }
329 
330 void
331 doif(tchar **v, struct command *kp)
332 {
333 	int i;
334 	tchar **vv;
335 
336 #ifdef TRACE
337 	tprintf("TRACE- doif()\n");
338 #endif
339 	v++;
340 	i = exp(&v);
341 	vv = v;
342 	if (*vv == NOSTR) {
343 		bferr("Empty if");
344 	}
345 	if (eq(*vv, S_then)) {
346 		if (*++vv) {
347 			bferr("Improper then");
348 		}
349 		setname(S_then);
350 		/*
351 		 * If expression was zero, then scan to else,
352 		 * otherwise just fall into following code.
353 		 */
354 		if (!i) {
355 			search(ZIF, 0);
356 		}
357 		return;
358 	}
359 	/*
360 	 * Simple command attached to this if.
361 	 * Left shift the node in this tree, munging it
362 	 * so we can reexecute it.
363 	 */
364 	if (i) {
365 		lshift(kp->t_dcom, vv - kp->t_dcom);
366 		reexecute(kp);
367 		donefds();
368 	}
369 }
370 
371 /*
372  * Reexecute a command, being careful not
373  * to redo i/o redirection, which is already set up.
374  */
375 void
376 reexecute(struct command *kp)
377 {
378 
379 #ifdef TRACE
380 	tprintf("TRACE- reexecute()\n");
381 #endif
382 	kp->t_dflg &= FSAVE;
383 	kp->t_dflg |= FREDO;
384 	/*
385 	 * If tty is still ours to arbitrate, arbitrate it;
386 	 * otherwise dont even set pgrp's as the jobs would
387 	 * then have no way to get the tty (we can't give it
388 	 * to them, and our parent wouldn't know their pgrp, etc.
389 	 */
390 	execute(kp, tpgrp > 0 ? tpgrp : -1);
391 }
392 
393 void
394 doelse(void)
395 {
396 
397 #ifdef TRACE
398 	tprintf("TRACE- doelse()\n");
399 #endif
400 	search(ZELSE, 0);
401 }
402 
403 void
404 dogoto(tchar **v)
405 {
406 	struct whyle *wp;
407 	tchar *lp;
408 #ifdef TRACE
409 	tprintf("TRACE- dogoto()\n");
410 #endif
411 
412 	/*
413 	 * While we still can, locate any unknown ends of existing loops.
414 	 * This obscure code is the WORST result of the fact that we
415 	 * don't really parse.
416 	 */
417 	for (wp = whyles; wp; wp = wp->w_next) {
418 		if (wp->w_end == 0) {
419 			search(ZBREAK, 0);
420 			wp->w_end = btell();
421 		} else {
422 			bseek(wp->w_end);
423 		}
424 	}
425 	search(ZGOTO, 0, lp = globone(v[1]));
426 	xfree(lp);
427 	/*
428 	 * Eliminate loops which were exited.
429 	 */
430 	wfree();
431 }
432 
433 void
434 doswitch(tchar **v)
435 {
436 	tchar *cp, *lp;
437 
438 #ifdef TRACE
439 	tprintf("TRACE- doswitch()\n");
440 #endif
441 	v++;
442 	if (!*v || *(*v++) != '(') {
443 		goto syntax;
444 	}
445 	cp = **v == ')' ? S_ : *v++;
446 	if (*(*v++) != ')') {
447 		v--;
448 	}
449 	if (*v) {
450 syntax:
451 		error("Syntax error");
452 	}
453 	search(ZSWITCH, 0, lp = globone(cp));
454 	xfree(lp);
455 }
456 
457 void
458 dobreak(void)
459 {
460 
461 #ifdef TRACE
462 	tprintf("TRACE- dobreak()\n");
463 #endif
464 	if (whyles) {
465 		toend();
466 	} else {
467 		bferr("Not in while/foreach");
468 	}
469 }
470 
471 void
472 doexit(tchar **v)
473 {
474 
475 #ifdef TRACE
476 	tprintf("TRACE- doexit()\n");
477 #endif
478 	if (chkstop == 0) {
479 		panystop(0);
480 	}
481 	/*
482 	 * Don't DEMAND parentheses here either.
483 	 */
484 	v++;
485 	if (*v) {
486 		set(S_status, putn(exp(&v)));
487 		if (*v) {
488 			bferr("Expression syntax");
489 		}
490 	}
491 	btoeof();
492 	if (intty) {
493 		(void) close(SHIN);
494 		unsetfd(SHIN);
495 	}
496 }
497 
498 void
499 doforeach(tchar **v)
500 {
501 	tchar *cp;
502 	struct whyle *nwp;
503 
504 #ifdef TRACE
505 	tprintf("TRACE- doforeach()\n");
506 #endif
507 	v++;
508 	cp = strip(*v);
509 	while (*cp && alnum(*cp)) {
510 		cp++;
511 	}
512 	if (*cp || strlen_(*v) >= 20 || !letter(**v)) {
513 		bferr("Invalid variable");
514 	}
515 	cp = *v++;
516 	if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')') {
517 		bferr("Words not ()'ed");
518 	}
519 	v++;
520 	gflag = 0, tglob(v);
521 	v = glob(v);
522 	if (v == 0) {
523 		bferr("No match");
524 	}
525 	nwp = (struct whyle *)calloc(1, sizeof (*nwp));
526 	nwp->w_fe = nwp->w_fe0 = v; gargv = 0;
527 	nwp->w_start = btell();
528 	nwp->w_fename = savestr(cp);
529 	nwp->w_next = whyles;
530 	whyles = nwp;
531 	/*
532 	 * Pre-read the loop so as to be more
533 	 * comprehensible to a terminal user.
534 	 */
535 	if (intty) {
536 		preread_();
537 	}
538 	doagain();
539 }
540 
541 void
542 dowhile(tchar **v)
543 {
544 	int status;
545 	bool again = whyles != 0 && whyles->w_start == lineloc &&
546 	    whyles->w_fename == 0;
547 
548 #ifdef TRACE
549 	tprintf("TRACE- dowhile()\n");
550 #endif
551 	v++;
552 	/*
553 	 * Implement prereading here also, taking care not to
554 	 * evaluate the expression before the loop has been read up
555 	 * from a terminal.
556 	 */
557 	if (intty && !again) {
558 		status = !exp0(&v, 1);
559 	} else {
560 		status = !exp(&v);
561 	}
562 	if (*v) {
563 		bferr("Expression syntax");
564 	}
565 	if (!again) {
566 		struct whyle *nwp = (struct whyle *)calloc(1, sizeof (*nwp));
567 
568 		nwp->w_start = lineloc;
569 		nwp->w_end = 0;
570 		nwp->w_next = whyles;
571 		whyles = nwp;
572 		if (intty) {
573 			/*
574 			 * The tty preread
575 			 */
576 			preread_();
577 			doagain();
578 			return;
579 		}
580 	}
581 	if (status) {
582 		/* We ain't gonna loop no more, no more! */
583 		toend();
584 	}
585 }
586 
587 void
588 preread_(void)
589 {
590 #ifdef TRACE
591 	tprintf("TRACE- preread()\n");
592 #endif
593 
594 	whyles->w_end = -1;
595 	if (setintr) {
596 		(void) sigsetmask(sigblock(0) & ~sigmask(SIGINT));
597 	}
598 	search(ZBREAK, 0);
599 	if (setintr) {
600 		(void) sigblock(sigmask(SIGINT));
601 	}
602 	whyles->w_end = btell();
603 }
604 
605 void
606 doend(void)
607 {
608 
609 #ifdef TRACE
610 	tprintf("TRACE- doend()\n");
611 #endif
612 	if (!whyles) {
613 		bferr("Not in while/foreach");
614 	}
615 	whyles->w_end = btell();
616 	doagain();
617 }
618 
619 void
620 docontin(void)
621 {
622 #ifdef TRACE
623 	tprintf("TRACE- docontin()\n");
624 #endif
625 
626 	if (!whyles) {
627 		bferr("Not in while/foreach");
628 	}
629 	doagain();
630 }
631 
632 void
633 doagain(void)
634 {
635 
636 #ifdef TRACE
637 	tprintf("TRACE- doagain()\n");
638 #endif
639 	/* Repeating a while is simple */
640 	if (whyles->w_fename == 0) {
641 		bseek(whyles->w_start);
642 		return;
643 	}
644 	/*
645 	 * The foreach variable list actually has a spurious word
646 	 * ")" at the end of the w_fe list.  Thus we are at the
647 	 * of the list if one word beyond this is 0.
648 	 */
649 	if (!whyles->w_fe[1]) {
650 		dobreak();
651 		return;
652 	}
653 	set(whyles->w_fename, savestr(*whyles->w_fe++));
654 	bseek(whyles->w_start);
655 }
656 
657 void
658 dorepeat(tchar **v, struct command *kp)
659 {
660 	int i, omask;
661 
662 #ifdef TRACE
663 	tprintf("TRACE- dorepeat()\n");
664 #endif
665 	i = getn(v[1]);
666 	if (setintr) {
667 		omask = sigblock(sigmask(SIGINT)) & ~sigmask(SIGINT);
668 	}
669 	lshift(v, 2);
670 	while (i > 0) {
671 		if (setintr) {
672 			(void) sigsetmask(omask);
673 		}
674 		reexecute(kp);
675 		--i;
676 	}
677 	donefds();
678 	if (setintr) {
679 		(void) sigsetmask(omask);
680 	}
681 }
682 
683 void
684 doswbrk(void)
685 {
686 
687 #ifdef TRACE
688 	tprintf("TRACE- doswbrk()\n");
689 #endif
690 	search(ZBRKSW, 0);
691 }
692 
693 int
694 srchx(tchar *cp)
695 {
696 	struct srch *sp, *sp1, *sp2;
697 	int i;
698 
699 #ifdef TRACE
700 	tprintf("TRACE- srchx()\n");
701 #endif
702 	/*
703 	 * Binary search
704 	 * Sp1 is the beginning of the current search range.
705 	 * Sp2 is one past the end.
706 	 */
707 	for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2; ) {
708 		sp = sp1 + (sp2 - sp1 >> 1);
709 		if ((i = *cp - *sp->s_name) == 0 &&
710 		    (i = strcmp_(cp, sp->s_name)) == 0) {
711 			return (sp->s_value);
712 		}
713 		if (i < 0) {
714 			sp2 = sp;
715 		} else {
716 			sp1 = sp + 1;
717 		}
718 	}
719 	return (-1);
720 }
721 
722 tchar Stype;
723 tchar *Sgoal;
724 
725 /*VARARGS2*/
726 void
727 search(type, level, goal)
728 	int type; int level; tchar *goal;
729 {
730 	tchar wordbuf[BUFSIZ];
731 	tchar *aword = wordbuf;
732 	tchar *cp;
733 
734 #ifdef TRACE
735 	tprintf("TRACE- search()\n");
736 #endif
737 	Stype = type; Sgoal = goal;
738 	if (type == ZGOTO) {
739 		bseek((off_t)0);
740 	}
741 	do {
742 		if (intty && fseekp == feobp) {
743 			printf("? "), flush();
744 		}
745 		aword[0] = 0;
746 		(void) getword(aword);
747 
748 		switch (srchx(aword)) {
749 
750 		case ZELSE:
751 			if (level == 0 && type == ZIF) {
752 				return;
753 			}
754 			break;
755 
756 		case ZIF:
757 			while (getword(aword)) {
758 				continue;
759 			}
760 			if ((type == ZIF || type == ZELSE) &&
761 			    eq(aword, S_then)) {
762 				level++;
763 			}
764 			break;
765 
766 		case ZENDIF:
767 			if (type == ZIF || type == ZELSE) {
768 				level--;
769 			}
770 			break;
771 
772 		case ZFOREACH:
773 		case ZWHILE:
774 			if (type == ZBREAK) {
775 				level++;
776 			}
777 			break;
778 
779 		case ZEND:
780 			if (type == ZBREAK) {
781 				level--;
782 			}
783 			break;
784 
785 		case ZSWITCH:
786 			if (type == ZSWITCH || type == ZBRKSW) {
787 				level++;
788 			}
789 			break;
790 
791 		case ZENDSW:
792 			if (type == ZSWITCH || type == ZBRKSW) {
793 				level--;
794 			}
795 			break;
796 
797 		case ZLABEL:
798 			if (type == ZGOTO && getword(aword) &&
799 			    eq(aword, goal)) {
800 				level = -1;
801 			}
802 			break;
803 
804 		default:
805 			if (type != ZGOTO && (type != ZSWITCH || level != 0)) {
806 				break;
807 			}
808 			if (lastchr(aword) != ':') {
809 				break;
810 			}
811 			aword[strlen_(aword) - 1] = 0;
812 			if (type == ZGOTO && eq(aword, goal) ||
813 			    type == ZSWITCH && eq(aword, S_default)) {
814 				level = -1;
815 			}
816 			break;
817 
818 		case ZCASE:
819 			if (type != ZSWITCH || level != 0) {
820 				break;
821 			}
822 			(void) getword(aword);
823 			if (lastchr(aword) == ':') {
824 				aword[strlen_(aword) - 1] = 0;
825 			}
826 			cp = strip(Dfix1(aword));
827 			if (Gmatch(goal, cp)) {
828 				level = -1;
829 			}
830 			xfree(cp);
831 			break;
832 
833 		case ZDEFAULT:
834 			if (type == ZSWITCH && level == 0) {
835 				level = -1;
836 			}
837 			break;
838 		}
839 		(void) getword(NOSTR);
840 	} while (level >= 0);
841 }
842 
843 int
844 getword(tchar *wp)
845 {
846 	int found = 0;
847 	int c, d;
848 #ifdef TRACE
849 	tprintf("TRACE- getword()\n");
850 #endif
851 
852 	c = readc(1);
853 	d = 0;
854 	do {
855 		while (issp(c)) {
856 			c = readc(1);
857 		}
858 		if (c == '#') {
859 			do {
860 				c = readc(1);
861 			} while (c >= 0 && c != '\n');
862 		}
863 		if (c < 0) {
864 			goto past;
865 		}
866 		if (c == '\n') {
867 			if (wp) {
868 				break;
869 			}
870 			return (0);
871 		}
872 
873 		/* ( and ) form separate words */
874 		if (c == '(' || c == ')') {
875 			return (1);
876 		}
877 
878 		unreadc(c);
879 		found = 1;
880 		do {
881 			c = readc(1);
882 			if (c == '\\' && (c = readc(1)) == '\n') {
883 				c = ' ';
884 			}
885 			if (c == '\'' || c == '"') {
886 				if (d == 0) {
887 					d = c;
888 				} else if (d == c) {
889 					d = 0;
890 				}
891 			}
892 			if (c < 0) {
893 				goto past;
894 			}
895 			if (wp) {
896 				*wp++ = c;
897 			}
898 		} while ((d || !issp(c) && c != '(' && c != ')') && c != '\n');
899 	} while (wp == 0);
900 	unreadc(c);
901 	if (found) {
902 		*--wp = 0;
903 	}
904 	return (found);
905 
906 past:
907 	switch (Stype) {
908 
909 	case ZIF:
910 		bferr("then/endif not found");
911 
912 	case ZELSE:
913 		bferr("endif not found");
914 
915 	case ZBRKSW:
916 	case ZSWITCH:
917 		bferr("endsw not found");
918 
919 	case ZBREAK:
920 		bferr("end not found");
921 
922 	case ZGOTO:
923 		setname(Sgoal);
924 		bferr("label not found");
925 	}
926 	/*NOTREACHED*/
927 
928 	return (0);
929 }
930 
931 void
932 toend(void)
933 {
934 
935 #ifdef TRACE
936 	tprintf("TRACE- toend()\n");
937 #endif
938 	if (whyles->w_end == 0) {
939 		search(ZBREAK, 0);
940 		whyles->w_end = btell() - 1;
941 	} else {
942 		bseek(whyles->w_end);
943 	}
944 	wfree();
945 }
946 
947 void
948 wfree(void)
949 {
950 	long o = btell();
951 
952 #ifdef TRACE
953 	tprintf("TRACE- wfree()\n");
954 #endif
955 	while (whyles) {
956 		struct whyle *wp = whyles;
957 		struct whyle *nwp = wp->w_next;
958 
959 		if (o >= wp->w_start && (wp->w_end == 0 || o < wp->w_end)) {
960 			break;
961 		}
962 		if (wp->w_fe0) {
963 			blkfree(wp->w_fe0);
964 		}
965 		if (wp->w_fename) {
966 			xfree(wp->w_fename);
967 		}
968 		xfree((char *)wp);
969 		whyles = nwp;
970 	}
971 }
972 
973 void
974 doecho(tchar **v)
975 {
976 
977 #ifdef TRACE
978 	tprintf("TRACE- doecho()\n");
979 #endif
980 	echo(' ', v);
981 }
982 
983 void
984 doglob(tchar **v)
985 {
986 
987 #ifdef TRACE
988 	tprintf("TRACE- doglob()\n");
989 #endif
990 	echo(0, v);
991 	flush();
992 }
993 
994 void
995 echo(tchar sep, tchar **v)
996 {
997 	tchar *cp;
998 	int nonl = 0;
999 
1000 #ifdef TRACE
1001 	tprintf("TRACE- echo()\n");
1002 #endif
1003 	if (setintr) {
1004 		(void) sigsetmask(sigblock(0) & ~sigmask(SIGINT));
1005 	}
1006 	v++;
1007 	if (*v == 0) {
1008 		/*
1009 		 * echo command needs to have newline when there are no
1010 		 * flags or arguments.  glob should have no newline.  If
1011 		 * the separator is a blank, we are doing an echo.  If the
1012 		 * separator is zero, we are globbing.
1013 		 */
1014 		if (sep == (tchar)' ')
1015 			Putchar('\n');
1016 		return;
1017 	}
1018 	gflag = 0, tglob(v);
1019 	if (gflag) {
1020 		v = glob(v);
1021 		if (v == 0) {
1022 			bferr("No match");
1023 		}
1024 	}
1025 	/* check for -n arg, NOTE: it might be quoted */
1026 	if (sep == ' ' && *v && strlen_(*v) == 2 &&
1027 	    ((**v&TRIM) == '-' && (*(*v + 1) & TRIM) == 'n' &&
1028 	    (*(*v+2)&TRIM) == 0)) {
1029 		nonl++, v++;
1030 	}
1031 	while (cp = *v++) {
1032 		int c;
1033 
1034 		while (c = *cp++) {
1035 			Putchar(c | QUOTE);
1036 		}
1037 		if (*v) {
1038 			Putchar(sep | QUOTE);
1039 		}
1040 	}
1041 	if (sep && nonl == 0) {
1042 		Putchar('\n');
1043 	} else {
1044 		flush();
1045 	}
1046 	if (setintr) {
1047 		(void) sigblock(sigmask(SIGINT));
1048 	}
1049 	if (gargv) {
1050 		blkfree(gargv), gargv = 0;
1051 	}
1052 }
1053 
1054 extern char **environ;
1055 
1056 /*
1057  * Check if the environment variable vp affects this csh's behavior
1058  * and therefore we should call setlocale() or not.
1059  * This function has two side effects when it returns 1:
1060  *	variable islocalevar_catnum is set to the LC_xxx value.
1061  *	variable islocalevar_catname is set to the string "LC_xxx"
1062  */
1063 static int	islocalevar_catnum;
1064 static char	*islocalevar_catname;
1065 
1066 static
1067 bool
1068 islocalevar(tchar *vp)
1069 {
1070 	static struct lcinfo {
1071 		tchar *	evname; /* The name of the env. var. */
1072 	} categories_we_care[] = {
1073 	    S_LANG, S_LC_ALL, S_LC_CTYPE, S_LC_MESSAGES,
1074 	    NOSTR		/* assumption: LC_xxx >= 0 */
1075 	};
1076 	struct lcinfo *p = categories_we_care;
1077 
1078 	do {
1079 		if (strcmp_(vp, p->evname) == 0) {
1080 			return (1);
1081 		}
1082 	} while (((++p)->evname) != NOSTR);
1083 	return (0);
1084 }
1085 
1086 void
1087 dosetenv(tchar **v)
1088 {
1089 	tchar *vp, *lp;
1090 
1091 #ifdef TRACE
1092 	tprintf("TRACE- dosetenv()\n");
1093 #endif
1094 	v++;
1095 	if ((vp = *v++) == 0) {
1096 		char **ep;
1097 
1098 		if (setintr) {
1099 			(void) sigsetmask(sigblock(0) & ~ sigmask(SIGINT));
1100 		}
1101 		for (ep = environ; *ep; ep++) {
1102 			printf("%s\n", *ep);
1103 		}
1104 		return;
1105 	}
1106 
1107 	if ((lp = *v++) == 0) {
1108 		lp = S_;	/* "" */
1109 	}
1110 	local_setenv(vp, lp = globone(lp));
1111 	if (eq(vp, S_PATH)) {
1112 		importpath(lp);
1113 		dohash(xhash);
1114 	} else if (islocalevar(vp)) {
1115 		if (!setlocale(LC_ALL, "")) {
1116 			error("Locale could not be set properly");
1117 		}
1118 	}
1119 
1120 	xfree(lp);
1121 }
1122 
1123 void
1124 dounsetenv(tchar **v)
1125 {
1126 #ifdef TRACE
1127 	tprintf("TRACE- dounsetenv()\n");
1128 #endif
1129 	v++;
1130 	do {
1131 		local_unsetenv(*v);
1132 		if (islocalevar(*v++)) {
1133 			setlocale(LC_ALL, "");	/* Hope no error! */
1134 		}
1135 	} while (*v);
1136 }
1137 
1138 void
1139 local_setenv(tchar *name, tchar *val)
1140 {
1141 	char **ep = environ;
1142 	tchar *cp;
1143 	char *dp;
1144 	tchar *ep_;	/* temporary */
1145 	char *blk[2], **oep = ep;
1146 
1147 #ifdef TRACE
1148 	/* tprintf("TRACE- local_setenv(%t, %t)\n", name, val); */
1149 	/* printf("IN local_setenv args = (%t)\n", val); */
1150 #endif
1151 	for (; *ep; ep++) {
1152 #ifdef MBCHAR
1153 		for (cp = name, dp = *ep; *cp && *dp; cp++) {
1154 			/*
1155 			 * This loop compares two chars in different
1156 			 * representations, EUC (as char *) and wchar_t
1157 			 * (in tchar), and ends when they are different.
1158 			 */
1159 			wchar_t	dwc;
1160 			int	n;
1161 
1162 			n = mbtowc(&dwc, dp, MB_CUR_MAX);
1163 			if (n <= 0) {
1164 				break; /* Illegal multibyte. */
1165 			}
1166 			dp += n; /* Advance to next multibyte char. */
1167 			if (dwc == (wchar_t)(*cp & TRIM)) {
1168 				continue;
1169 			} else  {
1170 				break;
1171 			}
1172 		}
1173 #else /* !MBCHAR */
1174 		for (cp = name, dp = *ep; *cp && (char)*cp == *dp; cp++, dp++) {
1175 			continue;
1176 		}
1177 #endif /* !MBCHAR */
1178 		if (*cp != 0 || *dp != '=') {
1179 			continue;
1180 		}
1181 		cp = strspl(S_EQ, val);
1182 		xfree(*ep);
1183 		ep_ = strspl(name, cp);		/* ep_ is xalloc'ed */
1184 		xfree(cp);
1185 		/*
1186 		 * Trimming is not needed here.
1187 		 * trim();
1188 		 */
1189 		*ep = tstostr(NULL, ep_);
1190 		xfree(ep_);			/* because temp.  use */
1191 		return;
1192 	}
1193 	ep_ = strspl(name, S_EQ);		/* ep_ is xalloc'ed */
1194 	blk[0] = tstostr(NULL, ep_);
1195 	blk[1] = 0;
1196 	xfree(ep_);
1197 	environ = (char **)blkspl_((char **)environ, blk);
1198 	xfree((void *)oep);
1199 	local_setenv(name, val);
1200 }
1201 
1202 void
1203 local_unsetenv(tchar *name)
1204 {
1205 	char **ep = environ;
1206 	tchar *cp;
1207 	char *dp;
1208 	char **oep = ep;
1209 	char *cp_;	/* tmp use */
1210 	static int cnt = 0;	/* delete counter */
1211 
1212 #ifdef TRACE
1213 	tprintf("TRACE- local_unsetenv()\n");
1214 #endif
1215 	for (; *ep; ep++) {
1216 #ifdef MBCHAR
1217 		for (cp = name, dp = *ep; *cp && *dp; cp++) {
1218 			/*
1219 			 * This loop compares two chars in different
1220 			 * representations, EUC (as char *) and wchar_t
1221 			 * (in tchar), and ends when they are different.
1222 			 */
1223 			wchar_t	dwc;
1224 			int	n;
1225 
1226 			n = mbtowc(&dwc, dp, MB_CUR_MAX);
1227 			if (n <= 0) {
1228 				break; /* Illegal multibyte. */
1229 			}
1230 			dp += n; /* Advance to next multibyte char. */
1231 			if (dwc == (wchar_t)(*cp & TRIM)) {
1232 				continue;
1233 			} else {
1234 				break;
1235 			}
1236 		}
1237 #else /* !MBCHAR */
1238 		for (cp = name, dp = *ep; *cp && (char)*cp == *dp; cp++, dp++) {
1239 			continue;
1240 		}
1241 #endif /* !MBCHAR */
1242 		if (*cp != 0 || *dp != '=') {
1243 			continue;
1244 		}
1245 		cp_ = *ep;
1246 		*ep = 0;
1247 		environ = (char **)blkspl_((char **)environ, ep+1);
1248 		*ep = cp_;
1249 		xfree(cp_);
1250 		xfree((void *)oep);
1251 		return;
1252 	}
1253 }
1254 
1255 void
1256 doumask(tchar **v)
1257 {
1258 	tchar *cp = v[1];
1259 	int i;
1260 
1261 #ifdef TRACE
1262 	tprintf("TRACE- dounmask()\n");
1263 #endif
1264 	if (cp == 0) {
1265 		i = umask(0);
1266 		(void) umask(i);
1267 		printf("%o\n", i);
1268 		return;
1269 	}
1270 	i = 0;
1271 	while (digit(*cp) && *cp != '8' && *cp != '9') {
1272 		i = i * 8 + *cp++ - '0';
1273 	}
1274 	if (*cp || i < 0 || i > 0777) {
1275 		bferr("Improper mask");
1276 	}
1277 	(void) umask(i);
1278 }
1279 
1280 
1281 struct limits *
1282 findlim(tchar *cp)
1283 {
1284 	struct limits *lp, *res;
1285 
1286 #ifdef TRACE
1287 	tprintf("TRACE- findlim()\n");
1288 #endif
1289 	res = 0;
1290 	for (lp = limits; lp->limconst >= 0; lp++) {
1291 		if (prefix(cp, lp->limname)) {
1292 			if (res) {
1293 				bferr("Ambiguous");
1294 			}
1295 			res = lp;
1296 		}
1297 	}
1298 	if (res) {
1299 		return (res);
1300 	}
1301 	bferr("No such limit");
1302 	/*NOTREACHED*/
1303 }
1304 
1305 void
1306 dolimit(tchar **v)
1307 {
1308 	struct limits *lp;
1309 	rlim_t limit;
1310 	tchar hard = 0;
1311 
1312 #ifdef TRACE
1313 	tprintf("TRACE- dolimit()\n");
1314 #endif
1315 	v++;
1316 	if (*v && eq(*v, S_h)) {
1317 		hard = 1;
1318 		v++;
1319 	}
1320 	if (*v == 0) {
1321 		for (lp = limits; lp->limconst >= 0; lp++) {
1322 			plim(lp, hard);
1323 		}
1324 		return;
1325 	}
1326 	lp = findlim(v[0]);
1327 	if (v[1] == 0) {
1328 		plim(lp,  hard);
1329 		return;
1330 	}
1331 	switch (getval(lp, v+1, &limit)) {
1332 	case 0:
1333 		error("Value specified for limit is too large");
1334 		return;
1335 	case (-1):
1336 		error("Numeric conversion failed");
1337 		return;
1338 	default:
1339 		if (setlim(lp, hard, limit) < 0) {
1340 			error(NOSTR);
1341 		}
1342 	}
1343 }
1344 
1345 static int
1346 getval(struct limits *lp, tchar **v, rlim_t *retval)
1347 {
1348 	rlim_t value, tmp, tmp2;
1349 	tchar *cp = *v++;
1350 	char chbuf[BUFSIZ * MB_LEN_MAX];
1351 
1352 #ifdef TRACE
1353 	tprintf("TRACE- getval()\n");
1354 #endif
1355 
1356 	tstostr(chbuf, cp);
1357 	errno = 0;
1358 	value = strtoull(chbuf, NULL, 0);
1359 /*
1360  * we must accept zero, but the conversion can fail and give us
1361  * zero as well...try to deal with it as gracefully as possible
1362  * by checking for EINVAL
1363  */
1364 	if (value == 0 && errno == EINVAL)
1365 		return (-1);
1366 
1367 	while (digit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E') {
1368 		cp++;
1369 	}
1370 	if (*cp == 0) {
1371 		if (*v == 0) {
1372 			tmp = value * (rlim_t)lp->limdiv;
1373 			/* Check for overflow */
1374 			if (tmp >= value) {
1375 				*retval = tmp;
1376 				return (1);
1377 			} else {
1378 				return (0);
1379 			}
1380 		}
1381 		cp = *v;
1382 	}
1383 	switch (*cp) {
1384 
1385 	case ':':
1386 		if (lp->limconst != RLIMIT_CPU) {
1387 			goto badscal;
1388 		}
1389 		tstostr(chbuf, cp + 1);
1390 		tmp = strtoull(chbuf, NULL, 0);
1391 		tmp2 = value * 60 + tmp;
1392 		if (tmp2 >= value) {
1393 			*retval = tmp2;
1394 			return (1);
1395 		} else {
1396 			return (0);
1397 		}
1398 
1399 	case 'h':
1400 		if (lp->limconst != RLIMIT_CPU) {
1401 			goto badscal;
1402 		}
1403 		limtail(cp, S_hours);
1404 		tmp = value * 3600;
1405 		if (tmp < value) {
1406 			return (0);
1407 		}
1408 		value = tmp;
1409 		break;
1410 
1411 	case 'm':
1412 		if (lp->limconst == RLIMIT_CPU) {
1413 			limtail(cp, S_minutes);
1414 			tmp = value * 60;
1415 			if (tmp < value) {
1416 				return (0);
1417 			}
1418 			value = tmp;
1419 			break;
1420 		}
1421 	case 'M':
1422 		if (lp->limconst == RLIMIT_CPU) {
1423 			goto badscal;
1424 		}
1425 		*cp = 'm';
1426 		limtail(cp, S_megabytes);
1427 		tmp = value * 1024 * 1024;
1428 		if (tmp < value) {
1429 			return (0);
1430 		}
1431 		value = tmp;
1432 		break;
1433 
1434 	case 's':
1435 		if (lp->limconst != RLIMIT_CPU) {
1436 			goto badscal;
1437 		}
1438 		limtail(cp, S_seconds);
1439 		break;
1440 
1441 	case 'k':
1442 		if (lp->limconst == RLIMIT_CPU) {
1443 			goto badscal;
1444 		}
1445 		limtail(cp, S_kbytes);
1446 		tmp = value * 1024;
1447 		if (tmp < value) {
1448 			return (0);
1449 		}
1450 		value = tmp;
1451 		break;
1452 
1453 	case 'u':
1454 		limtail(cp, S_unlimited);
1455 		*retval = RLIM_INFINITY;
1456 		return (1);
1457 
1458 	default:
1459 badscal:
1460 		bferr("Improper or unknown scale factor");
1461 	}
1462 	*retval = value;
1463 	return (1);
1464 }
1465 
1466 void
1467 limtail(tchar *cp, tchar *str0)
1468 {
1469 	tchar *str = str0;
1470 #ifdef TRACE
1471 	tprintf("TRACE- limtail()\n");
1472 #endif
1473 
1474 	while (*cp && *cp == *str) {
1475 		cp++, str++;
1476 	}
1477 	if (*cp) {
1478 		error("Bad scaling; did you mean ``%t''?", str0);
1479 	}
1480 }
1481 
1482 void
1483 plim(struct limits *lp, tchar hard)
1484 {
1485 	struct rlimit rlim;
1486 	char buf[BUFSZ];
1487 	char *pbuf;
1488 	rlim_t limit;
1489 
1490 #ifdef TRACE
1491 	tprintf("TRACE- plim()\n");
1492 #endif
1493 	printf("%t \t", lp->limname);
1494 	(void) getrlimit(lp->limconst, &rlim);
1495 	limit = hard ? rlim.rlim_max : rlim.rlim_cur;
1496 	if (limit == RLIM_INFINITY) {
1497 		printf("unlimited");
1498 	} else if (lp->limconst == RLIMIT_CPU) {
1499 		psecs_ull(limit);
1500 	} else {
1501 		buf[BUFSZ - 1] = '\0';
1502 		pbuf = ulltostr((limit / lp->limdiv), &buf[BUFSZ - 1]);
1503 		printf("%s %t", pbuf, lp->limscale);
1504 	}
1505 	printf("\n");
1506 }
1507 
1508 void
1509 dounlimit(tchar **v)
1510 {
1511 	struct limits *lp;
1512 	int err = 0;
1513 	tchar hard = 0;
1514 #ifdef TRACE
1515 	tprintf("TRACE- dounlimit()\n");
1516 #endif
1517 
1518 	v++;
1519 	if (*v && eq(*v, S_h)) {
1520 		hard = 1;
1521 		v++;
1522 	}
1523 	if (*v == 0) {
1524 		for (lp = limits; lp->limconst >= 0; lp++) {
1525 			if (setlim(lp, hard, RLIM_INFINITY) < 0) {
1526 				err++;
1527 			}
1528 		}
1529 		if (err) {
1530 			error(NULL);
1531 		}
1532 		return;
1533 	}
1534 	while (*v) {
1535 		lp = findlim(*v++);
1536 		if (setlim(lp, hard, RLIM_INFINITY) < 0) {
1537 			error(NULL);
1538 		}
1539 	}
1540 }
1541 
1542 int
1543 setlim(struct limits *lp, tchar hard, rlim_t limit)
1544 {
1545 	struct rlimit rlim;
1546 
1547 #ifdef TRACE
1548 	tprintf("TRACE- setlim()\n");
1549 #endif
1550 	(void) getrlimit(lp->limconst, &rlim);
1551 	if (hard) {
1552 		rlim.rlim_max = limit;
1553 	} else if (limit == RLIM_INFINITY && geteuid() != 0) {
1554 		rlim.rlim_cur = rlim.rlim_max;
1555 	} else {
1556 		rlim.rlim_cur = limit;
1557 	}
1558 	if (setrlimit(lp->limconst, &rlim) < 0) {
1559 		printf("%t: %t: Can't %s%s limit\n", bname, lp->limname,
1560 		    limit == RLIM_INFINITY ? "remove" : "set",
1561 		    hard ? " hard" : "");
1562 		return (-1);
1563 	}
1564 	return (0);
1565 }
1566 
1567 void
1568 dosuspend()
1569 {
1570 	int ctpgrp;
1571 	void (*old)();
1572 
1573 #ifdef TRACE
1574 	tprintf("TRACE- dosuspend()\n");
1575 #endif
1576 	if (loginsh) {
1577 		error("Can't suspend a login shell (yet)");
1578 	}
1579 	if (getpid() == getsid(0)) {
1580 		error("Can't suspend this shell");
1581 	}
1582 	untty();
1583 	old = (void (*)())signal(SIGTSTP, SIG_DFL);
1584 	(void) kill(0, SIGTSTP);
1585 	/* the shell stops here */
1586 	(void) signal(SIGTSTP, old);
1587 	if (tpgrp != -1) {
1588 retry:
1589 		(void) ioctl(FSHTTY, TIOCGPGRP,  (char *)&ctpgrp);
1590 		if (ctpgrp != opgrp) {
1591 			old = (void (*)())signal(SIGTTIN, SIG_DFL);
1592 			(void) kill(0, SIGTTIN);
1593 			(void) signal(SIGTTIN, old);
1594 			goto retry;
1595 		}
1596 		(void) setpgid(0, shpgrp);
1597 		(void) ioctl(FSHTTY, TIOCSPGRP, (char *)&shpgrp);
1598 	}
1599 }
1600 
1601 void
1602 doeval(tchar **v)
1603 {
1604 	tchar **oevalvec = evalvec;
1605 	tchar *oevalp = evalp;
1606 	jmp_buf osetexit;
1607 	int reenter;
1608 	tchar **gv = 0;
1609 
1610 #ifdef TRACE
1611 	tprintf("TRACE- doeval()\n");
1612 #endif
1613 	v++;
1614 	if (*v == 0) {
1615 		return;
1616 	}
1617 	gflag = 0, tglob(v);
1618 	if (gflag) {
1619 		gv = v = glob(v);
1620 		gargv = 0;
1621 		if (v == 0) {
1622 			error("No match");
1623 		}
1624 		v = copyblk(v);
1625 	} else {
1626 		trim(v);
1627 	}
1628 	getexit(osetexit);
1629 	reenter = 0;
1630 	setexit();
1631 	reenter++;
1632 	if (reenter == 1) {
1633 		evalvec = v;
1634 		evalp = 0;
1635 		process(0);
1636 	}
1637 	evalvec = oevalvec;
1638 	evalp = oevalp;
1639 	doneinp = 0;
1640 	if (gv) {
1641 		blkfree(gv);
1642 	}
1643 	resexit(osetexit);
1644 	if (reenter >= 2) {
1645 		error(NULL);
1646 	}
1647 }
1648