Merge branch 'vendor/TCSH'
[dragonfly.git] / contrib / tcsh-6 / sh.func.c
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 *
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
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
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
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
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
208 dozip(Char **v, struct command *c)
209 {
210     USE(c);
211     USE(v);
212 }
213
214 /*ARGSUSED*/
215 void
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, 0);
231         cleanup_push(res, xfree);
232         xprintf("%S", res);
233         cleanup_until(res);
234         if (*v)
235             xprintf(" ");
236     }
237     xprintf("\n");
238
239     cleanup_until(globbed);
240 }
241
242 void
243 prvars(void)
244 {
245     plist(&shvhed, VAR_ALL);
246 }
247
248 /*ARGSUSED*/
249 void
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
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
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
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
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
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
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
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
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
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
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
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
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
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         setv(STRstatus, putn(expr(&v)), VAR_READWRITE);
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
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
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
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
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
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
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
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
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
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 *
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
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 *
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
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
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
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
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
1184 doecho(Char **v, struct command *c)
1185 {
1186     USE(c);
1187     xecho(' ', v);
1188 }
1189
1190 /*ARGSUSED*/
1191 void
1192 doglob(Char **v, struct command *c)
1193 {
1194     USE(c);
1195     xecho(0, v);
1196     flush();
1197 }
1198
1199 static void
1200 xecho(int sep, Char **v)
1201 {
1202     Char *cp, **globbed = NULL;
1203     int     nonl = 0;
1204     int     echo_style = ECHO_STYLE;
1205     struct varent *vp;
1206
1207     if ((vp = adrof(STRecho_style)) != NULL && vp->vec != NULL &&
1208         vp->vec[0] != NULL) {
1209         if (Strcmp(vp->vec[0], STRbsd) == 0)
1210             echo_style = BSD_ECHO;
1211         else if (Strcmp(vp->vec[0], STRsysv) == 0)
1212             echo_style = SYSV_ECHO;
1213         else if (Strcmp(vp->vec[0], STRboth) == 0)
1214             echo_style = BOTH_ECHO;
1215         else if (Strcmp(vp->vec[0], STRnone) == 0)
1216             echo_style = NONE_ECHO;
1217     }
1218
1219     v++;
1220     if (*v == 0)
1221         goto done;
1222     if (setintr) {
1223         int old_pintr_disabled;
1224         pintr_push_enable(&old_pintr_disabled);
1225         v = glob_all_or_error(v);
1226         cleanup_until(&old_pintr_disabled);
1227     } else {
1228         v = glob_all_or_error(v);
1229     }
1230     globbed = v;
1231     if (globbed != NULL)
1232         cleanup_push(globbed, blk_cleanup);
1233
1234     if ((echo_style & BSD_ECHO) != 0 && sep == ' ' && *v && eq(*v, STRmn))
1235         nonl++, v++;
1236
1237     while ((cp = *v++) != 0) {
1238         Char c;
1239
1240         if (setintr) {
1241             int old_pintr_disabled;
1242
1243             pintr_push_enable(&old_pintr_disabled);
1244             cleanup_until(&old_pintr_disabled);
1245         }
1246         while ((c = *cp++) != 0) {
1247             if ((echo_style & SYSV_ECHO) != 0 && c == '\\') {
1248                 switch (c = *cp++) {
1249                 case 'a':
1250                     c = '\a';
1251                     break;
1252                 case 'b':
1253                     c = '\b';
1254                     break;
1255                 case 'c':
1256                     nonl = 1;
1257                     goto done;
1258                 case 'e':
1259 #if 0                   /* Windows does not understand \e */
1260                     c = '\e';
1261 #else
1262                     c = CTL_ESC('\033');
1263 #endif
1264                     break;
1265                 case 'f':
1266                     c = '\f';
1267                     break;
1268                 case 'n':
1269                     c = '\n';
1270                     break;
1271                 case 'r':
1272                     c = '\r';
1273                     break;
1274                 case 't':
1275                     c = '\t';
1276                     break;
1277                 case 'v':
1278                     c = '\v';
1279                     break;
1280                 case '\\':
1281                     c = '\\';
1282                     break;
1283                 case '0':
1284                     c = 0;
1285                     if (*cp >= '0' && *cp < '8')
1286                         c = c * 8 + *cp++ - '0';
1287                     if (*cp >= '0' && *cp < '8')
1288                         c = c * 8 + *cp++ - '0';
1289                     if (*cp >= '0' && *cp < '8')
1290                         c = c * 8 + *cp++ - '0';
1291                     break;
1292                 case '\0':
1293                     c = '\\';
1294                     cp--;
1295                     break;
1296                 default:
1297                     xputchar('\\' | QUOTE);
1298                     break;
1299                 }
1300             }
1301             xputwchar(c | QUOTE);
1302
1303         }
1304         if (*v)
1305             xputchar(sep | QUOTE);
1306     }
1307 done:
1308     if (sep && nonl == 0)
1309         xputchar('\n');
1310     else
1311         flush();
1312     if (globbed != NULL)
1313         cleanup_until(globbed);
1314 }
1315
1316 /* check whether an environment variable should invoke 'set_locale()' */
1317 static int
1318 islocale_var(Char *var)
1319 {
1320     static Char *locale_vars[] = {
1321         STRLANG,        STRLC_ALL,      STRLC_CTYPE,    STRLC_NUMERIC,
1322         STRLC_TIME,     STRLC_COLLATE,  STRLC_MESSAGES, STRLC_MONETARY, 0
1323     };
1324     Char **v;
1325
1326     for (v = locale_vars; *v; ++v)
1327         if (eq(var, *v))
1328             return 1;
1329     return 0;
1330 }
1331
1332 static void
1333 xlate_cr_cleanup(void *dummy)
1334 {
1335     USE(dummy);
1336     xlate_cr = 0;
1337 }
1338
1339 /*ARGSUSED*/
1340 void
1341 doprintenv(Char **v, struct command *c) 
1342 {
1343     Char   *e;
1344
1345     USE(c);
1346     v++;
1347     if (*v == 0) {
1348         Char **ep;
1349
1350         xlate_cr = 1;
1351         cleanup_push(&xlate_cr, xlate_cr_cleanup);
1352         for (ep = STR_environ; *ep; ep++) {
1353             if (setintr) {
1354                 int old_pintr_disabled;
1355
1356                 pintr_push_enable(&old_pintr_disabled);
1357                 cleanup_until(&old_pintr_disabled);
1358             }
1359             xprintf("%S\n", *ep);
1360         }
1361         cleanup_until(&xlate_cr);
1362     }
1363     else if ((e = tgetenv(*v)) != NULL) {
1364         int old_output_raw;
1365
1366         old_output_raw = output_raw;
1367         output_raw = 1;
1368         cleanup_push(&old_output_raw, output_raw_restore);
1369         xprintf("%S\n", e);
1370         cleanup_until(&old_output_raw);
1371     }
1372     else
1373         setcopy(STRstatus, STR1, VAR_READWRITE);
1374 }
1375
1376 /* from "Karl Berry." <karl%mote.umb.edu@relay.cs.net> -- for NeXT things
1377    (and anything else with a modern compiler) */
1378
1379 /*ARGSUSED*/
1380 void
1381 dosetenv(Char **v, struct command *c)
1382 {
1383     Char   *vp, *lp;
1384
1385     USE(c);
1386     if (*++v == 0) {
1387         doprintenv(--v, 0);
1388         return;
1389     }
1390
1391     vp = *v++;
1392     lp = vp;
1393
1394     if (!letter(*lp))
1395         stderror(ERR_NAME | ERR_VARBEGIN);
1396     do {
1397         lp++;
1398     } while (alnum(*lp) || *lp == '.');
1399     if (*lp != '\0')
1400         stderror(ERR_NAME | ERR_VARALNUM);
1401
1402     if ((lp = *v++) == 0)
1403         lp = STRNULL;
1404
1405     lp = globone(lp, G_APPEND);
1406     cleanup_push(lp, xfree);
1407     tsetenv(vp, lp);
1408     if (eq(vp, STRKPATH)) {
1409         importpath(lp);
1410         dohash(NULL, NULL);
1411         cleanup_until(lp);
1412         return;
1413     }
1414
1415 #ifdef apollo
1416     if (eq(vp, STRSYSTYPE)) {
1417         dohash(NULL, NULL);
1418         cleanup_until(lp);
1419         return;
1420     }
1421 #endif /* apollo */
1422
1423     /* dspkanji/dspmbyte autosetting */
1424     /* PATCH IDEA FROM Issei.Suzuki VERY THANKS */
1425 #if defined(DSPMBYTE)
1426     if(eq(vp, STRLANG) && !adrof(CHECK_MBYTEVAR)) {
1427         autoset_dspmbyte(lp);
1428     }
1429 #endif
1430
1431     if (islocale_var(vp)) {
1432 #ifdef NLS
1433         int     k;
1434
1435 # ifdef SETLOCALEBUG
1436         dont_free = 1;
1437 # endif /* SETLOCALEBUG */
1438         (void) setlocale(LC_ALL, "");
1439 # ifdef LC_COLLATE
1440         (void) setlocale(LC_COLLATE, "");
1441 # endif
1442 # ifdef LC_CTYPE
1443         (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1444 # endif /* LC_CTYPE */
1445 # if defined(AUTOSET_KANJI)
1446         autoset_kanji();
1447 # endif /* AUTOSET_KANJI */
1448 # ifdef NLS_CATALOGS
1449 #  ifdef LC_MESSAGES
1450         (void) setlocale(LC_MESSAGES, "");
1451 #  endif /* LC_MESSAGES */
1452         nlsclose();
1453         nlsinit();
1454 # endif /* NLS_CATALOGS */
1455 # ifdef SETLOCALEBUG
1456         dont_free = 0;
1457 # endif /* SETLOCALEBUG */
1458 # ifdef STRCOLLBUG
1459         fix_strcoll_bug();
1460 # endif /* STRCOLLBUG */
1461         tw_cmd_free();  /* since the collation sequence has changed */
1462         for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1463             continue;
1464         AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1465 #else /* !NLS */
1466         AsciiOnly = 0;
1467 #endif /* NLS */
1468         NLSMapsAreInited = 0;
1469         ed_Init();
1470         if (MapsAreInited && !NLSMapsAreInited)
1471             ed_InitNLSMaps();
1472         cleanup_until(lp);
1473         return;
1474     }
1475
1476 #ifdef NLS_CATALOGS
1477     if (eq(vp, STRNLSPATH)) {
1478         nlsclose();
1479         nlsinit();
1480     }
1481 #endif
1482
1483     if (eq(vp, STRNOREBIND)) {
1484         NoNLSRebind = 1;
1485         MapsAreInited = 0;
1486         NLSMapsAreInited = 0;
1487         ed_InitMaps();
1488         cleanup_until(lp);
1489         return;
1490     }
1491 #ifdef WINNT_NATIVE
1492     if (eq(vp, STRtcshlang)) {
1493         nlsinit();
1494         cleanup_until(lp);
1495         return;
1496     }
1497 #endif /* WINNT_NATIVE */
1498     if (eq(vp, STRKTERM)) {
1499         char *t;
1500
1501         setv(STRterm, quote(lp), VAR_READWRITE);        /* lp memory used here */
1502         cleanup_ignore(lp);
1503         cleanup_until(lp);
1504         t = short2str(lp);
1505         if (noediting && strcmp(t, "unknown") != 0 && strcmp(t,"dumb") != 0) {
1506             editing = 1;
1507             noediting = 0;
1508             setNS(STRedit);
1509         }
1510         GotTermCaps = 0;
1511         ed_Init();
1512         return;
1513     }
1514
1515     if (eq(vp, STRKHOME)) {
1516         Char *canon;
1517         /*
1518          * convert to canonical pathname (possibly resolving symlinks)
1519          */
1520         canon = dcanon(lp, lp);
1521         cleanup_ignore(lp);
1522         cleanup_until(lp);
1523         cleanup_push(canon, xfree);
1524         setv(STRhome, quote(canon), VAR_READWRITE); /* lp memory used here */
1525         cleanup_ignore(canon);
1526         cleanup_until(canon);
1527
1528         /* fix directory stack for new tilde home */
1529         dtilde();
1530         return;
1531     }
1532
1533     if (eq(vp, STRKSHLVL)) {
1534         setv(STRshlvl, quote(lp), VAR_READWRITE); /* lp memory used here */
1535         cleanup_ignore(lp);
1536         cleanup_until(lp);
1537         return;
1538     }
1539
1540     if (eq(vp, STRKUSER)) {
1541         setv(STRuser, quote(lp), VAR_READWRITE);        /* lp memory used here */
1542         cleanup_ignore(lp);
1543         cleanup_until(lp);
1544         return;
1545     }
1546
1547     if (eq(vp, STRKGROUP)) {
1548         setv(STRgroup, quote(lp), VAR_READWRITE); /* lp memory used here */
1549         cleanup_ignore(lp);
1550         cleanup_until(lp);
1551         return;
1552     }
1553
1554 #ifdef COLOR_LS_F
1555     if (eq(vp, STRLS_COLORS)) {
1556         parseLS_COLORS(lp);
1557         cleanup_until(lp);
1558         return;
1559     }
1560     if (eq(vp, STRLSCOLORS)) {
1561         parseLSCOLORS(lp);
1562         cleanup_until(lp);
1563         return;
1564     }
1565 #endif /* COLOR_LS_F */
1566
1567 #ifdef SIG_WINDOW
1568     /*
1569      * Load/Update $LINES $COLUMNS
1570      */
1571     if ((eq(lp, STRNULL) && (eq(vp, STRLINES) || eq(vp, STRCOLUMNS))) ||
1572         eq(vp, STRTERMCAP)) {
1573         cleanup_until(lp);
1574         check_window_size(1);
1575         return;
1576     }
1577
1578     /*
1579      * Change the size to the one directed by $LINES and $COLUMNS
1580      */
1581     if (eq(vp, STRLINES) || eq(vp, STRCOLUMNS)) {
1582 #if 0
1583         GotTermCaps = 0;
1584 #endif
1585         cleanup_until(lp);
1586         ed_Init();
1587         return;
1588     }
1589 #endif /* SIG_WINDOW */
1590     cleanup_until(lp);
1591 }
1592
1593 /*ARGSUSED*/
1594 void
1595 dounsetenv(Char **v, struct command *c)
1596 {
1597     Char  **ep, *p, *n, *name;
1598     int     i, maxi;
1599
1600     USE(c);
1601     /*
1602      * Find the longest environment variable
1603      */
1604     for (maxi = 0, ep = STR_environ; *ep; ep++) {
1605         for (i = 0, p = *ep; *p && *p != '='; p++, i++)
1606             continue;
1607         if (i > maxi)
1608             maxi = i;
1609     }
1610
1611     name = xmalloc((maxi + 1) * sizeof(Char));
1612     cleanup_push(name, xfree);
1613
1614     while (++v && *v) 
1615         for (maxi = 1; maxi;)
1616             for (maxi = 0, ep = STR_environ; *ep; ep++) {
1617                 for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
1618                     continue;
1619                 *n = '\0';
1620                 if (!Gmatch(name, *v))
1621                     continue;
1622                 maxi = 1;
1623
1624                 /* Unset the name. This wasn't being done until
1625                  * later but most of the stuff following won't
1626                  * work (particularly the setlocale() and getenv()
1627                  * stuff) as intended until the name is actually
1628                  * removed. (sg)
1629                  */
1630                 Unsetenv(name);
1631
1632                 if (eq(name, STRNOREBIND)) {
1633                     NoNLSRebind = 0;
1634                     MapsAreInited = 0;
1635                     NLSMapsAreInited = 0;
1636                     ed_InitMaps();
1637                 }
1638 #ifdef apollo
1639                 else if (eq(name, STRSYSTYPE))
1640                     dohash(NULL, NULL);
1641 #endif /* apollo */
1642                 else if (islocale_var(name)) {
1643 #ifdef NLS
1644                     int     k;
1645
1646 # ifdef SETLOCALEBUG
1647                     dont_free = 1;
1648 # endif /* SETLOCALEBUG */
1649                     (void) setlocale(LC_ALL, "");
1650 # ifdef LC_COLLATE
1651                     (void) setlocale(LC_COLLATE, "");
1652 # endif
1653 # ifdef LC_CTYPE
1654                     (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1655 # endif /* LC_CTYPE */
1656 # ifdef NLS_CATALOGS
1657 #  ifdef LC_MESSAGES
1658                     (void) setlocale(LC_MESSAGES, "");
1659 #  endif /* LC_MESSAGES */
1660                     nlsclose();
1661                     nlsinit();
1662 # endif /* NLS_CATALOGS */
1663 # ifdef SETLOCALEBUG
1664                     dont_free = 0;
1665 # endif /* SETLOCALEBUG */
1666 # ifdef STRCOLLBUG
1667                     fix_strcoll_bug();
1668 # endif /* STRCOLLBUG */
1669                     tw_cmd_free();/* since the collation sequence has changed */
1670                     for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1671                         continue;
1672                     AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1673 #else /* !NLS */
1674                     AsciiOnly = getenv("LANG") == NULL &&
1675                         getenv("LC_CTYPE") == NULL;
1676 #endif /* NLS */
1677                     NLSMapsAreInited = 0;
1678                     ed_Init();
1679                     if (MapsAreInited && !NLSMapsAreInited)
1680                         ed_InitNLSMaps();
1681
1682                 }
1683 #ifdef WINNT_NATIVE
1684                 else if (eq(name,(STRtcshlang))) {
1685                     nls_dll_unload();
1686                     nlsinit();
1687                 }
1688 #endif /* WINNT_NATIVE */
1689 #ifdef COLOR_LS_F
1690                 else if (eq(name, STRLS_COLORS))
1691                     parseLS_COLORS(n);
1692                 else if (eq(name, STRLSCOLORS))
1693                     parseLSCOLORS(n);
1694 #endif /* COLOR_LS_F */
1695 #ifdef NLS_CATALOGS
1696                 else if (eq(name, STRNLSPATH)) {
1697                     nlsclose();
1698                     nlsinit();
1699                 }
1700 #endif
1701                 /*
1702                  * start again cause the environment changes
1703                  */
1704                 break;
1705             }
1706     cleanup_until(name);
1707 }
1708
1709 void
1710 tsetenv(const Char *name, const Char *val)
1711 {
1712 #ifdef SETENV_IN_LIB
1713 /*
1714  * XXX: This does not work right, since tcsh cannot track changes to
1715  * the environment this way. (the builtin setenv without arguments does
1716  * not print the right stuff neither does unsetenv). This was for Mach,
1717  * it is not needed anymore.
1718  */
1719 #undef setenv
1720     char   *cname;
1721
1722     if (name == NULL)
1723         return;
1724     cname = strsave(short2str(name));
1725     setenv(cname, short2str(val), 1);
1726     xfree(cname);
1727 #else /* !SETENV_IN_LIB */
1728     Char **ep = STR_environ;
1729     const Char *ccp;
1730     Char *cp, *dp;
1731     Char   *blk[2];
1732     Char  **oep = ep;
1733
1734 #ifdef WINNT_NATIVE
1735     nt_set_env(name,val);
1736 #endif /* WINNT_NATIVE */
1737     for (; *ep; ep++) {
1738 #ifdef WINNT_NATIVE
1739         for (ccp = name, dp = *ep; *ccp && Tolower(*ccp & TRIM) == Tolower(*dp);
1740                                 ccp++, dp++)
1741 #else
1742         for (ccp = name, dp = *ep; *ccp && (*ccp & TRIM) == *dp; ccp++, dp++)
1743 #endif /* WINNT_NATIVE */
1744             continue;
1745         if (*ccp != 0 || *dp != '=')
1746             continue;
1747         cp = Strspl(STRequal, val);
1748         xfree(*ep);
1749         *ep = strip(Strspl(name, cp));
1750         xfree(cp);
1751         blkfree((Char **) environ);
1752         environ = short2blk(STR_environ);
1753         return;
1754     }
1755     cp = Strspl(name, STRequal);
1756     blk[0] = strip(Strspl(cp, val));
1757     xfree(cp);
1758     blk[1] = 0;
1759     STR_environ = blkspl(STR_environ, blk);
1760     blkfree((Char **) environ);
1761     environ = short2blk(STR_environ);
1762     xfree(oep);
1763 #endif /* SETENV_IN_LIB */
1764 }
1765
1766 void
1767 Unsetenv(Char *name)
1768 {
1769     Char **ep = STR_environ;
1770     Char *cp, *dp;
1771     Char **oep = ep;
1772
1773 #ifdef WINNT_NATIVE
1774         nt_set_env(name,NULL);
1775 #endif /*WINNT_NATIVE */
1776     for (; *ep; ep++) {
1777         for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
1778             continue;
1779         if (*cp != 0 || *dp != '=')
1780             continue;
1781         cp = *ep;
1782         *ep = 0;
1783         STR_environ = blkspl(STR_environ, ep + 1);
1784         blkfree((Char **) environ);
1785         environ = short2blk(STR_environ);
1786         *ep = cp;
1787         xfree(cp);
1788         xfree(oep);
1789         return;
1790     }
1791 }
1792
1793 /*ARGSUSED*/
1794 void
1795 doumask(Char **v, struct command *c)
1796 {
1797     Char *cp = v[1];
1798     int i;
1799
1800     USE(c);
1801     if (cp == 0) {
1802         i = (int)umask(0);
1803         (void) umask(i);
1804         xprintf("%o\n", i);
1805         return;
1806     }
1807     i = 0;
1808     while (Isdigit(*cp) && *cp != '8' && *cp != '9')
1809         i = i * 8 + *cp++ - '0';
1810     if (*cp || i < 0 || i > 0777)
1811         stderror(ERR_NAME | ERR_MASK);
1812     (void) umask(i);
1813 }
1814
1815 #ifndef HAVENOLIMIT
1816 # ifndef BSDLIMIT
1817    typedef long RLIM_TYPE;
1818 #  ifdef _OSD_POSIX /* BS2000 */
1819 #   include <ulimit.h>
1820 #  endif
1821 #  ifndef RLIM_INFINITY
1822 #   if !defined(_MINIX) && !defined(__clipper__) && !defined(_CRAY)
1823     extern RLIM_TYPE ulimit();
1824 #   endif /* ! _MINIX && !__clipper__ */
1825 #   define RLIM_INFINITY 0x003fffff
1826 #   define RLIMIT_FSIZE 1
1827 #  endif /* RLIM_INFINITY */
1828 #  ifdef aiws
1829 #   define toset(a) (((a) == 3) ? 1004 : (a) + 1)
1830 #   define RLIMIT_DATA  3
1831 #   define RLIMIT_STACK 1005
1832 #  else /* aiws */
1833 #   define toset(a) ((a) + 1)
1834 #  endif /* aiws */
1835 # else /* BSDLIMIT */
1836 #  if (defined(BSD4_4) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (HPUXVERSION >= 1100)) && !defined(__386BSD__)
1837     typedef rlim_t RLIM_TYPE;
1838 #  else
1839 #   if defined(SOLARIS2) || (defined(sgi) && SYSVREL > 3)
1840      typedef rlim_t RLIM_TYPE;
1841 #   else
1842 #    if defined(_SX)
1843       typedef long long RLIM_TYPE;
1844 #    else /* !_SX */
1845       typedef unsigned long RLIM_TYPE;
1846 #    endif /* _SX */
1847 #   endif /* SOLARIS2 || (sgi && SYSVREL > 3) */
1848 #  endif /* BSD4_4 && !__386BSD__  */
1849 # endif /* BSDLIMIT */
1850
1851 # if (HPUXVERSION > 700) && (HPUXVERSION < 1100) && defined(BSDLIMIT)
1852 /* Yes hpux8.0 has limits but <sys/resource.h> does not make them public */
1853 /* Yes, we could have defined _KERNEL, and -I/etc/conf/h, but is that better? */
1854 #  ifndef RLIMIT_CPU
1855 #   define RLIMIT_CPU           0
1856 #   define RLIMIT_FSIZE         1
1857 #   define RLIMIT_DATA          2
1858 #   define RLIMIT_STACK         3
1859 #   define RLIMIT_CORE          4
1860 #   define RLIMIT_RSS           5
1861 #   define RLIMIT_NOFILE        6
1862 #  endif /* RLIMIT_CPU */
1863 #  ifndef RLIM_INFINITY
1864 #   define RLIM_INFINITY        0x7fffffff
1865 #  endif /* RLIM_INFINITY */
1866    /*
1867     * old versions of HP/UX counted limits in 512 bytes
1868     */
1869 #  ifndef SIGRTMIN
1870 #   define FILESIZE512
1871 #  endif /* SIGRTMIN */
1872 # endif /* (HPUXVERSION > 700) && (HPUXVERSION < 1100) && BSDLIMIT */
1873
1874 # if SYSVREL > 3 && defined(BSDLIMIT) && !defined(_SX)
1875 /* In order to use rusage, we included "/usr/ucbinclude/sys/resource.h" in */
1876 /* sh.h.  However, some SVR4 limits are defined in <sys/resource.h>.  Rather */
1877 /* than include both and get warnings, we define the extra SVR4 limits here. */
1878 /* XXX: I don't understand if RLIMIT_AS is defined, why don't we define */
1879 /* RLIMIT_VMEM based on it? */
1880 #  ifndef RLIMIT_VMEM
1881 #   define RLIMIT_VMEM  6
1882 #  endif
1883 #  ifndef RLIMIT_AS
1884 #   define RLIMIT_AS    RLIMIT_VMEM
1885 #  endif
1886 # endif /* SYSVREL > 3 && BSDLIMIT */
1887
1888 # if (defined(__linux__) || defined(__GNU__) || defined(__GLIBC__))
1889 #  if defined(RLIMIT_AS) && !defined(RLIMIT_VMEM)
1890 #   define RLIMIT_VMEM  RLIMIT_AS
1891 #  endif
1892 /*
1893  * Oh well, <asm-generic/resource.h> has it, but <bits/resource.h> does not
1894  * Linux headers: When the left hand does not know what the right hand does.
1895  */
1896 #  if defined(RLIMIT_RTPRIO) && !defined(RLIMIT_RTTIME)
1897 #   define RLIMIT_RTTIME (RLIMIT_RTPRIO + 1)
1898 #  endif
1899 # endif
1900
1901 struct limits limits[] = 
1902 {
1903 # ifdef RLIMIT_CPU
1904     { RLIMIT_CPU,       "cputime",      1,      "seconds"       },
1905 # endif /* RLIMIT_CPU */
1906
1907 # ifdef RLIMIT_FSIZE
1908 #  ifndef aiws
1909     { RLIMIT_FSIZE,     "filesize",     1024,   "kbytes"        },
1910 #  else
1911     { RLIMIT_FSIZE,     "filesize",     512,    "blocks"        },
1912 #  endif /* aiws */
1913 # endif /* RLIMIT_FSIZE */
1914
1915 # ifdef RLIMIT_DATA
1916     { RLIMIT_DATA,      "datasize",     1024,   "kbytes"        },
1917 # endif /* RLIMIT_DATA */
1918
1919 # ifdef RLIMIT_STACK
1920 #  ifndef aiws
1921     { RLIMIT_STACK,     "stacksize",    1024,   "kbytes"        },
1922 #  else
1923     { RLIMIT_STACK,     "stacksize",    1024 * 1024,    "kbytes"},
1924 #  endif /* aiws */
1925 # endif /* RLIMIT_STACK */
1926
1927 # ifdef RLIMIT_CORE
1928     { RLIMIT_CORE,      "coredumpsize", 1024,   "kbytes"        },
1929 # endif /* RLIMIT_CORE */
1930
1931 # ifdef RLIMIT_RSS
1932     { RLIMIT_RSS,       "memoryuse",    1024,   "kbytes"        },
1933 # endif /* RLIMIT_RSS */
1934
1935 # ifdef RLIMIT_UMEM
1936     { RLIMIT_UMEM,      "memoryuse",    1024,   "kbytes"        },
1937 # endif /* RLIMIT_UMEM */
1938
1939 # ifdef RLIMIT_VMEM
1940     { RLIMIT_VMEM,      "vmemoryuse",   1024,   "kbytes"        },
1941 # endif /* RLIMIT_VMEM */
1942
1943 # if defined(RLIMIT_HEAP) /* found on BS2000/OSD systems */
1944     { RLIMIT_HEAP,      "heapsize",     1024,   "kbytes"        },
1945 # endif /* RLIMIT_HEAP */
1946
1947 # ifdef RLIMIT_NOFILE
1948     { RLIMIT_NOFILE,    "descriptors", 1,       ""              },
1949 # endif /* RLIMIT_NOFILE */
1950
1951 # ifdef RLIMIT_NPTS
1952     { RLIMIT_NPTS,      "pseudoterminals", 1,   ""              },
1953 # endif /* RLIMIT_NPTS */
1954
1955 # ifdef RLIMIT_KQUEUES
1956     { RLIMIT_KQUEUES,   "kqueues",      1,      ""              },
1957 # endif /* RLIMIT_KQUEUES */
1958
1959 # ifdef RLIMIT_CONCUR
1960     { RLIMIT_CONCUR,    "concurrency", 1,       "thread(s)"     },
1961 # endif /* RLIMIT_CONCUR */
1962
1963 # ifdef RLIMIT_MEMLOCK
1964     { RLIMIT_MEMLOCK,   "memorylocked", 1024,   "kbytes"        },
1965 # endif /* RLIMIT_MEMLOCK */
1966
1967 # ifdef RLIMIT_NPROC
1968     { RLIMIT_NPROC,     "maxproc",      1,      ""              },
1969 # endif /* RLIMIT_NPROC */
1970
1971 # ifdef RLIMIT_NTHR
1972     { RLIMIT_NTHR,      "maxthread",    1,      ""              },
1973 # endif /* RLIMIT_NTHR */
1974
1975 # if defined(RLIMIT_OFILE) && !defined(RLIMIT_NOFILE)
1976     { RLIMIT_OFILE,     "openfiles",    1,      ""              },
1977 # endif /* RLIMIT_OFILE && !defined(RLIMIT_NOFILE) */
1978
1979 # ifdef RLIMIT_SBSIZE
1980     { RLIMIT_SBSIZE,    "sbsize",       1,      ""              },
1981 # endif /* RLIMIT_SBSIZE */
1982
1983 #ifdef RLIMIT_POSIXLOCKS
1984     { RLIMIT_POSIXLOCKS, "posixlocks",   1,      ""             },
1985 #endif /* RLIMIT_POSIXLOCKS */
1986
1987 # ifdef RLIMIT_SWAP 
1988     { RLIMIT_SWAP,      "swapsize",     1024,   "kbytes"        }, 
1989 # endif /* RLIMIT_SWAP */ 
1990
1991 # ifdef RLIMIT_LOCKS 
1992     { RLIMIT_LOCKS,     "maxlocks",     1,      ""              }, 
1993 # endif /* RLIMIT_LOCKS */ 
1994
1995 # ifdef RLIMIT_POSIXLOCKS
1996     { RLIMIT_POSIXLOCKS,"posixlocks",   1,      ""              },
1997 # endif /* RLIMIT_POSIXLOCKS */
1998
1999 # ifdef RLIMIT_SIGPENDING 
2000     { RLIMIT_SIGPENDING,"maxsignal",    1,      ""              }, 
2001 # endif /* RLIMIT_SIGPENDING */ 
2002
2003 # ifdef RLIMIT_MSGQUEUE 
2004     { RLIMIT_MSGQUEUE,  "maxmessage",   1,      ""              }, 
2005 # endif /* RLIMIT_MSGQUEUE */ 
2006
2007 # ifdef RLIMIT_NICE 
2008     { RLIMIT_NICE,      "maxnice",      1,      ""              }, 
2009 # endif /* RLIMIT_NICE */ 
2010
2011 # ifdef RLIMIT_RTPRIO 
2012     { RLIMIT_RTPRIO,    "maxrtprio",    1,      ""              }, 
2013 # endif /* RLIMIT_RTPRIO */ 
2014
2015 # ifdef RLIMIT_RTTIME 
2016     { RLIMIT_RTTIME,    "maxrttime",    1,      "usec"          }, 
2017 # endif /* RLIMIT_RTTIME */ 
2018
2019     { -1,               NULL,           0,      NULL            }
2020 };
2021
2022 static struct limits *findlim   (Char *);
2023 static RLIM_TYPE getval         (struct limits *, Char **);
2024 static int strtail              (Char *, const char *);
2025 static void limtail             (Char *, const char *);
2026 static void limtail2            (Char *, const char *, const char *);
2027 static void plim                (struct limits *, int);
2028 static int setlim               (struct limits *, int, RLIM_TYPE);
2029
2030 #ifdef convex
2031 static  RLIM_TYPE
2032 restrict_limit(double value)
2033 {
2034     /*
2035      * is f too large to cope with? return the maximum or minimum int
2036      */
2037     if (value > (double) INT_MAX)
2038         return (RLIM_TYPE) INT_MAX;
2039     else if (value < (double) INT_MIN)
2040         return (RLIM_TYPE) INT_MIN;
2041     else
2042         return (RLIM_TYPE) value;
2043 }
2044 #else /* !convex */
2045 # define restrict_limit(x)      ((RLIM_TYPE) (x))
2046 #endif /* convex */
2047
2048
2049 static struct limits *
2050 findlim(Char *cp)
2051 {
2052     struct limits *lp, *res;
2053
2054     res = NULL;
2055     for (lp = limits; lp->limconst >= 0; lp++)
2056         if (prefix(cp, str2short(lp->limname))) {
2057             if (res)
2058                 stderror(ERR_NAME | ERR_AMBIG);
2059             res = lp;
2060         }
2061     if (res)
2062         return (res);
2063     stderror(ERR_NAME | ERR_LIMIT);
2064     /* NOTREACHED */
2065     return (0);
2066 }
2067
2068 /*ARGSUSED*/
2069 void
2070 dolimit(Char **v, struct command *c)
2071 {
2072     struct limits *lp;
2073     RLIM_TYPE limit;
2074     int    hard = 0;
2075
2076     USE(c);
2077     v++;
2078     if (*v && eq(*v, STRmh)) {
2079         hard = 1;
2080         v++;
2081     }
2082     if (*v == 0) {
2083         for (lp = limits; lp->limconst >= 0; lp++)
2084             plim(lp, hard);
2085         return;
2086     }
2087     lp = findlim(v[0]);
2088     if (v[1] == 0) {
2089         plim(lp, hard);
2090         return;
2091     }
2092     limit = getval(lp, v + 1);
2093     if (setlim(lp, hard, limit) < 0)
2094         stderror(ERR_SILENT);
2095 }
2096
2097 static  RLIM_TYPE
2098 getval(struct limits *lp, Char **v)
2099 {
2100     float f;
2101     Char   *cp = *v++;
2102
2103     f = atof(short2str(cp));
2104
2105 # ifdef convex
2106     /*
2107      * is f too large to cope with. limit f to minint, maxint  - X-6768 by
2108      * strike
2109      */
2110     if ((f < (double) INT_MIN) || (f > (double) INT_MAX)) {
2111         stderror(ERR_NAME | ERR_TOOLARGE);
2112     }
2113 # endif /* convex */
2114
2115     while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
2116         cp++;
2117     if (*cp == 0) {
2118         if (*v == 0)
2119             return restrict_limit((f * lp->limdiv) + 0.5);
2120         cp = *v;
2121     }
2122     switch (*cp) {
2123 # ifdef RLIMIT_CPU
2124     case ':':
2125         if (lp->limconst != RLIMIT_CPU)
2126             goto badscal;
2127         return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f * 60.0 + atof(short2str(cp + 1))));
2128     case 'h':
2129         if (lp->limconst != RLIMIT_CPU)
2130             goto badscal;
2131         limtail(cp, "hours");
2132         f *= 3600.0;
2133         break;
2134 # endif /* RLIMIT_CPU */
2135     case 'm':
2136 # ifdef RLIMIT_CPU
2137         if (lp->limconst == RLIMIT_CPU) {
2138             limtail(cp, "minutes");
2139             f *= 60.0;
2140             break;
2141         }
2142 # endif /* RLIMIT_CPU */
2143         limtail2(cp, "megabytes", "mbytes");
2144         f *= 1024.0 * 1024.0;
2145         break;
2146 # ifdef RLIMIT_CPU
2147     case 's':
2148         if (lp->limconst != RLIMIT_CPU)
2149             goto badscal;
2150         limtail(cp, "seconds");
2151         break;
2152 # endif /* RLIMIT_CPU */
2153     case 'G':
2154         *cp = 'g';
2155         /*FALLTHROUGH*/
2156     case 'g':
2157 # ifdef RLIMIT_CPU
2158         if (lp->limconst == RLIMIT_CPU)
2159             goto badscal;
2160 # endif /* RLIMIT_CPU */
2161         limtail2(cp, "gigabytes", "gbytes");
2162         f *= 1024.0 * 1024.0 * 1024.0;
2163         break;
2164     case 'M':
2165 # ifdef RLIMIT_CPU
2166         if (lp->limconst == RLIMIT_CPU)
2167             goto badscal;
2168 # endif /* RLIMIT_CPU */
2169         *cp = 'm';
2170         limtail2(cp, "megabytes", "mbytes");
2171         f *= 1024.0 * 1024.0;
2172         break;
2173     case 'k':
2174 # ifdef RLIMIT_CPU
2175         if (lp->limconst == RLIMIT_CPU)
2176             goto badscal;
2177 # endif /* RLIMIT_CPU */
2178         limtail2(cp, "kilobytes", "kbytes");
2179         f *= 1024.0;
2180         break;
2181     case 'b':
2182 # ifdef RLIMIT_CPU
2183         if (lp->limconst == RLIMIT_CPU)
2184             goto badscal;
2185 # endif /* RLIMIT_CPU */
2186         limtail(cp, "blocks");
2187         f *= 512.0;
2188         break;
2189     case 'u':
2190         limtail(cp, "unlimited");
2191         return ((RLIM_TYPE) RLIM_INFINITY);
2192     default:
2193 # ifdef RLIMIT_CPU
2194 badscal:
2195 # endif /* RLIMIT_CPU */
2196         stderror(ERR_NAME | ERR_SCALEF);
2197     }
2198 # ifdef convex
2199     return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f + 0.5));
2200 # else
2201     f += 0.5;
2202     if (f > (float) ((RLIM_TYPE) RLIM_INFINITY))
2203         return ((RLIM_TYPE) RLIM_INFINITY);
2204     else
2205         return ((RLIM_TYPE) f);
2206 # endif /* convex */
2207 }
2208
2209 static int
2210 strtail(Char *cp, const char *str)
2211 {
2212     while (*cp && *cp == (Char)*str)
2213         cp++, str++;
2214     return (*cp != '\0');
2215 }
2216
2217 static void
2218 limtail(Char *cp, const char *str)
2219 {
2220     if (strtail(cp, str))
2221         stderror(ERR_BADSCALE, str);
2222 }
2223
2224 static void
2225 limtail2(Char *cp, const char *str1, const char *str2)
2226 {
2227     if (strtail(cp, str1) && strtail(cp, str2))
2228         stderror(ERR_BADSCALE, str1);
2229 }
2230
2231 /*ARGSUSED*/
2232 static void
2233 plim(struct limits *lp, int hard)
2234 {
2235 # ifdef BSDLIMIT
2236     struct rlimit rlim;
2237 # endif /* BSDLIMIT */
2238     RLIM_TYPE limit;
2239     int     xdiv = lp->limdiv;
2240
2241     xprintf("%-13.13s", lp->limname);
2242
2243 # ifndef BSDLIMIT
2244     limit = ulimit(lp->limconst, 0);
2245 #  ifdef aiws
2246     if (lp->limconst == RLIMIT_DATA)
2247         limit -= 0x20000000;
2248 #  endif /* aiws */
2249 # else /* BSDLIMIT */
2250     (void) getrlimit(lp->limconst, &rlim);
2251     limit = hard ? rlim.rlim_max : rlim.rlim_cur;
2252 # endif /* BSDLIMIT */
2253
2254 # if !defined(BSDLIMIT) || defined(FILESIZE512)
2255     /*
2256      * Christos: filesize comes in 512 blocks. we divide by 2 to get 1024
2257      * blocks. Note we cannot pre-multiply cause we might overflow (A/UX)
2258      */
2259     if (lp->limconst == RLIMIT_FSIZE) {
2260         if (limit >= (RLIM_INFINITY / 512))
2261             limit = RLIM_INFINITY;
2262         else
2263             xdiv = (xdiv == 1024 ? 2 : 1);
2264     }
2265 # endif /* !BSDLIMIT || FILESIZE512 */
2266
2267     if (limit == RLIM_INFINITY)
2268         xprintf("unlimited");
2269     else
2270 # if defined(RLIMIT_CPU) && defined(_OSD_POSIX)
2271     if (lp->limconst == RLIMIT_CPU &&
2272         (unsigned long)limit >= 0x7ffffffdUL)
2273         xprintf("unlimited");
2274     else
2275 # endif
2276 # ifdef RLIMIT_CPU
2277     if (lp->limconst == RLIMIT_CPU)
2278         psecs(limit);
2279     else
2280 # endif /* RLIMIT_CPU */
2281         xprintf("%ld %s", (long) (limit / xdiv), lp->limscale);
2282     xputchar('\n');
2283 }
2284
2285 /*ARGSUSED*/
2286 void
2287 dounlimit(Char **v, struct command *c)
2288 {
2289     struct limits *lp;
2290     int    lerr = 0;
2291     int    hard = 0;
2292     int    force = 0;
2293
2294     USE(c);
2295     while (*++v && **v == '-') {
2296         Char   *vp = *v;
2297         while (*++vp)
2298             switch (*vp) {
2299             case 'f':
2300                 force = 1;
2301                 break;
2302             case 'h':
2303                 hard = 1;
2304                 break;
2305             default:
2306                 stderror(ERR_ULIMUS);
2307                 break;
2308             }
2309     }
2310
2311     if (*v == 0) {
2312         for (lp = limits; lp->limconst >= 0; lp++)
2313             if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
2314                 lerr++;
2315         if (!force && lerr)
2316             stderror(ERR_SILENT);
2317         return;
2318     }
2319     while (*v) {
2320         lp = findlim(*v++);
2321         if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0 && !force)
2322             stderror(ERR_SILENT);
2323     }
2324 }
2325
2326 static int
2327 setlim(struct limits *lp, int hard, RLIM_TYPE limit)
2328 {
2329 # ifdef BSDLIMIT
2330     struct rlimit rlim;
2331
2332     (void) getrlimit(lp->limconst, &rlim);
2333
2334 #  ifdef FILESIZE512
2335     /* Even though hpux has setrlimit(), it expects fsize in 512 byte blocks */
2336     if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2337         limit /= 512;
2338 #  endif /* FILESIZE512 */
2339     if (hard)
2340         rlim.rlim_max = limit;
2341     else if (limit == RLIM_INFINITY && euid != 0)
2342         rlim.rlim_cur = rlim.rlim_max;
2343     else
2344         rlim.rlim_cur = limit;
2345
2346     if (rlim.rlim_cur > rlim.rlim_max)
2347         rlim.rlim_max = rlim.rlim_cur;
2348
2349     if (setrlimit(lp->limconst, &rlim) < 0) {
2350 # else /* BSDLIMIT */
2351     if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2352         limit /= 512;
2353 # ifdef aiws
2354     if (lp->limconst == RLIMIT_DATA)
2355         limit += 0x20000000;
2356 # endif /* aiws */
2357     if (ulimit(toset(lp->limconst), limit) < 0) {
2358 # endif /* BSDLIMIT */
2359         int err;
2360         char *op, *type;
2361
2362         err = errno;
2363         op = strsave(limit == RLIM_INFINITY ? CGETS(15, 2, "remove") :
2364                         CGETS(15, 3, "set"));
2365         cleanup_push(op, xfree);
2366         type = strsave(hard ? CGETS(15, 4, " hard") : "");
2367         cleanup_push(type, xfree);
2368         xprintf(CGETS(15, 1, "%s: %s: Can't %s%s limit (%s)\n"), bname,
2369             lp->limname, op, type, strerror(err));
2370         cleanup_until(op);
2371         return (-1);
2372     }
2373     return (0);
2374 }
2375
2376 #endif /* !HAVENOLIMIT */
2377
2378 /*ARGSUSED*/
2379 void
2380 dosuspend(Char **v, struct command *c)
2381 {
2382 #ifdef BSDJOBS
2383     struct sigaction old;
2384 #endif /* BSDJOBS */
2385
2386     USE(c);
2387     USE(v);
2388
2389     if (loginsh)
2390         stderror(ERR_SUSPLOG);
2391     untty();
2392
2393 #ifdef BSDJOBS
2394     sigaction(SIGTSTP, NULL, &old);
2395     signal(SIGTSTP, SIG_DFL);
2396     (void) kill(0, SIGTSTP);
2397     /* the shell stops here */
2398     sigaction(SIGTSTP, &old, NULL);
2399 #else /* !BSDJOBS */
2400     stderror(ERR_JOBCONTROL);
2401 #endif /* BSDJOBS */
2402
2403 #ifdef BSDJOBS
2404     if (tpgrp != -1) {
2405         if (grabpgrp(FSHTTY, opgrp) == -1)
2406             stderror(ERR_SYSTEM, "tcgetpgrp", strerror(errno));
2407         (void) setpgid(0, shpgrp);
2408         (void) tcsetpgrp(FSHTTY, shpgrp);
2409     }
2410 #endif /* BSDJOBS */
2411     (void) setdisc(FSHTTY);
2412 }
2413
2414 /* This is the dreaded EVAL built-in.
2415  *   If you don't fiddle with file descriptors, and reset didfds,
2416  *   this command will either ignore redirection inside or outside
2417  *   its arguments, e.g. eval "date >x"  vs.  eval "date" >x
2418  *   The stuff here seems to work, but I did it by trial and error rather
2419  *   than really knowing what was going on.  If tpgrp is zero, we are
2420  *   probably a background eval, e.g. "eval date &", and we want to
2421  *   make sure that any processes we start stay in our pgrp.
2422  *   This is also the case for "time eval date" -- stay in same pgrp.
2423  *   Otherwise, under stty tostop, processes will stop in the wrong
2424  *   pgrp, with no way for the shell to get them going again.  -IAN!
2425  */
2426
2427 struct doeval_state
2428 {
2429     Char **evalvec, *evalp;
2430     int didfds;
2431 #ifndef CLOSE_ON_EXEC
2432     int didcch;
2433 #endif
2434     int saveIN, saveOUT, saveDIAG;
2435     int SHIN, SHOUT, SHDIAG;
2436 };
2437
2438 static void
2439 doeval_cleanup(void *xstate)
2440 {
2441     struct doeval_state *state;
2442
2443     state = xstate;
2444     evalvec = state->evalvec;
2445     evalp = state->evalp;
2446     doneinp = 0;
2447 #ifndef CLOSE_ON_EXEC
2448     didcch = state->didcch;
2449 #endif /* CLOSE_ON_EXEC */
2450     didfds = state->didfds;
2451     if (state->saveIN != SHIN)
2452         xclose(SHIN);
2453     if (state->saveOUT != SHOUT)
2454         xclose(SHOUT);
2455     if (state->saveDIAG != SHDIAG)
2456         xclose(SHDIAG);
2457     close_on_exec(SHIN = dmove(state->saveIN, state->SHIN), 1);
2458     close_on_exec(SHOUT = dmove(state->saveOUT, state->SHOUT), 1);
2459     close_on_exec(SHDIAG = dmove(state->saveDIAG, state->SHDIAG), 1);
2460     if (didfds) {
2461         close_on_exec(dcopy(SHIN, 0), 1);
2462         close_on_exec(dcopy(SHOUT, 1), 1);
2463         close_on_exec(dcopy(SHDIAG, 2), 1);
2464     }
2465 }
2466
2467 static Char **Ggv;
2468 /*ARGSUSED*/
2469 void
2470 doeval(Char **v, struct command *c)
2471 {
2472     struct doeval_state state;
2473     int gflag, my_reenter;
2474     Char **gv;
2475     jmp_buf_t osetexit;
2476
2477     USE(c);
2478     v++;
2479     if (*v == 0)
2480         return;
2481     gflag = tglob(v);
2482     if (gflag) {
2483         gv = v = globall(v, gflag);
2484         if (v == 0)
2485             stderror(ERR_NOMATCH);
2486         cleanup_push(gv, blk_cleanup);
2487         v = copyblk(v);
2488     }
2489     else {
2490         gv = NULL;
2491         v = copyblk(v);
2492         trim(v);
2493     }
2494
2495     Ggv = gv;
2496     state.evalvec = evalvec;
2497     state.evalp = evalp;
2498     state.didfds = didfds;
2499 #ifndef CLOSE_ON_EXEC
2500     state.didcch = didcch;
2501 #endif /* CLOSE_ON_EXEC */
2502     state.SHIN = SHIN;
2503     state.SHOUT = SHOUT;
2504     state.SHDIAG = SHDIAG;
2505
2506     (void)close_on_exec(state.saveIN = dcopy(SHIN, -1), 1);
2507     (void)close_on_exec(state.saveOUT = dcopy(SHOUT, -1), 1);
2508     (void)close_on_exec(state.saveDIAG = dcopy(SHDIAG, -1), 1);
2509
2510     cleanup_push(&state, doeval_cleanup);
2511
2512     getexit(osetexit);
2513
2514     /* PWP: setjmp/longjmp bugfix for optimizing compilers */
2515 #ifdef cray
2516     my_reenter = 1;             /* assume non-zero return val */
2517     if (setexit() == 0) {
2518         my_reenter = 0;         /* Oh well, we were wrong */
2519 #else /* !cray */
2520     if ((my_reenter = setexit()) == 0) {
2521 #endif /* cray */
2522         evalvec = v;
2523         evalp = 0;
2524         (void)close_on_exec(SHIN = dcopy(0, -1), 1);
2525         (void)close_on_exec(SHOUT = dcopy(1, -1), 1);
2526         (void)close_on_exec(SHDIAG = dcopy(2, -1), 1);
2527 #ifndef CLOSE_ON_EXEC
2528         didcch = 0;
2529 #endif /* CLOSE_ON_EXEC */
2530         didfds = 0;
2531         gv = Ggv;
2532         process(0);
2533         Ggv = gv;
2534     }
2535
2536     if (my_reenter == 0) {
2537         cleanup_until(&state);
2538         if (Ggv)
2539             cleanup_until(Ggv);
2540     }
2541
2542     resexit(osetexit);
2543     if (my_reenter)
2544         stderror(ERR_SILENT);
2545 }
2546
2547 /*************************************************************************/
2548 /* print list of builtin commands */
2549
2550 static void
2551 lbuffed_cleanup (void *dummy)
2552 {
2553     USE(dummy);
2554     lbuffed = 1;
2555 }
2556
2557 /*ARGSUSED*/
2558 void
2559 dobuiltins(Char **v, struct command *c)
2560 {
2561     /* would use print_by_column() in tw.parse.c but that assumes
2562      * we have an array of Char * to pass.. (sg)
2563      */
2564     const struct biltins *b;
2565     int row, col, columns, rows;
2566     unsigned int w, maxwidth;
2567
2568     USE(c);
2569     USE(v);
2570     lbuffed = 0;                /* turn off line buffering */
2571     cleanup_push(&lbuffed, lbuffed_cleanup);
2572
2573     /* find widest string */
2574     for (maxwidth = 0, b = bfunc; b < &bfunc[nbfunc]; ++b)
2575         maxwidth = max(maxwidth, strlen(b->bname));
2576     ++maxwidth;                                 /* for space */
2577
2578     columns = (TermH + 1) / maxwidth;   /* PWP: terminal size change */
2579     if (!columns)
2580         columns = 1;
2581     rows = (nbfunc + (columns - 1)) / columns;
2582
2583     for (b = bfunc, row = 0; row < rows; row++) {
2584         for (col = 0; col < columns; col++) {
2585             if (b < &bfunc[nbfunc]) {
2586                 w = strlen(b->bname);
2587                 xprintf("%s", b->bname);
2588                 if (col < (columns - 1))        /* Not last column? */
2589                     for (; w < maxwidth; w++)
2590                         xputchar(' ');
2591                 ++b;
2592             }
2593         }
2594         if (row < (rows - 1)) {
2595             if (Tty_raw_mode)
2596                 xputchar('\r');
2597             xputchar('\n');
2598         }
2599     }
2600 #ifdef WINNT_NATIVE
2601     nt_print_builtins(maxwidth);
2602 #else
2603     if (Tty_raw_mode)
2604         xputchar('\r');
2605     xputchar('\n');
2606 #endif /* WINNT_NATIVE */
2607
2608     cleanup_until(&lbuffed);            /* turn back on line buffering */
2609     flush();
2610 }
2611
2612 #ifdef NLS_CATALOGS
2613 char *
2614 xcatgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2615 {
2616     char *res;
2617
2618     errno = 0;
2619     while ((res = catgets(ctd, set_id, msg_id, s)) == s && errno == EINTR) {
2620         handle_pending_signals();
2621         errno = 0;
2622     }
2623     return res;
2624 }
2625
2626
2627 # if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2628 char *
2629 iconv_catgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2630 {
2631     static char *buf = NULL;
2632     static size_t buf_size = 0;
2633   
2634     char *orig, *dest, *p;
2635     ICONV_CONST char *src;
2636     size_t src_size, dest_size;
2637   
2638     orig = xcatgets(ctd, set_id, msg_id, s);
2639     if (catgets_iconv == (iconv_t)-1 || orig == s)
2640         return orig;
2641     src = orig;
2642     src_size = strlen(src) + 1;
2643     if (buf == NULL && (buf = xmalloc(buf_size = src_size + 32)) == NULL)
2644         return orig;
2645     dest = buf;
2646     while (src_size != 0) {
2647         dest_size = buf + buf_size - dest;
2648         if (iconv(catgets_iconv, &src, &src_size, &dest, &dest_size)
2649             == (size_t)-1) {
2650             switch (errno) {
2651             case E2BIG:
2652                 if ((p = xrealloc(buf, buf_size * 2)) == NULL)
2653                     return orig;
2654                 buf_size *= 2;
2655                 dest = p + (dest - buf);
2656                 buf = p;
2657                 break;
2658                 
2659             case EILSEQ: case EINVAL: default:
2660                 return orig;
2661             }
2662         }
2663     }
2664     return buf;
2665 }
2666 # endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2667 #endif /* NLS_CATALOGS */
2668
2669 void
2670 nlsinit(void)
2671 {
2672 #ifdef NLS_CATALOGS
2673     static const char default_catalog[] = "tcsh";
2674
2675     char *catalog = (char *)(intptr_t)default_catalog;
2676
2677     if (adrof(STRcatalog) != NULL)
2678         catalog = xasprintf("tcsh.%s", short2str(varval(STRcatalog)));
2679 #ifdef NL_CAT_LOCALE /* POSIX-compliant. */
2680     /*
2681      * Check if LC_MESSAGES is set in the environment and use it, if so.
2682      * If not, fall back to the setting of LANG.
2683      */
2684     catd = catopen(catalog, tgetenv(STRLC_MESSAGES) ? NL_CAT_LOCALE : 0);
2685 #else /* pre-POSIX */
2686 # ifndef MCLoadBySet
2687 #  define MCLoadBySet 0
2688 #  endif
2689     catd = catopen(catalog, MCLoadBySet);
2690 #endif
2691     if (catalog != default_catalog)
2692         xfree(catalog);
2693 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2694     /* xcatgets (), not CGETS, the charset name should be in ASCII anyway. */
2695     catgets_iconv = iconv_open (nl_langinfo (CODESET),
2696                                 xcatgets(catd, 255, 1, "UTF-8"));
2697 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2698 #endif /* NLS_CATALOGS */
2699 #ifdef WINNT_NATIVE
2700     nls_dll_init();
2701 #endif /* WINNT_NATIVE */
2702     errinit();          /* init the errorlist in correct locale */
2703     mesginit();         /* init the messages for signals */
2704     dateinit();         /* init the messages for dates */
2705     editinit();         /* init the editor messages */
2706     terminit();         /* init the termcap messages */
2707 }
2708
2709 void
2710 nlsclose(void)
2711 {
2712 #ifdef NLS_CATALOGS
2713 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2714     if (catgets_iconv != (iconv_t)-1) {
2715         iconv_close(catgets_iconv);
2716         catgets_iconv = (iconv_t)-1;
2717     }
2718 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2719     if (catd != (nl_catd)-1) {
2720         /*
2721          * catclose can call other functions which can call longjmp
2722          * making us re-enter this code. Prevent infinite recursion
2723          * by resetting catd. Problem reported and solved by:
2724          * Gerhard Niklasch
2725          */
2726         nl_catd oldcatd = catd;
2727         catd = (nl_catd)-1;
2728         while (catclose(oldcatd) == -1 && errno == EINTR)
2729             handle_pending_signals();
2730     }
2731 #endif /* NLS_CATALOGS */
2732 }
2733
2734 int
2735 getYN(const char *prompt)
2736 {
2737     int doit;
2738     char c;
2739
2740     xprintf("%s", prompt);
2741     flush();
2742     (void) force_read(SHIN, &c, sizeof(c));
2743     /* 
2744      * Perhaps we should use the yesexpr from the
2745      * actual locale
2746      */
2747     doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
2748     while (c != '\n' && force_read(SHIN, &c, sizeof(c)) == sizeof(c))
2749         continue;
2750     return doit;
2751 }