xref: /dragonfly/contrib/tcsh-6/sh.func.c (revision d6ab524c)
1 /*
2  * sh.func.c: csh builtin functions
3  */
4 /*-
5  * Copyright (c) 1980, 1991 The Regents of the University of California.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 #include "sh.h"
33 #include "ed.h"
34 #include "tw.h"
35 #include "tc.h"
36 #ifdef WINNT_NATIVE
37 #include "nt.const.h"
38 #endif /* WINNT_NATIVE */
39 
40 #if defined (NLS_CATALOGS) && defined(HAVE_ICONV)
41 static iconv_t catgets_iconv; /* Or (iconv_t)-1 */
42 #endif
43 
44 /*
45  * C shell
46  */
47 
48 extern int MapsAreInited;
49 extern int NLSMapsAreInited;
50 extern int GotTermCaps;
51 
52 static int zlast = -1;
53 
54 static	void	islogin		(void);
55 static	void	preread		(void);
56 static	void	doagain		(void);
57 static  const char *isrchx	(int);
58 static	void	search		(int, int, Char *);
59 static	int	getword		(struct Strbuf *);
60 static	struct wordent	*histgetword	(struct wordent *);
61 static	void	toend		(void);
62 static	void	xecho		(int, Char **);
63 static	int	islocale_var	(Char *);
64 static	void	wpfree		(struct whyle *);
65 
66 const struct biltins *
isbfunc(struct command * t)67 isbfunc(struct command *t)
68 {
69     Char *cp = t->t_dcom[0];
70     const struct biltins *bp, *bp1, *bp2;
71     static struct biltins label = {"", dozip, 0, 0};
72     static struct biltins foregnd = {"%job", dofg1, 0, 0};
73     static struct biltins backgnd = {"%job &", dobg1, 0, 0};
74 
75     /*
76      * We never match a builtin that has quoted the first
77      * character; this has been the traditional way to escape
78      * builtin commands.
79      */
80     if (*cp & QUOTE)
81 	return NULL;
82 
83     if (*cp != ':' && lastchr(cp) == ':') {
84 	label.bname = short2str(cp);
85 	return (&label);
86     }
87     if (*cp == '%') {
88 	if (t->t_dflg & F_AMPERSAND) {
89 	    t->t_dflg &= ~F_AMPERSAND;
90 	    backgnd.bname = short2str(cp);
91 	    return (&backgnd);
92 	}
93 	foregnd.bname = short2str(cp);
94 	return (&foregnd);
95     }
96 #ifdef WARP
97     /*
98      * This is a perhaps kludgy way to determine if the warp builtin is to be
99      * acknowledged or not.  If checkwarp() fails, then we are to assume that
100      * the warp command is invalid, and carry on as we would handle any other
101      * non-builtin command.         -- JDK 2/4/88
102      */
103     if (eq(STRwarp, cp) && !checkwarp()) {
104 	return (0);		/* this builtin disabled */
105     }
106 #endif /* WARP */
107     /*
108      * Binary search Bp1 is the beginning of the current search range. Bp2 is
109      * one past the end.
110      */
111     for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
112 	int i;
113 
114 	bp = bp1 + ((bp2 - bp1) >> 1);
115 	if ((i = ((char) *cp) - *bp->bname) == 0 &&
116 	    (i = StrQcmp(cp, str2short(bp->bname))) == 0)
117 	    return bp;
118 	if (i < 0)
119 	    bp2 = bp;
120 	else
121 	    bp1 = bp + 1;
122     }
123 #ifdef WINNT_NATIVE
124     return nt_check_additional_builtins(cp);
125 #endif /*WINNT_NATIVE*/
126     return (0);
127 }
128 
129 void
func(struct command * t,const struct biltins * bp)130 func(struct command *t, const struct biltins *bp)
131 {
132     int     i;
133 
134     xechoit(t->t_dcom);
135     setname(bp->bname);
136     i = blklen(t->t_dcom) - 1;
137     if (i < bp->minargs)
138 	stderror(ERR_NAME | ERR_TOOFEW);
139     if (i > bp->maxargs)
140 	stderror(ERR_NAME | ERR_TOOMANY);
141     (*bp->bfunct) (t->t_dcom, t);
142 }
143 
144 /*ARGSUSED*/
145 void
doonintr(Char ** v,struct command * c)146 doonintr(Char **v, struct command *c)
147 {
148     Char *cp;
149     Char *vv = v[1];
150 
151     USE(c);
152     if (parintr.sa_handler == SIG_IGN)
153 	return;
154     if (setintr && intty)
155 	stderror(ERR_NAME | ERR_TERMINAL);
156     cp = gointr;
157     gointr = 0;
158     xfree(cp);
159     if (vv == 0) {
160 	if (setintr)
161 	    sigset_interrupting(SIGINT, queue_pintr);
162 	else
163 	    (void) signal(SIGINT, SIG_DFL);
164 	gointr = 0;
165     }
166     else if (eq((vv = strip(vv)), STRminus)) {
167 	(void) signal(SIGINT, SIG_IGN);
168 	gointr = Strsave(STRminus);
169     }
170     else {
171 	gointr = Strsave(vv);
172 	sigset_interrupting(SIGINT, queue_pintr);
173     }
174 }
175 
176 /*ARGSUSED*/
177 void
donohup(Char ** v,struct command * c)178 donohup(Char **v, struct command *c)
179 {
180     USE(c);
181     USE(v);
182     if (intty)
183 	stderror(ERR_NAME | ERR_TERMINAL);
184     if (setintr == 0) {
185 	(void) signal(SIGHUP, SIG_IGN);
186 	phup_disabled = 1;
187 #ifdef CC
188 	submit(getpid());
189 #endif /* CC */
190     }
191 }
192 
193 /*ARGSUSED*/
194 void
dohup(Char ** v,struct command * c)195 dohup(Char **v, struct command *c)
196 {
197     USE(c);
198     USE(v);
199     if (intty)
200 	stderror(ERR_NAME | ERR_TERMINAL);
201     if (setintr == 0)
202     	sigset_interrupting(SIGHUP, SIG_DFL);
203 }
204 
205 
206 /*ARGSUSED*/
207 void
dozip(Char ** v,struct command * c)208 dozip(Char **v, struct command *c)
209 {
210     USE(c);
211     USE(v);
212 }
213 
214 /*ARGSUSED*/
215 void
dofiletest(Char ** v,struct command * c)216 dofiletest(Char **v, struct command *c)
217 {
218     Char **globbed, **fileptr, *ftest, *res;
219 
220     USE(c);
221     if (*(ftest = *++v) != '-')
222 	stderror(ERR_NAME | ERR_FILEINQ);
223     ++v;
224 
225     v = glob_all_or_error(v);
226     globbed = v;
227     cleanup_push(globbed, blk_cleanup);
228 
229     while (*(fileptr = v++) != NULL) {
230 	res = filetest(ftest, &fileptr, TEXP_NOGLOB);
231 	cleanup_push(res, xfree);
232 	xprintf("%" TCSH_S, res);
233 	cleanup_until(res);
234 	if (*v)
235 	    xprintf(" ");
236     }
237     xprintf("\n");
238 
239     cleanup_until(globbed);
240 }
241 
242 void
prvars(void)243 prvars(void)
244 {
245     plist(&shvhed, VAR_ALL);
246 }
247 
248 /*ARGSUSED*/
249 void
doalias(Char ** v,struct command * c)250 doalias(Char **v, struct command *c)
251 {
252     struct varent *vp;
253     Char *p;
254 
255     USE(c);
256     v++;
257     p = *v++;
258     if (p == 0)
259 	plist(&aliases, VAR_ALL);
260     else if (*v == 0) {
261 	vp = adrof1(strip(p), &aliases);
262 	if (vp && vp->vec)
263 	    blkpr(vp->vec), xputchar('\n');
264     }
265     else {
266 	if (eq(p, STRalias) || eq(p, STRunalias)) {
267 	    setname(short2str(p));
268 	    stderror(ERR_NAME | ERR_DANGER);
269 	}
270 	set1(strip(p), saveblk(v), &aliases, VAR_READWRITE);
271 	tw_cmd_free();
272     }
273 }
274 
275 /*ARGSUSED*/
276 void
unalias(Char ** v,struct command * c)277 unalias(Char **v, struct command *c)
278 {
279     USE(c);
280     unset1(v, &aliases);
281     tw_cmd_free();
282 }
283 
284 /*ARGSUSED*/
285 void
dologout(Char ** v,struct command * c)286 dologout(Char **v, struct command *c)
287 {
288     USE(c);
289     USE(v);
290     islogin();
291     goodbye(NULL, NULL);
292 }
293 
294 /*ARGSUSED*/
295 void
dologin(Char ** v,struct command * c)296 dologin(Char **v, struct command *c)
297 {
298 #ifdef WINNT_NATIVE
299     USE(c);
300     USE(v);
301 #else /* !WINNT_NATIVE */
302     char **p = short2blk(v);
303 
304     USE(c);
305     cleanup_push((Char **)p, blk_cleanup);
306     islogin();
307     rechist(NULL, adrof(STRsavehist) != NULL);
308     sigaction(SIGTERM, &parterm, NULL);
309     (void) execv(_PATH_BIN_LOGIN, p);
310     (void) execv(_PATH_USRBIN_LOGIN, p);
311     cleanup_until((Char **)p);
312     untty();
313     xexit(1);
314 #endif /* !WINNT_NATIVE */
315 }
316 
317 
318 #ifdef NEWGRP
319 /*ARGSUSED*/
320 void
donewgrp(Char ** v,struct command * c)321 donewgrp(Char **v, struct command *c)
322 {
323     char **p;
324     if (chkstop == 0 && setintr)
325 	panystop(0);
326     sigaction(SIGTERM, &parterm, NULL);
327     p = short2blk(v);
328     /*
329      * From Beto Appleton (beto@aixwiz.austin.ibm.com)
330      * Newgrp can take 2 arguments...
331      */
332     (void) execv(_PATH_BIN_NEWGRP, p);
333     (void) execv(_PATH_USRBIN_NEWGRP, p);
334     blkfree((Char **) p);
335     untty();
336     xexit(1);
337 }
338 #endif /* NEWGRP */
339 
340 static void
islogin(void)341 islogin(void)
342 {
343     if (chkstop == 0 && setintr)
344 	panystop(0);
345     if (loginsh)
346 	return;
347     stderror(ERR_NOTLOGIN);
348 }
349 
350 void
doif(Char ** v,struct command * kp)351 doif(Char **v, struct command *kp)
352 {
353     int i;
354     Char **vv;
355 
356     v++;
357     i = noexec ? 1 : expr(&v);
358     vv = v;
359     if (*vv == NULL)
360 	stderror(ERR_NAME | ERR_EMPTYIF);
361     if (eq(*vv, STRthen)) {
362 	if (*++vv)
363 	    stderror(ERR_NAME | ERR_IMPRTHEN);
364 	setname(short2str(STRthen));
365 	/*
366 	 * If expression was zero, then scan to else , otherwise just fall into
367 	 * following code.
368 	 */
369 	if (!i)
370 	    search(TC_IF, 0, NULL);
371 	return;
372     }
373     /*
374      * Simple command attached to this if. Left shift the node in this tree,
375      * munging it so we can reexecute it.
376      */
377     if (i) {
378 	lshift(kp->t_dcom, vv - kp->t_dcom);
379 	reexecute(kp);
380 	donefds();
381     }
382 }
383 
384 /*
385  * Reexecute a command, being careful not
386  * to redo i/o redirection, which is already set up.
387  */
388 void
reexecute(struct command * kp)389 reexecute(struct command *kp)
390 {
391     kp->t_dflg &= F_SAVE;
392     kp->t_dflg |= F_REPEAT;
393     /*
394      * If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
395      * pgrp's as the jobs would then have no way to get the tty (we can't give
396      * it to them, and our parent wouldn't know their pgrp, etc.
397      */
398     execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL, TRUE);
399 }
400 
401 /*ARGSUSED*/
402 void
doelse(Char ** v,struct command * c)403 doelse (Char **v, struct command *c)
404 {
405     USE(c);
406     USE(v);
407     if (!noexec)
408 	search(TC_ELSE, 0, NULL);
409 }
410 
411 /*ARGSUSED*/
412 void
dogoto(Char ** v,struct command * c)413 dogoto(Char **v, struct command *c)
414 {
415     Char   *lp;
416 
417     USE(c);
418     lp = globone(v[1], G_ERROR);
419     cleanup_push(lp, xfree);
420     if (!noexec)
421 	gotolab(lp);
422     cleanup_until(lp);
423 }
424 
425 void
gotolab(Char * lab)426 gotolab(Char *lab)
427 {
428     struct whyle *wp;
429     /*
430      * While we still can, locate any unknown ends of existing loops. This
431      * obscure code is the WORST result of the fact that we don't really parse.
432      */
433     zlast = TC_GOTO;
434     for (wp = whyles; wp; wp = wp->w_next)
435 	if (wp->w_end.type == TCSH_F_SEEK && wp->w_end.f_seek == 0) {
436 	    search(TC_BREAK, 0, NULL);
437 	    btell(&wp->w_end);
438 	}
439 	else {
440 	    bseek(&wp->w_end);
441 	}
442     search(TC_GOTO, 0, lab);
443     /*
444      * Eliminate loops which were exited.
445      */
446     wfree();
447 }
448 
449 /*ARGSUSED*/
450 void
doswitch(Char ** v,struct command * c)451 doswitch(Char **v, struct command *c)
452 {
453     Char *cp, *lp;
454 
455     USE(c);
456     v++;
457     if (!*v || *(*v++) != '(')
458 	stderror(ERR_SYNTAX);
459     cp = **v == ')' ? STRNULL : *v++;
460     if (*(*v++) != ')')
461 	v--;
462     if (*v)
463 	stderror(ERR_SYNTAX);
464     lp = globone(cp, G_ERROR);
465     cleanup_push(lp, xfree);
466     if (!noexec)
467 	search(TC_SWITCH, 0, lp);
468     cleanup_until(lp);
469 }
470 
471 /*ARGSUSED*/
472 void
dobreak(Char ** v,struct command * c)473 dobreak(Char **v, struct command *c)
474 {
475     USE(v);
476     USE(c);
477     if (whyles == NULL)
478 	stderror(ERR_NAME | ERR_NOTWHILE);
479     if (!noexec)
480 	toend();
481 }
482 
483 /*ARGSUSED*/
484 void
doexit(Char ** v,struct command * c)485 doexit(Char **v, struct command *c)
486 {
487     USE(c);
488 
489     if (chkstop == 0 && (intty || intact) && evalvec == 0)
490 	panystop(0);
491     /*
492      * Don't DEMAND parentheses here either.
493      */
494     v++;
495     if (*v) {
496 	setstrstatus(putn(expr(&v)));
497 	if (*v)
498 	    stderror(ERR_NAME | ERR_EXPRESSION);
499     }
500     btoeof();
501 #if 0
502     if (intty)
503 #endif
504     /* Always close, why only on ttys? */
505 	xclose(SHIN);
506 }
507 
508 /*ARGSUSED*/
509 void
doforeach(Char ** v,struct command * c)510 doforeach(Char **v, struct command *c)
511 {
512     Char *cp, *sp;
513     struct whyle *nwp;
514     int gflag;
515 
516     USE(c);
517     v++;
518     cp = sp = strip(*v);
519     if (!letter(*cp))
520 	stderror(ERR_NAME | ERR_VARBEGIN);
521     do {
522 	cp++;
523     } while (alnum(*cp));
524     if (*cp != '\0')
525 	stderror(ERR_NAME | ERR_VARALNUM);
526     cp = *v++;
527     if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
528 	stderror(ERR_NAME | ERR_NOPAREN);
529     v++;
530     gflag = tglob(v);
531     if (gflag) {
532 	v = globall(v, gflag);
533 	if (v == 0 && !noexec)
534 	    stderror(ERR_NAME | ERR_NOMATCH);
535     }
536     else {
537 	v = saveblk(v);
538 	trim(v);
539     }
540     nwp = xcalloc(1, sizeof *nwp);
541     nwp->w_fe = nwp->w_fe0 = v;
542     btell(&nwp->w_start);
543     nwp->w_fename = Strsave(cp);
544     nwp->w_next = whyles;
545     nwp->w_end.type = TCSH_F_SEEK;
546     whyles = nwp;
547     /*
548      * Pre-read the loop so as to be more comprehensible to a terminal user.
549      */
550     zlast = TC_FOREACH;
551     if (intty)
552 	preread();
553     if (!noexec)
554 	doagain();
555 }
556 
557 /*ARGSUSED*/
558 void
dowhile(Char ** v,struct command * c)559 dowhile(Char **v, struct command *c)
560 {
561     int status;
562     int again = whyles != 0 &&
563 			  SEEKEQ(&whyles->w_start, &lineloc) &&
564 			  whyles->w_fename == 0;
565 
566     USE(c);
567     v++;
568     /*
569      * Implement prereading here also, taking care not to evaluate the
570      * expression before the loop has been read up from a terminal.
571      */
572     if (noexec)
573 	status = 0;
574     else if (intty && !again)
575 	status = !exp0(&v, 1);
576     else
577 	status = !expr(&v);
578     if (*v && !noexec)
579 	stderror(ERR_NAME | ERR_EXPRESSION);
580     if (!again) {
581 	struct whyle *nwp = xcalloc(1, sizeof(*nwp));
582 
583 	nwp->w_start = lineloc;
584 	nwp->w_end.type = TCSH_F_SEEK;
585 	nwp->w_end.f_seek = 0;
586 	nwp->w_end.a_seek = 0;
587 	nwp->w_next = whyles;
588 	whyles = nwp;
589 	zlast = TC_WHILE;
590 	if (intty) {
591 	    /*
592 	     * The tty preread
593 	     */
594 	    preread();
595 	    doagain();
596 	    return;
597 	}
598     }
599     if (status)
600 	/* We ain't gonna loop no more, no more! */
601 	toend();
602 }
603 
604 static void
preread(void)605 preread(void)
606 {
607     int old_pintr_disabled;
608 
609     whyles->w_end.type = TCSH_I_SEEK;
610     if (setintr)
611 	pintr_push_enable(&old_pintr_disabled);
612     search(TC_BREAK, 0, NULL);		/* read the expression in */
613     if (setintr)
614 	cleanup_until(&old_pintr_disabled);
615     btell(&whyles->w_end);
616 }
617 
618 /*ARGSUSED*/
619 void
doend(Char ** v,struct command * c)620 doend(Char **v, struct command *c)
621 {
622     USE(v);
623     USE(c);
624     if (!whyles)
625 	stderror(ERR_NAME | ERR_NOTWHILE);
626     btell(&whyles->w_end);
627     if (!noexec)
628 	doagain();
629 }
630 
631 /*ARGSUSED*/
632 void
docontin(Char ** v,struct command * c)633 docontin(Char **v, struct command *c)
634 {
635     USE(v);
636     USE(c);
637     if (!whyles)
638 	stderror(ERR_NAME | ERR_NOTWHILE);
639     if (!noexec)
640 	doagain();
641 }
642 
643 static void
doagain(void)644 doagain(void)
645 {
646     /* Repeating a while is simple */
647     if (whyles->w_fename == 0) {
648 	bseek(&whyles->w_start);
649 	return;
650     }
651     /*
652      * The foreach variable list actually has a spurious word ")" at the end of
653      * the w_fe list.  Thus we are at the of the list if one word beyond this
654      * is 0.
655      */
656     if (!whyles->w_fe[1]) {
657 	dobreak(NULL, NULL);
658 	return;
659     }
660     setv(whyles->w_fename, quote(Strsave(*whyles->w_fe++)), VAR_READWRITE);
661     bseek(&whyles->w_start);
662 }
663 
664 void
dorepeat(Char ** v,struct command * kp)665 dorepeat(Char **v, struct command *kp)
666 {
667     int i = 1;
668 
669     do {
670 	i *= getn(v[1]);
671 	lshift(v, 2);
672     } while (v[0] != NULL && Strcmp(v[0], STRrepeat) == 0);
673     if (noexec)
674 	i = 1;
675 
676     if (setintr) {
677 	pintr_disabled++;
678 	cleanup_push(&pintr_disabled, disabled_cleanup);
679     }
680     while (i > 0) {
681 	if (setintr && pintr_disabled == 1) {
682 	    cleanup_until(&pintr_disabled);
683 	    pintr_disabled++;
684 	    cleanup_push(&pintr_disabled, disabled_cleanup);
685 	}
686 	reexecute(kp);
687 	--i;
688     }
689     if (setintr && pintr_disabled == 1)
690         cleanup_until(&pintr_disabled);
691     donefds();
692 }
693 
694 /*ARGSUSED*/
695 void
doswbrk(Char ** v,struct command * c)696 doswbrk(Char **v, struct command *c)
697 {
698     USE(v);
699     USE(c);
700     if (!noexec)
701 	search(TC_BRKSW, 0, NULL);
702 }
703 
704 int
srchx(Char * cp)705 srchx(Char *cp)
706 {
707     struct srch *sp, *sp1, *sp2;
708     int i;
709 
710     /*
711      * Ignore keywords inside heredocs
712      */
713     if (inheredoc)
714 	return -1;
715 
716     /*
717      * Binary search Sp1 is the beginning of the current search range. Sp2 is
718      * one past the end.
719      */
720     for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
721 	sp = sp1 + ((sp2 - sp1) >> 1);
722 	if ((i = *cp - *sp->s_name) == 0 &&
723 	    (i = Strcmp(cp, str2short(sp->s_name))) == 0)
724 	    return sp->s_value;
725 	if (i < 0)
726 	    sp2 = sp;
727 	else
728 	    sp1 = sp + 1;
729     }
730     return (-1);
731 }
732 
733 static const char *
isrchx(int n)734 isrchx(int n)
735 {
736     struct srch *sp, *sp2;
737 
738     for (sp = srchn, sp2 = srchn + nsrchn; sp < sp2; sp++)
739 	if (sp->s_value == n)
740 	    return (sp->s_name);
741     return ("");
742 }
743 
744 
745 static int Stype;
746 static Char *Sgoal;
747 
748 static void
search(int type,int level,Char * goal)749 search(int type, int level, Char *goal)
750 {
751     struct Strbuf word = Strbuf_INIT;
752     Char *cp;
753     struct whyle *wp;
754     int wlevel = 0;
755     struct wordent *histent = NULL, *ohistent = NULL;
756 
757     Stype = type;
758     Sgoal = goal;
759     if (type == TC_GOTO) {
760 	struct Ain a;
761 	a.type = TCSH_F_SEEK;
762 	a.f_seek = 0;
763 	a.a_seek = 0;
764 	bseek(&a);
765     }
766     cleanup_push(&word, Strbuf_cleanup);
767     do {
768 
769 	if (intty) {
770 	    histent = xmalloc(sizeof(*histent));
771 	    ohistent = xmalloc(sizeof(*histent));
772 	    ohistent->word = STRNULL;
773 	    ohistent->next = histent;
774 	    histent->prev = ohistent;
775 	}
776 
777 	if (intty && fseekp == feobp && aret == TCSH_F_SEEK)
778 	    printprompt(1, isrchx(type == TC_BREAK ? zlast : type));
779 	/* xprintf("? "), flush(); */
780 	(void) getword(&word);
781 	Strbuf_terminate(&word);
782 
783 	if (intty && Strlen(word.s) > 0) {
784 	    histent->word = Strsave(word.s);
785 	    histent->next = xmalloc(sizeof(*histent));
786 	    histent->next->prev = histent;
787 	    histent = histent->next;
788 	}
789 
790 	switch (srchx(word.s)) {
791 
792 	case TC_ELSE:
793 	    if (level == 0 && type == TC_IF)
794 		goto end;
795 	    break;
796 
797 	case TC_IF:
798 	    while (getword(&word)) {
799 		if (intty) {
800 		    histent->word = Strsave(word.s);
801 		    histent->next = xmalloc(sizeof(*histent));
802 		    histent->next->prev = histent;
803 		    histent = histent->next;
804 		}
805 		continue;
806 	    }
807 
808 	    if ((type == TC_IF || type == TC_ELSE) &&
809 		eq(word.s, STRthen))
810 		level++;
811 	    break;
812 
813 	case TC_ENDIF:
814 	    if (type == TC_IF || type == TC_ELSE)
815 		level--;
816 	    break;
817 
818 	case TC_FOREACH:
819 	case TC_WHILE:
820 	    wlevel++;
821 	    if (type == TC_BREAK)
822 		level++;
823 	    break;
824 
825 	case TC_END:
826 	    if (type == TC_BRKSW) {
827 		if (wlevel == 0) {
828 		    wp = whyles;
829 		    if (wp) {
830 			    whyles = wp->w_next;
831 			    wpfree(wp);
832 		    }
833 		}
834 	    }
835 	    if (type == TC_BREAK)
836 		level--;
837 	    wlevel--;
838 	    break;
839 
840 	case TC_SWITCH:
841 	    if (type == TC_SWITCH || type == TC_BRKSW)
842 		level++;
843 	    break;
844 
845 	case TC_ENDSW:
846 	    if (type == TC_SWITCH || type == TC_BRKSW)
847 		level--;
848 	    break;
849 
850 	case TC_LABEL:
851 	    if (type == TC_GOTO && getword(&word) && eq(word.s, goal))
852 		level = -1;
853 	    break;
854 
855 	default:
856 	    if (type != TC_GOTO && (type != TC_SWITCH || level != 0))
857 		break;
858 	    if (word.len == 0 || word.s[word.len - 1] != ':')
859 		break;
860 	    word.s[--word.len] = 0;
861 	    if ((type == TC_GOTO && eq(word.s, goal)) ||
862 		(type == TC_SWITCH && eq(word.s, STRdefault)))
863 		level = -1;
864 	    break;
865 
866 	case TC_CASE:
867 	    if (type != TC_SWITCH || level != 0)
868 		break;
869 	    (void) getword(&word);
870 	    if (word.len != 0 && word.s[word.len - 1] == ':')
871 		word.s[--word.len] = 0;
872 	    cp = strip(Dfix1(word.s));
873 	    cleanup_push(cp, xfree);
874 	    if (Gmatch(goal, cp))
875 		level = -1;
876 	    cleanup_until(cp);
877 	    break;
878 
879 	case TC_DEFAULT:
880 	    if (type == TC_SWITCH && level == 0)
881 		level = -1;
882 	    break;
883 	}
884 	if (intty) {
885 	    ohistent->prev = histgetword(histent);
886 	    ohistent->prev->next = ohistent;
887 	    savehist(ohistent, 0);
888 	    freelex(ohistent);
889 	    xfree(ohistent);
890 	} else
891 	    (void) getword(NULL);
892     } while (level >= 0);
893  end:
894     cleanup_until(&word);
895 }
896 
897 static struct wordent *
histgetword(struct wordent * histent)898 histgetword(struct wordent *histent)
899 {
900     int first;
901     eChar c, d;
902     int e;
903     struct Strbuf *tmp;
904     tmp = xmalloc(sizeof(*tmp));
905     tmp->size = 0;
906     tmp->s = NULL;
907     c = readc(1);
908     d = 0;
909     e = 0;
910     for (;;) {
911 	tmp->len = 0;
912 	Strbuf_terminate (tmp);
913 	while (c == ' ' || c == '\t')
914 	    c = readc(1);
915 	if (c == '#')
916 	    do
917 		c = readc(1);
918 	    while (c != CHAR_ERR && c != '\n');
919 	if (c == CHAR_ERR)
920 	    goto past;
921 	if (c == '\n')
922 	    goto nl;
923 	unreadc(c);
924 	first = 1;
925 	do {
926 	    e = (c == '\\');
927 	    c = readc(1);
928 	    if (c == '\\' && !e) {
929 		if ((c = readc(1)) == '\n') {
930 		    e = 1;
931 		    c = ' ';
932 		} else {
933 		    unreadc(c);
934 		    c = '\\';
935 		}
936 	    }
937 	    if ((c == '\'' || c == '"') && !e) {
938 		if (d == 0)
939 		    d = c;
940 		else if (d == c)
941 		    d = 0;
942 	    }
943 	    if (c == CHAR_ERR)
944 		goto past;
945 
946 	    Strbuf_append1(tmp, (Char) c);
947 
948 	    if (!first && !d && c == '(' && !e) {
949 		break;
950 	    }
951 	    first = 0;
952 	} while (d || e || (c != ' ' && c != '\t' && c != '\n'));
953 	tmp->len--;
954 	if (tmp->len) {
955 	    Strbuf_terminate(tmp);
956 	    histent->word = Strsave(tmp->s);
957 	    histent->next = xmalloc(sizeof (*histent));
958 	    histent->next->prev = histent;
959 	    histent = histent->next;
960 	}
961 	if (c == '\n') {
962 	nl:
963 	    tmp->len = 0;
964 	    Strbuf_append1(tmp, (Char) c);
965 	    Strbuf_terminate(tmp);
966 	    histent->word = Strsave(tmp->s);
967 	    return histent;
968 	}
969     }
970 
971 past:
972     switch (Stype) {
973 
974     case TC_IF:
975 	stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
976 	break;
977 
978     case TC_ELSE:
979 	stderror(ERR_NAME | ERR_NOTFOUND, "endif");
980 	break;
981 
982     case TC_BRKSW:
983     case TC_SWITCH:
984 	stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
985 	break;
986 
987     case TC_BREAK:
988 	stderror(ERR_NAME | ERR_NOTFOUND, "end");
989 	break;
990 
991     case TC_GOTO:
992 	setname(short2str(Sgoal));
993 	stderror(ERR_NAME | ERR_NOTFOUND, "label");
994 	break;
995 
996     default:
997 	break;
998     }
999     /* NOTREACHED */
1000     return NULL;
1001 }
1002 
1003 static int
getword(struct Strbuf * wp)1004 getword(struct Strbuf *wp)
1005 {
1006     int found = 0, first;
1007     eChar c, d;
1008 
1009     if (wp)
1010 	wp->len = 0;
1011     c = readc(1);
1012     d = 0;
1013     do {
1014 	while (c == ' ' || c == '\t')
1015 	    c = readc(1);
1016 	if (c == '#')
1017 	    do
1018 		c = readc(1);
1019 	    while (c != CHAR_ERR && c != '\n');
1020 	if (c == CHAR_ERR)
1021 	    goto past;
1022 	if (c == '\n') {
1023 	    if (wp)
1024 		break;
1025 	    return (0);
1026 	}
1027 	unreadc(c);
1028 	found = 1;
1029 	first = 1;
1030 	do {
1031 	    c = readc(1);
1032 	    if (c == '\\' && (c = readc(1)) == '\n')
1033 		c = ' ';
1034 	    if (c == '\'' || c == '"') {
1035 		if (d == 0)
1036 		    d = c;
1037 		else if (d == c)
1038 		    d = 0;
1039 	    }
1040 	    if (c == CHAR_ERR)
1041 		goto past;
1042 	    if (wp)
1043 		Strbuf_append1(wp, (Char) c);
1044 	    if (!d && c == ')') {
1045 		if (!first && wp) {
1046 		    goto past_word_end;
1047 		} else {
1048 		    if (wp) {
1049 			wp->len = 1;
1050 			Strbuf_terminate(wp);
1051 		    }
1052 		    return found;
1053 		}
1054 	    }
1055 	    if (!first && !d && c == '(') {
1056 		if (wp)
1057 		    goto past_word_end;
1058 		else
1059 		    break;
1060 	    }
1061 	    first = 0;
1062 	} while ((d || (c != ' ' && c != '\t')) && c != '\n');
1063     } while (wp == 0);
1064 
1065  past_word_end:
1066     unreadc(c);
1067     if (found) {
1068 	wp->len--;
1069 	Strbuf_terminate(wp);
1070     }
1071 
1072     return (found);
1073 
1074 past:
1075     switch (Stype) {
1076 
1077     case TC_IF:
1078 	stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
1079 	break;
1080 
1081     case TC_ELSE:
1082 	stderror(ERR_NAME | ERR_NOTFOUND, "endif");
1083 	break;
1084 
1085     case TC_BRKSW:
1086     case TC_SWITCH:
1087 	stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
1088 	break;
1089 
1090     case TC_BREAK:
1091 	stderror(ERR_NAME | ERR_NOTFOUND, "end");
1092 	break;
1093 
1094     case TC_GOTO:
1095 	setname(short2str(Sgoal));
1096 	stderror(ERR_NAME | ERR_NOTFOUND, "label");
1097 	break;
1098 
1099     default:
1100 	break;
1101     }
1102     /* NOTREACHED */
1103     return (0);
1104 }
1105 
1106 static void
toend(void)1107 toend(void)
1108 {
1109     if (whyles->w_end.type == TCSH_F_SEEK && whyles->w_end.f_seek == 0) {
1110 	search(TC_BREAK, 0, NULL);
1111 	btell(&whyles->w_end);
1112 	whyles->w_end.f_seek--;
1113     }
1114     else {
1115 	bseek(&whyles->w_end);
1116     }
1117     wfree();
1118 }
1119 
1120 static void
wpfree(struct whyle * wp)1121 wpfree(struct whyle *wp)
1122 {
1123 	if (wp->w_fe0)
1124 	    blkfree(wp->w_fe0);
1125 	xfree(wp->w_fename);
1126 	xfree(wp);
1127 }
1128 
1129 void
wfree(void)1130 wfree(void)
1131 {
1132     struct Ain    o;
1133     struct whyle *nwp;
1134 #ifdef lint
1135     nwp = NULL;	/* sun lint is dumb! */
1136 #endif
1137 
1138 #ifdef FDEBUG
1139     static const char foo[] = "IAFE";
1140 #endif /* FDEBUG */
1141 
1142     btell(&o);
1143 
1144 #ifdef FDEBUG
1145     xprintf("o->type %c o->a_seek %d o->f_seek %d\n",
1146 	    foo[o.type + 1], o.a_seek, o.f_seek);
1147 #endif /* FDEBUG */
1148 
1149     for (; whyles; whyles = nwp) {
1150 	struct whyle *wp = whyles;
1151 	nwp = wp->w_next;
1152 
1153 #ifdef FDEBUG
1154 	xprintf("start->type %c start->a_seek %d start->f_seek %d\n",
1155 		foo[wp->w_start.type+1],
1156 		wp->w_start.a_seek, wp->w_start.f_seek);
1157 	xprintf("end->type %c end->a_seek %d end->f_seek %d\n",
1158 		foo[wp->w_end.type + 1], wp->w_end.a_seek, wp->w_end.f_seek);
1159 #endif /* FDEBUG */
1160 
1161 	/*
1162 	 * XXX: We free loops that have different seek types.
1163 	 */
1164 	if (wp->w_end.type != TCSH_I_SEEK && wp->w_start.type == wp->w_end.type &&
1165 	    wp->w_start.type == o.type) {
1166 	    if (wp->w_end.type == TCSH_F_SEEK) {
1167 		if (o.f_seek >= wp->w_start.f_seek &&
1168 		    (wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
1169 		    break;
1170 	    }
1171 	    else {
1172 		if (o.a_seek >= wp->w_start.a_seek &&
1173 		    (wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
1174 		    break;
1175 	    }
1176 	}
1177 
1178 	wpfree(wp);
1179     }
1180 }
1181 
1182 /*ARGSUSED*/
1183 void
doecho(Char ** v,struct command * c)1184 doecho(Char **v, struct command *c)
1185 {
1186     USE(c);
1187     xecho(' ', v);
1188 }
1189 
1190 /*ARGSUSED*/
1191 void
doglob(Char ** v,struct command * c)1192 doglob(Char **v, struct command *c)
1193 {
1194     USE(c);
1195     xecho(0, v);
1196     flush();
1197 }
1198 
1199 static void
xecho(int sep,Char ** v)1200 xecho(int sep, Char **v)
1201 {
1202     Char **globbed = NULL;
1203     const Char *cp;
1204     int     nonl = 0;
1205     int	    echo_style = ECHO_STYLE;
1206     struct varent *vp;
1207 
1208     if ((vp = adrof(STRecho_style)) != NULL && vp->vec != NULL &&
1209 	vp->vec[0] != NULL) {
1210 	if (Strcmp(vp->vec[0], STRbsd) == 0)
1211 	    echo_style = BSD_ECHO;
1212 	else if (Strcmp(vp->vec[0], STRsysv) == 0)
1213 	    echo_style = SYSV_ECHO;
1214 	else if (Strcmp(vp->vec[0], STRboth) == 0)
1215 	    echo_style = BOTH_ECHO;
1216 	else if (Strcmp(vp->vec[0], STRnone) == 0)
1217 	    echo_style = NONE_ECHO;
1218     }
1219 
1220     v++;
1221     if (*v == 0)
1222 	goto done;
1223     if (setintr) {
1224 	int old_pintr_disabled;
1225 	pintr_push_enable(&old_pintr_disabled);
1226 	v = glob_all_or_error(v);
1227 	cleanup_until(&old_pintr_disabled);
1228     } else {
1229 	v = glob_all_or_error(v);
1230     }
1231     globbed = v;
1232     if (globbed != NULL)
1233 	cleanup_push(globbed, blk_cleanup);
1234 
1235     if ((echo_style & BSD_ECHO) != 0 && sep == ' ' && *v && eq(*v, STRmn))
1236 	nonl++, v++;
1237 
1238     while ((cp = *v++) != 0) {
1239 	eChar c;
1240 
1241 	if (setintr) {
1242 	    int old_pintr_disabled;
1243 
1244 	    pintr_push_enable(&old_pintr_disabled);
1245 	    cleanup_until(&old_pintr_disabled);
1246 	}
1247 	for (; (c = *cp) != 0; cp++) {
1248 	    if ((echo_style & SYSV_ECHO) != 0 && c == '\\') {
1249 		if ((c = parseescape(&cp, FALSE)) == CHAR_ERR)
1250 		    c = '\\';
1251 	    }
1252 	    xputwchar(c | QUOTE);
1253 	}
1254 	if (*v)
1255 	    xputchar(sep | QUOTE);
1256     }
1257 done:
1258     if (sep && nonl == 0)
1259 	xputchar('\n');
1260     else
1261 	flush();
1262     if (globbed != NULL)
1263 	cleanup_until(globbed);
1264 }
1265 
1266 /* check whether an environment variable should invoke 'set_locale()' */
1267 static int
islocale_var(Char * var)1268 islocale_var(Char *var)
1269 {
1270     static Char *locale_vars[] = {
1271 	STRLANG,	STRLC_ALL, 	STRLC_CTYPE,	STRLC_NUMERIC,
1272 	STRLC_TIME,	STRLC_COLLATE,	STRLC_MESSAGES,	STRLC_MONETARY, 0
1273     };
1274     Char **v;
1275 
1276     for (v = locale_vars; *v; ++v)
1277 	if (eq(var, *v))
1278 	    return 1;
1279     return 0;
1280 }
1281 
1282 static void
xlate_cr_cleanup(void * dummy)1283 xlate_cr_cleanup(void *dummy)
1284 {
1285     USE(dummy);
1286     xlate_cr = 0;
1287 }
1288 
1289 /*ARGSUSED*/
1290 void
doprintenv(Char ** v,struct command * c)1291 doprintenv(Char **v, struct command *c)
1292 {
1293     Char   *e;
1294 
1295     USE(c);
1296     v++;
1297     if (*v == 0) {
1298 	Char **ep;
1299 
1300 	xlate_cr = 1;
1301 	cleanup_push(&xlate_cr, xlate_cr_cleanup);
1302 	for (ep = STR_environ; *ep; ep++) {
1303 	    if (setintr) {
1304 		int old_pintr_disabled;
1305 
1306 		pintr_push_enable(&old_pintr_disabled);
1307 		cleanup_until(&old_pintr_disabled);
1308 	    }
1309 	    xprintf("%" TCSH_S "\n", *ep);
1310 	}
1311 	cleanup_until(&xlate_cr);
1312     }
1313     else if ((e = tgetenv(*v)) != NULL) {
1314 	int old_output_raw;
1315 
1316 	old_output_raw = output_raw;
1317 	output_raw = 1;
1318 	cleanup_push(&old_output_raw, output_raw_restore);
1319 	xprintf("%" TCSH_S "\n", e);
1320 	cleanup_until(&old_output_raw);
1321     }
1322     else
1323 	setstatus(1);
1324 }
1325 
1326 /* from "Karl Berry." <karl%mote.umb.edu@relay.cs.net> -- for NeXT things
1327    (and anything else with a modern compiler) */
1328 
1329 /*ARGSUSED*/
1330 void
dosetenv(Char ** v,struct command * c)1331 dosetenv(Char **v, struct command *c)
1332 {
1333     Char   *vp, *lp;
1334 
1335     USE(c);
1336     if (*++v == 0) {
1337 	doprintenv(--v, 0);
1338 	return;
1339     }
1340 
1341     vp = *v++;
1342     lp = vp;
1343 
1344     if (!letter(*lp))
1345 	stderror(ERR_NAME | ERR_VARBEGIN);
1346     do {
1347 	lp++;
1348     } while (alnum(*lp) || *lp == '.');
1349     if (*lp != '\0')
1350 	stderror(ERR_NAME | ERR_VARALNUM);
1351 
1352     if ((lp = *v++) == 0)
1353 	lp = STRNULL;
1354 
1355     lp = globone(lp, G_APPEND);
1356     cleanup_push(lp, xfree);
1357     tsetenv(vp, lp);
1358     if (eq(vp, STRKPATH)) {
1359         importpath(lp);
1360 	dohash(NULL, NULL);
1361 	cleanup_until(lp);
1362 	return;
1363     }
1364 
1365 #ifdef apollo
1366     if (eq(vp, STRSYSTYPE)) {
1367 	dohash(NULL, NULL);
1368 	cleanup_until(lp);
1369 	return;
1370     }
1371 #endif /* apollo */
1372 
1373     /* dspkanji/dspmbyte autosetting */
1374     /* PATCH IDEA FROM Issei.Suzuki VERY THANKS */
1375 #if defined(DSPMBYTE)
1376     if (eq(vp, STRLANG) && !adrof(CHECK_MBYTEVAR)) {
1377 	autoset_dspmbyte(lp);
1378     }
1379 #endif
1380 
1381     if (islocale_var(vp)) {
1382 #ifdef NLS
1383 	int     k;
1384 
1385 # ifdef SETLOCALEBUG
1386 	dont_free = 1;
1387 # endif /* SETLOCALEBUG */
1388 	(void) setlocale(LC_ALL, "");
1389 # ifdef LC_COLLATE
1390 	(void) setlocale(LC_COLLATE, "");
1391 # endif
1392 # ifdef LC_CTYPE
1393 	(void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1394 # endif /* LC_CTYPE */
1395 # if defined(AUTOSET_KANJI)
1396         autoset_kanji();
1397 # endif /* AUTOSET_KANJI */
1398 # ifdef NLS_CATALOGS
1399 #  ifdef LC_MESSAGES
1400 	(void) setlocale(LC_MESSAGES, "");
1401 #  endif /* LC_MESSAGES */
1402 	nlsclose();
1403 	nlsinit();
1404 # endif /* NLS_CATALOGS */
1405 # ifdef SETLOCALEBUG
1406 	dont_free = 0;
1407 # endif /* SETLOCALEBUG */
1408 # ifdef STRCOLLBUG
1409 	fix_strcoll_bug();
1410 # endif /* STRCOLLBUG */
1411 	tw_cmd_free();	/* since the collation sequence has changed */
1412 	for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1413 	    continue;
1414 	AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1415 #else /* !NLS */
1416 	AsciiOnly = 0;
1417 #endif /* NLS */
1418 	NLSMapsAreInited = 0;
1419 	ed_Init();
1420 	if (MapsAreInited && !NLSMapsAreInited)
1421 	    ed_InitNLSMaps();
1422 	cleanup_until(lp);
1423 	return;
1424     }
1425 
1426 #ifdef NLS_CATALOGS
1427     if (eq(vp, STRNLSPATH)) {
1428 	nlsclose();
1429 	nlsinit();
1430     }
1431 #endif
1432 
1433     if (eq(vp, STRNOREBIND)) {
1434 	NoNLSRebind = 1;
1435 	MapsAreInited = 0;
1436 	NLSMapsAreInited = 0;
1437 	ed_InitMaps();
1438 	cleanup_until(lp);
1439 	return;
1440     }
1441 #ifdef WINNT_NATIVE
1442     if (eq(vp, STRtcshlang)) {
1443 	nlsinit();
1444 	cleanup_until(lp);
1445 	return;
1446     }
1447 #endif /* WINNT_NATIVE */
1448     if (eq(vp, STRKTERM)) {
1449 	char *t;
1450 
1451 	setv(STRterm, quote(lp), VAR_READWRITE);	/* lp memory used here */
1452 	cleanup_ignore(lp);
1453 	cleanup_until(lp);
1454 	t = short2str(lp);
1455 	if (noediting && strcmp(t, "unknown") != 0 && strcmp(t,"dumb") != 0) {
1456 	    editing = 1;
1457 	    noediting = 0;
1458 	    setNS(STRedit);
1459 	}
1460 	GotTermCaps = 0;
1461 	ed_Init();
1462 	return;
1463     }
1464 
1465     if (eq(vp, STRKHOME)) {
1466 	Char *canon;
1467 	/*
1468 	 * convert to canonical pathname (possibly resolving symlinks)
1469 	 */
1470 	cleanup_ignore(lp);
1471 	canon = dcanon(lp, lp);
1472 	cleanup_push(canon, xfree);
1473 	setv(STRhome, quote(canon), VAR_READWRITE); /* lp memory used here */
1474 	cleanup_ignore(canon);
1475 	cleanup_until(canon);
1476 
1477 	/* fix directory stack for new tilde home */
1478 	dtilde();
1479 	return;
1480     }
1481 
1482     if (eq(vp, STRKSHLVL)) {
1483 	setv(STRshlvl, quote(lp), VAR_READWRITE); /* lp memory used here */
1484 	cleanup_ignore(lp);
1485 	cleanup_until(lp);
1486 	return;
1487     }
1488 
1489     if (eq(vp, STRKUSER)) {
1490 	setv(STRuser, quote(lp), VAR_READWRITE);	/* lp memory used here */
1491 	cleanup_ignore(lp);
1492 	cleanup_until(lp);
1493 	return;
1494     }
1495 
1496     if (eq(vp, STRKGROUP)) {
1497 	setv(STRgroup, quote(lp), VAR_READWRITE); /* lp memory used here */
1498 	cleanup_ignore(lp);
1499 	cleanup_until(lp);
1500 	return;
1501     }
1502 
1503 #ifdef COLOR_LS_F
1504     if (eq(vp, STRLS_COLORS)) {
1505         parseLS_COLORS(lp);
1506 	cleanup_until(lp);
1507 	return;
1508     }
1509     if (eq(vp, STRLSCOLORS)) {
1510         parseLSCOLORS(lp);
1511 	cleanup_until(lp);
1512 	return;
1513     }
1514 #endif /* COLOR_LS_F */
1515 
1516 #ifdef SIG_WINDOW
1517     /*
1518      * Load/Update $LINES $COLUMNS
1519      */
1520     if ((eq(lp, STRNULL) && (eq(vp, STRLINES) || eq(vp, STRCOLUMNS))) ||
1521 	eq(vp, STRTERMCAP)) {
1522 	cleanup_until(lp);
1523 	check_window_size(1);
1524 	return;
1525     }
1526 
1527     /*
1528      * Change the size to the one directed by $LINES and $COLUMNS
1529      */
1530     if (eq(vp, STRLINES) || eq(vp, STRCOLUMNS)) {
1531 #if 0
1532 	GotTermCaps = 0;
1533 #endif
1534 	cleanup_until(lp);
1535 	ed_Init();
1536 	return;
1537     }
1538 #endif /* SIG_WINDOW */
1539     cleanup_until(lp);
1540 }
1541 
1542 /*ARGSUSED*/
1543 void
dounsetenv(Char ** v,struct command * c)1544 dounsetenv(Char **v, struct command *c)
1545 {
1546     Char  **ep, *p, *n, *name;
1547     int     i, maxi;
1548 
1549     USE(c);
1550     /*
1551      * Find the longest environment variable
1552      */
1553     for (maxi = 0, ep = STR_environ; *ep; ep++) {
1554 	for (i = 0, p = *ep; *p && *p != '='; p++, i++)
1555 	    continue;
1556 	if (i > maxi)
1557 	    maxi = i;
1558     }
1559 
1560     name = xmalloc((maxi + 1) * sizeof(Char));
1561     cleanup_push(name, xfree);
1562 
1563     while (++v && *v)
1564 	for (maxi = 1; maxi;)
1565 	    for (maxi = 0, ep = STR_environ; *ep; ep++) {
1566 		for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
1567 		    continue;
1568 		*n = '\0';
1569 		if (!Gmatch(name, *v))
1570 		    continue;
1571 		maxi = 1;
1572 
1573 		/* Unset the name. This wasn't being done until
1574 		 * later but most of the stuff following won't
1575 		 * work (particularly the setlocale() and getenv()
1576 		 * stuff) as intended until the name is actually
1577 		 * removed. (sg)
1578 		 */
1579 		Unsetenv(name);
1580 
1581 		if (eq(name, STRNOREBIND)) {
1582 		    NoNLSRebind = 0;
1583 		    MapsAreInited = 0;
1584 		    NLSMapsAreInited = 0;
1585 		    ed_InitMaps();
1586 		}
1587 #ifdef apollo
1588 		else if (eq(name, STRSYSTYPE))
1589 		    dohash(NULL, NULL);
1590 #endif /* apollo */
1591 		else if (islocale_var(name)) {
1592 #ifdef NLS
1593 		    int     k;
1594 
1595 # ifdef SETLOCALEBUG
1596 		    dont_free = 1;
1597 # endif /* SETLOCALEBUG */
1598 		    (void) setlocale(LC_ALL, "");
1599 # ifdef LC_COLLATE
1600 		    (void) setlocale(LC_COLLATE, "");
1601 # endif
1602 # ifdef LC_CTYPE
1603 		    (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1604 # endif /* LC_CTYPE */
1605 # ifdef NLS_CATALOGS
1606 #  ifdef LC_MESSAGES
1607 		    (void) setlocale(LC_MESSAGES, "");
1608 #  endif /* LC_MESSAGES */
1609 		    nlsclose();
1610 		    nlsinit();
1611 # endif /* NLS_CATALOGS */
1612 # ifdef SETLOCALEBUG
1613 		    dont_free = 0;
1614 # endif /* SETLOCALEBUG */
1615 # ifdef STRCOLLBUG
1616 		    fix_strcoll_bug();
1617 # endif /* STRCOLLBUG */
1618 		    tw_cmd_free();/* since the collation sequence has changed */
1619 		    for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1620 			continue;
1621 		    AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1622 #else /* !NLS */
1623 		    AsciiOnly = getenv("LANG") == NULL &&
1624 			getenv("LC_CTYPE") == NULL;
1625 #endif /* NLS */
1626 		    NLSMapsAreInited = 0;
1627 		    ed_Init();
1628 		    if (MapsAreInited && !NLSMapsAreInited)
1629 			ed_InitNLSMaps();
1630 
1631 		}
1632 #ifdef WINNT_NATIVE
1633 		else if (eq(name,(STRtcshlang))) {
1634 		    nls_dll_unload();
1635 		    nlsinit();
1636 		}
1637 #endif /* WINNT_NATIVE */
1638 #ifdef COLOR_LS_F
1639 		else if (eq(name, STRLS_COLORS))
1640 		    parseLS_COLORS(n);
1641 		else if (eq(name, STRLSCOLORS))
1642 		    parseLSCOLORS(n);
1643 #endif /* COLOR_LS_F */
1644 #ifdef NLS_CATALOGS
1645 		else if (eq(name, STRNLSPATH)) {
1646 		    nlsclose();
1647 		    nlsinit();
1648 		}
1649 #endif
1650 		/*
1651 		 * start again cause the environment changes
1652 		 */
1653 		break;
1654 	    }
1655     cleanup_until(name);
1656 }
1657 
1658 void
tsetenv(const Char * name,const Char * val)1659 tsetenv(const Char *name, const Char *val)
1660 {
1661 #ifdef SETENV_IN_LIB
1662 /*
1663  * XXX: This does not work right, since tcsh cannot track changes to
1664  * the environment this way. (the builtin setenv without arguments does
1665  * not print the right stuff neither does unsetenv). This was for Mach,
1666  * it is not needed anymore.
1667  */
1668 #undef setenv
1669     char   *cname;
1670 
1671     if (name == NULL)
1672 	return;
1673     cname = strsave(short2str(name));
1674     setenv(cname, short2str(val), 1);
1675     xfree(cname);
1676 #else /* !SETENV_IN_LIB */
1677     Char **ep = STR_environ;
1678     const Char *ccp;
1679     Char *cp, *dp;
1680     Char   *blk[2];
1681     Char  **oep = ep;
1682 
1683 #ifdef WINNT_NATIVE
1684     nt_set_env(name,val);
1685 #endif /* WINNT_NATIVE */
1686     for (; *ep; ep++) {
1687 #ifdef WINNT_NATIVE
1688 	for (ccp = name, dp = *ep; *ccp && Tolower(*ccp & TRIM) == Tolower(*dp);
1689 				ccp++, dp++)
1690 #else
1691 	for (ccp = name, dp = *ep; *ccp && (*ccp & TRIM) == *dp; ccp++, dp++)
1692 #endif /* WINNT_NATIVE */
1693 	    continue;
1694 	if (*ccp != 0 || *dp != '=')
1695 	    continue;
1696 	cp = Strspl(STRequal, val);
1697 	xfree(*ep);
1698 	*ep = strip(Strspl(name, cp));
1699 	xfree(cp);
1700 	blkfree((Char **) environ);
1701 	environ = short2blk(STR_environ);
1702 	return;
1703     }
1704     cp = Strspl(name, STRequal);
1705     blk[0] = strip(Strspl(cp, val));
1706     xfree(cp);
1707     blk[1] = 0;
1708     STR_environ = blkspl(STR_environ, blk);
1709     blkfree((Char **) environ);
1710     environ = short2blk(STR_environ);
1711     xfree(oep);
1712 #endif /* SETENV_IN_LIB */
1713 }
1714 
1715 void
Unsetenv(Char * name)1716 Unsetenv(Char *name)
1717 {
1718     Char **ep = STR_environ;
1719     Char *cp, *dp;
1720     Char **oep = ep;
1721 
1722 #ifdef WINNT_NATIVE
1723 	nt_set_env(name,NULL);
1724 #endif /*WINNT_NATIVE */
1725     for (; *ep; ep++) {
1726 	for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
1727 	    continue;
1728 	if (*cp != 0 || *dp != '=')
1729 	    continue;
1730 	cp = *ep;
1731 	*ep = 0;
1732 	STR_environ = blkspl(STR_environ, ep + 1);
1733 	blkfree((Char **) environ);
1734 	environ = short2blk(STR_environ);
1735 	*ep = cp;
1736 	xfree(cp);
1737 	xfree(oep);
1738 	return;
1739     }
1740 }
1741 
1742 /*ARGSUSED*/
1743 void
doumask(Char ** v,struct command * c)1744 doumask(Char **v, struct command *c)
1745 {
1746     Char *cp = v[1];
1747     int i;
1748 
1749     USE(c);
1750     if (cp == 0) {
1751 	i = (int)umask(0);
1752 	(void) umask(i);
1753 	xprintf("%o\n", i);
1754 	return;
1755     }
1756     i = 0;
1757     while (Isdigit(*cp) && *cp != '8' && *cp != '9')
1758 	i = i * 8 + *cp++ - '0';
1759     if (*cp || i < 0 || i > 0777)
1760 	stderror(ERR_NAME | ERR_MASK);
1761     (void) umask(i);
1762 }
1763 
1764 #ifndef HAVENOLIMIT
1765 # ifndef BSDLIMIT
1766    typedef long RLIM_TYPE;
1767 #  ifdef _OSD_POSIX /* BS2000 */
1768 #   include <ulimit.h>
1769 #  endif
1770 #  ifndef RLIM_INFINITY
1771 #   if !defined(_MINIX) && !defined(__clipper__) && !defined(_CRAY)
1772     extern RLIM_TYPE ulimit();
1773 #   endif /* ! _MINIX && !__clipper__ */
1774 #   define RLIM_INFINITY 0x003fffff
1775 #   define RLIMIT_FSIZE 1
1776 #  endif /* RLIM_INFINITY */
1777 #  ifdef aiws
1778 #   define toset(a) (((a) == 3) ? 1004 : (a) + 1)
1779 #   define RLIMIT_DATA	3
1780 #   define RLIMIT_STACK 1005
1781 #  else /* aiws */
1782 #   define toset(a) ((a) + 1)
1783 #  endif /* aiws */
1784 # else /* BSDLIMIT */
1785 #  if (defined(BSD4_4) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (HPUXVERSION >= 1100)) && !defined(__386BSD__)
1786     typedef rlim_t RLIM_TYPE;
1787 #  else
1788 #   if defined(SOLARIS2) || (defined(sgi) && SYSVREL > 3)
1789      typedef rlim_t RLIM_TYPE;
1790 #   else
1791 #    if defined(_SX)
1792       typedef long long RLIM_TYPE;
1793 #    else /* !_SX */
1794       typedef unsigned long RLIM_TYPE;
1795 #    endif /* _SX */
1796 #   endif /* SOLARIS2 || (sgi && SYSVREL > 3) */
1797 #  endif /* BSD4_4 && !__386BSD__  */
1798 # endif /* BSDLIMIT */
1799 
1800 # if (HPUXVERSION > 700) && (HPUXVERSION < 1100) && defined(BSDLIMIT)
1801 /* Yes hpux8.0 has limits but <sys/resource.h> does not make them public */
1802 /* Yes, we could have defined _KERNEL, and -I/etc/conf/h, but is that better? */
1803 #  ifndef RLIMIT_CPU
1804 #   define RLIMIT_CPU		0
1805 #   define RLIMIT_FSIZE		1
1806 #   define RLIMIT_DATA		2
1807 #   define RLIMIT_STACK		3
1808 #   define RLIMIT_CORE		4
1809 #   define RLIMIT_RSS		5
1810 #   define RLIMIT_NOFILE	6
1811 #  endif /* RLIMIT_CPU */
1812 #  ifndef RLIM_INFINITY
1813 #   define RLIM_INFINITY	0x7fffffff
1814 #  endif /* RLIM_INFINITY */
1815    /*
1816     * old versions of HP/UX counted limits in 512 bytes
1817     */
1818 #  ifndef SIGRTMIN
1819 #   define FILESIZE512
1820 #  endif /* SIGRTMIN */
1821 # endif /* (HPUXVERSION > 700) && (HPUXVERSION < 1100) && BSDLIMIT */
1822 
1823 # if SYSVREL > 3 && defined(BSDLIMIT) && !defined(_SX)
1824 /* In order to use rusage, we included "/usr/ucbinclude/sys/resource.h" in */
1825 /* sh.h.  However, some SVR4 limits are defined in <sys/resource.h>.  Rather */
1826 /* than include both and get warnings, we define the extra SVR4 limits here. */
1827 /* XXX: I don't understand if RLIMIT_AS is defined, why don't we define */
1828 /* RLIMIT_VMEM based on it? */
1829 #  ifndef RLIMIT_VMEM
1830 #   define RLIMIT_VMEM	6
1831 #  endif
1832 #  ifndef RLIMIT_AS
1833 #   define RLIMIT_AS	RLIMIT_VMEM
1834 #  endif
1835 # endif /* SYSVREL > 3 && BSDLIMIT */
1836 
1837 # if (defined(__linux__) || defined(__GNU__) || defined(__GLIBC__))
1838 #  if defined(RLIMIT_AS) && !defined(RLIMIT_VMEM)
1839 #   define RLIMIT_VMEM	RLIMIT_AS
1840 #  endif
1841 /*
1842  * Oh well, <asm-generic/resource.h> has it, but <bits/resource.h> does not
1843  * Linux headers: When the left hand does not know what the right hand does.
1844  */
1845 #  if defined(RLIMIT_RTPRIO) && !defined(RLIMIT_RTTIME)
1846 #   define RLIMIT_RTTIME (RLIMIT_RTPRIO + 1)
1847 #  endif
1848 # endif
1849 
1850 struct limits limits[] =
1851 {
1852 # ifdef RLIMIT_CPU
1853     { RLIMIT_CPU, 	"cputime",	1,	"seconds"	},
1854 # endif /* RLIMIT_CPU */
1855 
1856 # ifdef RLIMIT_FSIZE
1857 #  ifndef aiws
1858     { RLIMIT_FSIZE, 	"filesize",	1024,	"kbytes"	},
1859 #  else
1860     { RLIMIT_FSIZE, 	"filesize",	512,	"blocks"	},
1861 #  endif /* aiws */
1862 # endif /* RLIMIT_FSIZE */
1863 
1864 # ifdef RLIMIT_DATA
1865     { RLIMIT_DATA, 	"datasize",	1024,	"kbytes"	},
1866 # endif /* RLIMIT_DATA */
1867 
1868 # ifdef RLIMIT_STACK
1869 #  ifndef aiws
1870     { RLIMIT_STACK, 	"stacksize",	1024,	"kbytes"	},
1871 #  else
1872     { RLIMIT_STACK, 	"stacksize",	1024 * 1024,	"kbytes"},
1873 #  endif /* aiws */
1874 # endif /* RLIMIT_STACK */
1875 
1876 # ifdef RLIMIT_CORE
1877     { RLIMIT_CORE, 	"coredumpsize",	1024,	"kbytes"	},
1878 # endif /* RLIMIT_CORE */
1879 
1880 # ifdef RLIMIT_RSS
1881     { RLIMIT_RSS, 	"memoryuse",	1024,	"kbytes"	},
1882 # endif /* RLIMIT_RSS */
1883 
1884 # ifdef RLIMIT_UMEM
1885     { RLIMIT_UMEM, 	"memoryuse",	1024,	"kbytes"	},
1886 # endif /* RLIMIT_UMEM */
1887 
1888 # ifdef RLIMIT_VMEM
1889     { RLIMIT_VMEM, 	"vmemoryuse",	1024,	"kbytes"	},
1890 # endif /* RLIMIT_VMEM */
1891 
1892 # if defined(RLIMIT_HEAP) /* found on BS2000/OSD systems */
1893     { RLIMIT_HEAP,	"heapsize",	1024,	"kbytes"	},
1894 # endif /* RLIMIT_HEAP */
1895 
1896 # ifdef RLIMIT_NOFILE
1897     { RLIMIT_NOFILE, 	"descriptors", 1,	""		},
1898 # endif /* RLIMIT_NOFILE */
1899 
1900 # ifdef RLIMIT_NPTS
1901     { RLIMIT_NPTS,	"pseudoterminals", 1,	""		},
1902 # endif /* RLIMIT_NPTS */
1903 
1904 # ifdef RLIMIT_KQUEUES
1905     { RLIMIT_KQUEUES,	"kqueues",	1,	""		},
1906 # endif /* RLIMIT_KQUEUES */
1907 
1908 # ifdef RLIMIT_CONCUR
1909     { RLIMIT_CONCUR, 	"concurrency", 1,	"thread(s)"	},
1910 # endif /* RLIMIT_CONCUR */
1911 
1912 # ifdef RLIMIT_MEMLOCK
1913     { RLIMIT_MEMLOCK,	"memorylocked",	1024,	"kbytes"	},
1914 # endif /* RLIMIT_MEMLOCK */
1915 
1916 # ifdef RLIMIT_NPROC
1917     { RLIMIT_NPROC,	"maxproc",	1,	""		},
1918 # endif /* RLIMIT_NPROC */
1919 
1920 # ifdef RLIMIT_NTHR
1921     { RLIMIT_NTHR,	"maxthread",	1,	""		},
1922 # endif /* RLIMIT_NTHR */
1923 
1924 # if defined(RLIMIT_OFILE) && !defined(RLIMIT_NOFILE)
1925     { RLIMIT_OFILE,	"openfiles",	1,	""		},
1926 # endif /* RLIMIT_OFILE && !defined(RLIMIT_NOFILE) */
1927 
1928 # ifdef RLIMIT_SBSIZE
1929     { RLIMIT_SBSIZE,	"sbsize",	1,	""		},
1930 # endif /* RLIMIT_SBSIZE */
1931 
1932 # ifdef RLIMIT_SWAP
1933     { RLIMIT_SWAP,	"swapsize",	1024,	"kbytes"	},
1934 # endif /* RLIMIT_SWAP */
1935 
1936 # ifdef RLIMIT_LOCKS
1937     { RLIMIT_LOCKS,	"maxlocks",	1,	""		},
1938 # endif /* RLIMIT_LOCKS */
1939 
1940 # ifdef RLIMIT_POSIXLOCKS
1941     { RLIMIT_POSIXLOCKS,"posixlocks",	1,	""		},
1942 # endif /* RLIMIT_POSIXLOCKS */
1943 
1944 # ifdef RLIMIT_SIGPENDING
1945     { RLIMIT_SIGPENDING,"maxsignal",	1,	""		},
1946 # endif /* RLIMIT_SIGPENDING */
1947 
1948 # ifdef RLIMIT_MSGQUEUE
1949     { RLIMIT_MSGQUEUE,	"maxmessage",	1,	""		},
1950 # endif /* RLIMIT_MSGQUEUE */
1951 
1952 # ifdef RLIMIT_NICE
1953     { RLIMIT_NICE,	"maxnice",	1,	""		},
1954 # endif /* RLIMIT_NICE */
1955 
1956 # ifdef RLIMIT_RTPRIO
1957     { RLIMIT_RTPRIO,	"maxrtprio",	1,	""		},
1958 # endif /* RLIMIT_RTPRIO */
1959 
1960 # ifdef RLIMIT_RTTIME
1961     { RLIMIT_RTTIME,	"maxrttime",	1,	"usec"		},
1962 # endif /* RLIMIT_RTTIME */
1963 
1964     { -1, 		NULL, 		0, 	NULL		}
1965 };
1966 
1967 static struct limits *findlim	(Char *);
1968 static RLIM_TYPE getval		(struct limits *, Char **);
1969 static int strtail		(Char *, const char *);
1970 static void limtail		(Char *, const char *);
1971 static void limtail2		(Char *, const char *, const char *);
1972 static void plim		(struct limits *, int);
1973 static int setlim		(struct limits *, int, RLIM_TYPE);
1974 
1975 #ifdef convex
1976 static  RLIM_TYPE
restrict_limit(double value)1977 restrict_limit(double value)
1978 {
1979     /*
1980      * is f too large to cope with? return the maximum or minimum int
1981      */
1982     if (value > (double) INT_MAX)
1983 	return (RLIM_TYPE) INT_MAX;
1984     else if (value < (double) INT_MIN)
1985 	return (RLIM_TYPE) INT_MIN;
1986     else
1987 	return (RLIM_TYPE) value;
1988 }
1989 #else /* !convex */
1990 # define restrict_limit(x)	((RLIM_TYPE) (x))
1991 #endif /* convex */
1992 
1993 
1994 static struct limits *
findlim(Char * cp)1995 findlim(Char *cp)
1996 {
1997     struct limits *lp, *res;
1998 
1999     res = NULL;
2000     for (lp = limits; lp->limconst >= 0; lp++)
2001 	if (prefix(cp, str2short(lp->limname))) {
2002 	    if (res)
2003 		stderror(ERR_NAME | ERR_AMBIG);
2004 	    res = lp;
2005 	}
2006     if (res)
2007 	return (res);
2008     stderror(ERR_NAME | ERR_LIMIT);
2009     /* NOTREACHED */
2010     return (0);
2011 }
2012 
2013 /*ARGSUSED*/
2014 void
dolimit(Char ** v,struct command * c)2015 dolimit(Char **v, struct command *c)
2016 {
2017     struct limits *lp;
2018     RLIM_TYPE limit;
2019     int    hard = 0;
2020 
2021     USE(c);
2022     v++;
2023     if (*v && eq(*v, STRmh)) {
2024 	hard = 1;
2025 	v++;
2026     }
2027     if (*v == 0) {
2028 	for (lp = limits; lp->limconst >= 0; lp++)
2029 	    plim(lp, hard);
2030 	return;
2031     }
2032     lp = findlim(v[0]);
2033     if (v[1] == 0) {
2034 	plim(lp, hard);
2035 	return;
2036     }
2037     limit = getval(lp, v + 1);
2038     if (setlim(lp, hard, limit) < 0)
2039 	stderror(ERR_SILENT);
2040 }
2041 
2042 static  RLIM_TYPE
getval(struct limits * lp,Char ** v)2043 getval(struct limits *lp, Char **v)
2044 {
2045     float f;
2046     Char   *cp = *v++;
2047 
2048     f = atof(short2str(cp));
2049 
2050 # ifdef convex
2051     /*
2052      * is f too large to cope with. limit f to minint, maxint  - X-6768 by
2053      * strike
2054      */
2055     if ((f < (double) INT_MIN) || (f > (double) INT_MAX)) {
2056 	stderror(ERR_NAME | ERR_TOOLARGE);
2057     }
2058 # endif /* convex */
2059 
2060     while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
2061 	cp++;
2062     if (*cp == 0) {
2063 	if (*v == 0)
2064 	    return restrict_limit((f * lp->limdiv) + 0.5);
2065 	cp = *v;
2066     }
2067     switch (*cp) {
2068 # ifdef RLIMIT_CPU
2069     case ':':
2070 	if (lp->limconst != RLIMIT_CPU)
2071 	    goto badscal;
2072 	return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f * 60.0 + atof(short2str(cp + 1))));
2073     case 'h':
2074 	if (lp->limconst != RLIMIT_CPU)
2075 	    goto badscal;
2076 	limtail(cp, "hours");
2077 	f *= 3600.0;
2078 	break;
2079 # endif /* RLIMIT_CPU */
2080     case 'm':
2081 # ifdef RLIMIT_CPU
2082 	if (lp->limconst == RLIMIT_CPU) {
2083 	    limtail(cp, "minutes");
2084 	    f *= 60.0;
2085 	    break;
2086 	}
2087 # endif /* RLIMIT_CPU */
2088 	limtail2(cp, "megabytes", "mbytes");
2089 	f *= 1024.0 * 1024.0;
2090 	break;
2091 # ifdef RLIMIT_CPU
2092     case 's':
2093 	if (lp->limconst != RLIMIT_CPU)
2094 	    goto badscal;
2095 	limtail(cp, "seconds");
2096 	break;
2097 # endif /* RLIMIT_CPU */
2098     case 'G':
2099 	*cp = 'g';
2100 	/*FALLTHROUGH*/
2101     case 'g':
2102 # ifdef RLIMIT_CPU
2103 	if (lp->limconst == RLIMIT_CPU)
2104 	    goto badscal;
2105 # endif /* RLIMIT_CPU */
2106 	limtail2(cp, "gigabytes", "gbytes");
2107 	f *= 1024.0 * 1024.0 * 1024.0;
2108 	break;
2109     case 'M':
2110 # ifdef RLIMIT_CPU
2111 	if (lp->limconst == RLIMIT_CPU)
2112 	    goto badscal;
2113 # endif /* RLIMIT_CPU */
2114 	*cp = 'm';
2115 	limtail2(cp, "megabytes", "mbytes");
2116 	f *= 1024.0 * 1024.0;
2117 	break;
2118     case 'k':
2119 # ifdef RLIMIT_CPU
2120 	if (lp->limconst == RLIMIT_CPU)
2121 	    goto badscal;
2122 # endif /* RLIMIT_CPU */
2123 	limtail2(cp, "kilobytes", "kbytes");
2124 	f *= 1024.0;
2125 	break;
2126     case 'b':
2127 # ifdef RLIMIT_CPU
2128 	if (lp->limconst == RLIMIT_CPU)
2129 	    goto badscal;
2130 # endif /* RLIMIT_CPU */
2131 	limtail(cp, "blocks");
2132 	f *= 512.0;
2133 	break;
2134     case 'u':
2135 	limtail(cp, "unlimited");
2136 	return ((RLIM_TYPE) RLIM_INFINITY);
2137     default:
2138 # ifdef RLIMIT_CPU
2139 badscal:
2140 # endif /* RLIMIT_CPU */
2141 	stderror(ERR_NAME | ERR_SCALEF);
2142     }
2143 # ifdef convex
2144     return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f + 0.5));
2145 # else
2146     f += 0.5;
2147     if (f > (float) ((RLIM_TYPE) RLIM_INFINITY))
2148 	return ((RLIM_TYPE) RLIM_INFINITY);
2149     else
2150 	return ((RLIM_TYPE) f);
2151 # endif /* convex */
2152 }
2153 
2154 static int
strtail(Char * cp,const char * str)2155 strtail(Char *cp, const char *str)
2156 {
2157     while (*cp && *cp == (Char)*str)
2158 	cp++, str++;
2159     return (*cp != '\0');
2160 }
2161 
2162 static void
limtail(Char * cp,const char * str)2163 limtail(Char *cp, const char *str)
2164 {
2165     if (strtail(cp, str))
2166 	stderror(ERR_BADSCALE, str);
2167 }
2168 
2169 static void
limtail2(Char * cp,const char * str1,const char * str2)2170 limtail2(Char *cp, const char *str1, const char *str2)
2171 {
2172     if (strtail(cp, str1) && strtail(cp, str2))
2173 	stderror(ERR_BADSCALE, str1);
2174 }
2175 
2176 /*ARGSUSED*/
2177 static void
plim(struct limits * lp,int hard)2178 plim(struct limits *lp, int hard)
2179 {
2180 # ifdef BSDLIMIT
2181     struct rlimit rlim;
2182 # endif /* BSDLIMIT */
2183     RLIM_TYPE limit;
2184     int     xdiv = lp->limdiv;
2185 
2186     xprintf("%-13.13s", lp->limname);
2187 
2188 # ifndef BSDLIMIT
2189     limit = ulimit(lp->limconst, 0);
2190 #  ifdef aiws
2191     if (lp->limconst == RLIMIT_DATA)
2192 	limit -= 0x20000000;
2193 #  endif /* aiws */
2194 # else /* BSDLIMIT */
2195     (void) getrlimit(lp->limconst, &rlim);
2196     limit = hard ? rlim.rlim_max : rlim.rlim_cur;
2197 # endif /* BSDLIMIT */
2198 
2199 # if !defined(BSDLIMIT) || defined(FILESIZE512)
2200     /*
2201      * Christos: filesize comes in 512 blocks. we divide by 2 to get 1024
2202      * blocks. Note we cannot pre-multiply cause we might overflow (A/UX)
2203      */
2204     if (lp->limconst == RLIMIT_FSIZE) {
2205 	if (limit >= (RLIM_INFINITY / 512))
2206 	    limit = RLIM_INFINITY;
2207 	else
2208 	    xdiv = (xdiv == 1024 ? 2 : 1);
2209     }
2210 # endif /* !BSDLIMIT || FILESIZE512 */
2211 
2212     if (limit == RLIM_INFINITY)
2213 	xprintf("unlimited");
2214     else
2215 # if defined(RLIMIT_CPU) && defined(_OSD_POSIX)
2216     if (lp->limconst == RLIMIT_CPU &&
2217         (unsigned long)limit >= 0x7ffffffdUL)
2218 	xprintf("unlimited");
2219     else
2220 # endif
2221 # ifdef RLIMIT_CPU
2222     if (lp->limconst == RLIMIT_CPU)
2223 	psecs(limit);
2224     else
2225 # endif /* RLIMIT_CPU */
2226 	xprintf("%ld %s", (long) (limit / xdiv), lp->limscale);
2227     xputchar('\n');
2228 }
2229 
2230 /*ARGSUSED*/
2231 void
dounlimit(Char ** v,struct command * c)2232 dounlimit(Char **v, struct command *c)
2233 {
2234     struct limits *lp;
2235     int    lerr = 0;
2236     int    hard = 0;
2237     int	   force = 0;
2238 
2239     USE(c);
2240     while (*++v && **v == '-') {
2241 	Char   *vp = *v;
2242 	while (*++vp)
2243 	    switch (*vp) {
2244 	    case 'f':
2245 		force = 1;
2246 		break;
2247 	    case 'h':
2248 		hard = 1;
2249 		break;
2250 	    default:
2251 		stderror(ERR_ULIMUS);
2252 		break;
2253 	    }
2254     }
2255 
2256     if (*v == 0) {
2257 	for (lp = limits; lp->limconst >= 0; lp++)
2258 	    if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
2259 		lerr++;
2260 	if (!force && lerr)
2261 	    stderror(ERR_SILENT);
2262 	return;
2263     }
2264     while (*v) {
2265 	lp = findlim(*v++);
2266 	if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0 && !force)
2267 	    stderror(ERR_SILENT);
2268     }
2269 }
2270 
2271 static int
setlim(struct limits * lp,int hard,RLIM_TYPE limit)2272 setlim(struct limits *lp, int hard, RLIM_TYPE limit)
2273 {
2274 # ifdef BSDLIMIT
2275     struct rlimit rlim;
2276 
2277     (void) getrlimit(lp->limconst, &rlim);
2278 
2279 #  ifdef FILESIZE512
2280     /* Even though hpux has setrlimit(), it expects fsize in 512 byte blocks */
2281     if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2282 	limit /= 512;
2283 #  endif /* FILESIZE512 */
2284     if (hard)
2285 	rlim.rlim_max = limit;
2286     else if (limit == RLIM_INFINITY && euid != 0)
2287 	rlim.rlim_cur = rlim.rlim_max;
2288     else
2289 	rlim.rlim_cur = limit;
2290 
2291     if (rlim.rlim_cur > rlim.rlim_max)
2292 	rlim.rlim_max = rlim.rlim_cur;
2293 
2294     if (setrlimit(lp->limconst, &rlim) < 0) {
2295 # else /* BSDLIMIT */
2296     if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2297 	limit /= 512;
2298 # ifdef aiws
2299     if (lp->limconst == RLIMIT_DATA)
2300 	limit += 0x20000000;
2301 # endif /* aiws */
2302     if (ulimit(toset(lp->limconst), limit) < 0) {
2303 # endif /* BSDLIMIT */
2304         int err;
2305         char *op, *type;
2306 
2307 	err = errno;
2308 	op = strsave(limit == RLIM_INFINITY ? CGETS(15, 2, "remove") :
2309 		     	CGETS(15, 3, "set"));
2310 	cleanup_push(op, xfree);
2311 	type = strsave(hard ? CGETS(15, 4, " hard") : "");
2312 	cleanup_push(type, xfree);
2313 	xprintf(CGETS(15, 1, "%s: %s: Can't %s%s limit (%s)\n"), bname,
2314 	    lp->limname, op, type, strerror(err));
2315 	cleanup_until(op);
2316 	return (-1);
2317     }
2318     return (0);
2319 }
2320 
2321 #endif /* !HAVENOLIMIT */
2322 
2323 /*ARGSUSED*/
2324 void
2325 dosuspend(Char **v, struct command *c)
2326 {
2327 #ifdef BSDJOBS
2328     struct sigaction old;
2329 #endif /* BSDJOBS */
2330 
2331     USE(c);
2332     USE(v);
2333 
2334     if (loginsh)
2335 	stderror(ERR_SUSPLOG);
2336     untty();
2337 
2338 #ifdef BSDJOBS
2339     sigaction(SIGTSTP, NULL, &old);
2340     signal(SIGTSTP, SIG_DFL);
2341     (void) kill(0, SIGTSTP);
2342     /* the shell stops here */
2343     sigaction(SIGTSTP, &old, NULL);
2344 #else /* !BSDJOBS */
2345     stderror(ERR_JOBCONTROL);
2346 #endif /* BSDJOBS */
2347 
2348 #ifdef BSDJOBS
2349     if (tpgrp != -1) {
2350 	if (grabpgrp(FSHTTY, opgrp) == -1)
2351 	    stderror(ERR_SYSTEM, "tcgetpgrp", strerror(errno));
2352 	(void) setpgid(0, shpgrp);
2353 	(void) tcsetpgrp(FSHTTY, shpgrp);
2354     }
2355 #endif /* BSDJOBS */
2356     (void) setdisc(FSHTTY);
2357 }
2358 
2359 /* This is the dreaded EVAL built-in.
2360  *   If you don't fiddle with file descriptors, and reset didfds,
2361  *   this command will either ignore redirection inside or outside
2362  *   its arguments, e.g. eval "date >x"  vs.  eval "date" >x
2363  *   The stuff here seems to work, but I did it by trial and error rather
2364  *   than really knowing what was going on.  If tpgrp is zero, we are
2365  *   probably a background eval, e.g. "eval date &", and we want to
2366  *   make sure that any processes we start stay in our pgrp.
2367  *   This is also the case for "time eval date" -- stay in same pgrp.
2368  *   Otherwise, under stty tostop, processes will stop in the wrong
2369  *   pgrp, with no way for the shell to get them going again.  -IAN!
2370  */
2371 
2372 struct doeval_state
2373 {
2374     Char **evalvec, *evalp;
2375     int didfds;
2376 #ifndef CLOSE_ON_EXEC
2377     int didcch;
2378 #endif
2379     int saveIN, saveOUT, saveDIAG;
2380     int SHIN, SHOUT, SHDIAG;
2381 };
2382 
2383 static void
2384 doeval_cleanup(void *xstate)
2385 {
2386     struct doeval_state *state;
2387 
2388     state = xstate;
2389     evalvec = state->evalvec;
2390     evalp = state->evalp;
2391     doneinp = 0;
2392 #ifndef CLOSE_ON_EXEC
2393     didcch = state->didcch;
2394 #endif /* CLOSE_ON_EXEC */
2395     didfds = state->didfds;
2396     if (state->saveIN != SHIN)
2397 	xclose(SHIN);
2398     if (state->saveOUT != SHOUT)
2399 	xclose(SHOUT);
2400     if (state->saveDIAG != SHDIAG)
2401 	xclose(SHDIAG);
2402     close_on_exec(SHIN = dmove(state->saveIN, state->SHIN), 1);
2403     close_on_exec(SHOUT = dmove(state->saveOUT, state->SHOUT), 1);
2404     close_on_exec(SHDIAG = dmove(state->saveDIAG, state->SHDIAG), 1);
2405     if (didfds) {
2406 	close_on_exec(dcopy(SHIN, 0), 1);
2407 	close_on_exec(dcopy(SHOUT, 1), 1);
2408 	close_on_exec(dcopy(SHDIAG, 2), 1);
2409     }
2410 }
2411 
2412 static Char **Ggv;
2413 /*ARGSUSED*/
2414 void
2415 doeval(Char **v, struct command *c)
2416 {
2417     struct doeval_state state;
2418     int gflag, my_reenter;
2419     Char **gv;
2420     jmp_buf_t osetexit;
2421 
2422     USE(c);
2423     v++;
2424     if (*v == 0)
2425 	return;
2426     gflag = tglob(v);
2427     if (gflag) {
2428 	gv = v = globall(v, gflag);
2429 	if (v == 0)
2430 	    stderror(ERR_NOMATCH);
2431 	cleanup_push(gv, blk_cleanup);
2432 	v = copyblk(v);
2433     }
2434     else {
2435 	gv = NULL;
2436 	v = copyblk(v);
2437 	trim(v);
2438     }
2439 
2440     Ggv = gv;
2441     state.evalvec = evalvec;
2442     state.evalp = evalp;
2443     state.didfds = didfds;
2444 #ifndef CLOSE_ON_EXEC
2445     state.didcch = didcch;
2446 #endif /* CLOSE_ON_EXEC */
2447     state.SHIN = SHIN;
2448     state.SHOUT = SHOUT;
2449     state.SHDIAG = SHDIAG;
2450 
2451     (void)close_on_exec(state.saveIN = dcopy(SHIN, -1), 1);
2452     (void)close_on_exec(state.saveOUT = dcopy(SHOUT, -1), 1);
2453     (void)close_on_exec(state.saveDIAG = dcopy(SHDIAG, -1), 1);
2454 
2455     cleanup_push(&state, doeval_cleanup);
2456 
2457     getexit(osetexit);
2458 
2459     /* PWP: setjmp/longjmp bugfix for optimizing compilers */
2460 #ifdef cray
2461     my_reenter = 1;             /* assume non-zero return val */
2462     if (setexit() == 0) {
2463 	my_reenter = 0;         /* Oh well, we were wrong */
2464 #else /* !cray */
2465     if ((my_reenter = setexit()) == 0) {
2466 #endif /* cray */
2467 	evalvec = v;
2468 	evalp = 0;
2469 	(void)close_on_exec(SHIN = dcopy(0, -1), 1);
2470 	(void)close_on_exec(SHOUT = dcopy(1, -1), 1);
2471 	(void)close_on_exec(SHDIAG = dcopy(2, -1), 1);
2472 #ifndef CLOSE_ON_EXEC
2473 	didcch = 0;
2474 #endif /* CLOSE_ON_EXEC */
2475 	didfds = 0;
2476 	gv = Ggv;
2477 	process(0);
2478 	Ggv = gv;
2479     }
2480 
2481     if (my_reenter == 0) {
2482 	cleanup_until(&state);
2483 	if (Ggv)
2484 	    cleanup_until(Ggv);
2485     }
2486 
2487     resexit(osetexit);
2488     if (my_reenter)
2489 	stderror(ERR_SILENT);
2490 }
2491 
2492 /*************************************************************************/
2493 /* print list of builtin commands */
2494 
2495 static void
2496 lbuffed_cleanup (void *dummy)
2497 {
2498     USE(dummy);
2499     lbuffed = 1;
2500 }
2501 
2502 /*ARGSUSED*/
2503 void
2504 dobuiltins(Char **v, struct command *c)
2505 {
2506     /* would use print_by_column() in tw.parse.c but that assumes
2507      * we have an array of Char * to pass.. (sg)
2508      */
2509     const struct biltins *b;
2510     int row, col, columns, rows;
2511     unsigned int w, maxwidth;
2512 
2513     USE(c);
2514     USE(v);
2515     lbuffed = 0;		/* turn off line buffering */
2516     cleanup_push(&lbuffed, lbuffed_cleanup);
2517 
2518     /* find widest string */
2519     for (maxwidth = 0, b = bfunc; b < &bfunc[nbfunc]; ++b)
2520 	maxwidth = max(maxwidth, strlen(b->bname));
2521     ++maxwidth;					/* for space */
2522 
2523     columns = (TermH + 1) / maxwidth;	/* PWP: terminal size change */
2524     if (!columns)
2525 	columns = 1;
2526     rows = (nbfunc + (columns - 1)) / columns;
2527 
2528     for (b = bfunc, row = 0; row < rows; row++) {
2529 	for (col = 0; col < columns; col++) {
2530 	    if (b < &bfunc[nbfunc]) {
2531 		w = strlen(b->bname);
2532 		xprintf("%s", b->bname);
2533 		if (col < (columns - 1))	/* Not last column? */
2534 		    for (; w < maxwidth; w++)
2535 			xputchar(' ');
2536 		++b;
2537 	    }
2538 	}
2539 	if (row < (rows - 1)) {
2540 	    if (Tty_raw_mode)
2541 		xputchar('\r');
2542 	    xputchar('\n');
2543 	}
2544     }
2545 #ifdef WINNT_NATIVE
2546     nt_print_builtins(maxwidth);
2547 #else
2548     if (Tty_raw_mode)
2549 	xputchar('\r');
2550     xputchar('\n');
2551 #endif /* WINNT_NATIVE */
2552 
2553     cleanup_until(&lbuffed);		/* turn back on line buffering */
2554     flush();
2555 }
2556 
2557 #ifdef NLS_CATALOGS
2558 char *
2559 xcatgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2560 {
2561     char *res;
2562 
2563     errno = 0;
2564     while ((res = catgets(ctd, set_id, msg_id, s)) == s && errno == EINTR) {
2565 	handle_pending_signals();
2566 	errno = 0;
2567     }
2568     return res;
2569 }
2570 
2571 
2572 # if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2573 char *
2574 iconv_catgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2575 {
2576     static char *buf = NULL;
2577     static size_t buf_size = 0;
2578 
2579     char *orig, *dest, *p;
2580     ICONV_CONST char *src;
2581     size_t src_size, dest_size;
2582 
2583     orig = xcatgets(ctd, set_id, msg_id, s);
2584     if (catgets_iconv == (iconv_t)-1 || orig == s)
2585         return orig;
2586     src = orig;
2587     src_size = strlen(src) + 1;
2588     if (buf == NULL && (buf = xmalloc(buf_size = src_size + 32)) == NULL)
2589 	return orig;
2590     dest = buf;
2591     while (src_size != 0) {
2592         dest_size = buf + buf_size - dest;
2593 	if (iconv(catgets_iconv, &src, &src_size, &dest, &dest_size)
2594 	    == (size_t)-1) {
2595 	    switch (errno) {
2596 	    case E2BIG:
2597 		if ((p = xrealloc(buf, buf_size * 2)) == NULL)
2598 		    return orig;
2599 		buf_size *= 2;
2600 		dest = p + (dest - buf);
2601 		buf = p;
2602 		break;
2603 
2604 	    case EILSEQ: case EINVAL: default:
2605 		return orig;
2606 	    }
2607 	}
2608     }
2609     return buf;
2610 }
2611 # endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2612 #endif /* NLS_CATALOGS */
2613 
2614 void
2615 nlsinit(void)
2616 {
2617 #ifdef NLS_CATALOGS
2618     static const char default_catalog[] = "tcsh";
2619 
2620     char *catalog = (char *)(intptr_t)default_catalog;
2621 
2622     if (adrof(STRcatalog) != NULL)
2623 	catalog = xasprintf("tcsh.%s", short2str(varval(STRcatalog)));
2624 #ifdef NL_CAT_LOCALE /* POSIX-compliant. */
2625     /*
2626      * Check if LC_MESSAGES is set in the environment and use it, if so.
2627      * If not, fall back to the setting of LANG.
2628      */
2629     catd = catopen(catalog, tgetenv(STRLC_MESSAGES) ? NL_CAT_LOCALE : 0);
2630 #else /* pre-POSIX */
2631 # ifndef MCLoadBySet
2632 #  define MCLoadBySet 0
2633 #  endif
2634     catd = catopen(catalog, MCLoadBySet);
2635 #endif
2636     if (catalog != default_catalog)
2637 	xfree(catalog);
2638 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2639     /* xcatgets (), not CGETS, the charset name should be in ASCII anyway. */
2640     catgets_iconv = iconv_open (nl_langinfo (CODESET),
2641 				xcatgets(catd, 255, 1, "UTF-8"));
2642 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2643 #endif /* NLS_CATALOGS */
2644 #ifdef WINNT_NATIVE
2645     nls_dll_init();
2646 #endif /* WINNT_NATIVE */
2647     errinit();		/* init the errorlist in correct locale */
2648     mesginit();		/* init the messages for signals */
2649     dateinit();		/* init the messages for dates */
2650     editinit();		/* init the editor messages */
2651     terminit();		/* init the termcap messages */
2652 }
2653 
2654 void
2655 nlsclose(void)
2656 {
2657 #ifdef NLS_CATALOGS
2658 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2659     if (catgets_iconv != (iconv_t)-1) {
2660 	iconv_close(catgets_iconv);
2661 	catgets_iconv = (iconv_t)-1;
2662     }
2663 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2664     if (catd != (nl_catd)-1) {
2665 	/*
2666 	 * catclose can call other functions which can call longjmp
2667 	 * making us re-enter this code. Prevent infinite recursion
2668 	 * by resetting catd. Problem reported and solved by:
2669 	 * Gerhard Niklasch
2670 	 */
2671 	nl_catd oldcatd = catd;
2672 	catd = (nl_catd)-1;
2673 	while (catclose(oldcatd) == -1 && errno == EINTR)
2674 	    handle_pending_signals();
2675     }
2676 #endif /* NLS_CATALOGS */
2677 }
2678 
2679 int
2680 getYN(const char *prompt)
2681 {
2682     int doit;
2683     char c;
2684 
2685     xprintf("%s", prompt);
2686     flush();
2687     (void) force_read(SHIN, &c, sizeof(c));
2688     /*
2689      * Perhaps we should use the yesexpr from the
2690      * actual locale
2691      */
2692     doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
2693     while (c != '\n' && force_read(SHIN, &c, sizeof(c)) == sizeof(c))
2694 	continue;
2695     return doit;
2696 }
2697