2 * sh.func.c: csh builtin functions
5 * Copyright (c) 1980, 1991 The Regents of the University of California.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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
38 #endif /* WINNT_NATIVE */
40 #if defined (NLS_CATALOGS) && defined(HAVE_ICONV)
41 static iconv_t catgets_iconv; /* Or (iconv_t)-1 */
48 extern int MapsAreInited;
49 extern int NLSMapsAreInited;
50 extern int GotTermCaps;
52 static int zlast = -1;
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 *);
66 const struct biltins *
67 isbfunc(struct command *t)
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};
76 * We never match a builtin that has quoted the first
77 * character; this has been the traditional way to escape
83 if (*cp != ':' && lastchr(cp) == ':') {
84 label.bname = short2str(cp);
88 if (t->t_dflg & F_AMPERSAND) {
89 t->t_dflg &= ~F_AMPERSAND;
90 backgnd.bname = short2str(cp);
93 foregnd.bname = short2str(cp);
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
103 if (eq(STRwarp, cp) && !checkwarp()) {
104 return (0); /* this builtin disabled */
108 * Binary search Bp1 is the beginning of the current search range. Bp2 is
111 for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
114 bp = bp1 + ((bp2 - bp1) >> 1);
115 if ((i = ((char) *cp) - *bp->bname) == 0 &&
116 (i = StrQcmp(cp, str2short(bp->bname))) == 0)
124 return nt_check_additional_builtins(cp);
125 #endif /*WINNT_NATIVE*/
130 func(struct command *t, const struct biltins *bp)
136 i = blklen(t->t_dcom) - 1;
138 stderror(ERR_NAME | ERR_TOOFEW);
140 stderror(ERR_NAME | ERR_TOOMANY);
141 (*bp->bfunct) (t->t_dcom, t);
146 doonintr(Char **v, struct command *c)
152 if (parintr.sa_handler == SIG_IGN)
154 if (setintr && intty)
155 stderror(ERR_NAME | ERR_TERMINAL);
161 sigset_interrupting(SIGINT, queue_pintr);
163 (void) signal(SIGINT, SIG_DFL);
166 else if (eq((vv = strip(vv)), STRminus)) {
167 (void) signal(SIGINT, SIG_IGN);
168 gointr = Strsave(STRminus);
171 gointr = Strsave(vv);
172 sigset_interrupting(SIGINT, queue_pintr);
178 donohup(Char **v, struct command *c)
183 stderror(ERR_NAME | ERR_TERMINAL);
185 (void) signal(SIGHUP, SIG_IGN);
195 dohup(Char **v, struct command *c)
200 stderror(ERR_NAME | ERR_TERMINAL);
202 sigset_interrupting(SIGHUP, SIG_DFL);
208 dozip(Char **v, struct command *c)
216 dofiletest(Char **v, struct command *c)
218 Char **globbed, **fileptr, *ftest, *res;
221 if (*(ftest = *++v) != '-')
222 stderror(ERR_NAME | ERR_FILEINQ);
225 v = glob_all_or_error(v);
227 cleanup_push(globbed, blk_cleanup);
229 while (*(fileptr = v++) != NULL) {
230 res = filetest(ftest, &fileptr, 0);
231 cleanup_push(res, xfree);
239 cleanup_until(globbed);
245 plist(&shvhed, VAR_ALL);
250 doalias(Char **v, struct command *c)
259 plist(&aliases, VAR_ALL);
261 vp = adrof1(strip(p), &aliases);
263 blkpr(vp->vec), xputchar('\n');
266 if (eq(p, STRalias) || eq(p, STRunalias)) {
267 setname(short2str(p));
268 stderror(ERR_NAME | ERR_DANGER);
270 set1(strip(p), saveblk(v), &aliases, VAR_READWRITE);
277 unalias(Char **v, struct command *c)
286 dologout(Char **v, struct command *c)
296 dologin(Char **v, struct command *c)
301 #else /* !WINNT_NATIVE */
302 char **p = short2blk(v);
305 cleanup_push((Char **)p, blk_cleanup);
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);
314 #endif /* !WINNT_NATIVE */
321 donewgrp(Char **v, struct command *c)
324 if (chkstop == 0 && setintr)
326 sigaction(SIGTERM, &parterm, NULL);
329 * From Beto Appleton (beto@aixwiz.austin.ibm.com)
330 * Newgrp can take 2 arguments...
332 (void) execv(_PATH_BIN_NEWGRP, p);
333 (void) execv(_PATH_USRBIN_NEWGRP, p);
334 blkfree((Char **) p);
343 if (chkstop == 0 && setintr)
347 stderror(ERR_NOTLOGIN);
351 doif(Char **v, struct command *kp)
357 i = noexec ? 1 : expr(&v);
360 stderror(ERR_NAME | ERR_EMPTYIF);
361 if (eq(*vv, STRthen)) {
363 stderror(ERR_NAME | ERR_IMPRTHEN);
364 setname(short2str(STRthen));
366 * If expression was zero, then scan to else , otherwise just fall into
370 search(TC_IF, 0, NULL);
374 * Simple command attached to this if. Left shift the node in this tree,
375 * munging it so we can reexecute it.
378 lshift(kp->t_dcom, vv - kp->t_dcom);
385 * Reexecute a command, being careful not
386 * to redo i/o redirection, which is already set up.
389 reexecute(struct command *kp)
391 kp->t_dflg &= F_SAVE;
392 kp->t_dflg |= F_REPEAT;
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.
398 execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL, TRUE);
403 doelse (Char **v, struct command *c)
408 search(TC_ELSE, 0, NULL);
413 dogoto(Char **v, struct command *c)
418 lp = globone(v[1], G_ERROR);
419 cleanup_push(lp, xfree);
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.
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);
442 search(TC_GOTO, 0, lab);
444 * Eliminate loops which were exited.
451 doswitch(Char **v, struct command *c)
457 if (!*v || *(*v++) != '(')
458 stderror(ERR_SYNTAX);
459 cp = **v == ')' ? STRNULL : *v++;
463 stderror(ERR_SYNTAX);
464 lp = globone(cp, G_ERROR);
465 cleanup_push(lp, xfree);
467 search(TC_SWITCH, 0, lp);
473 dobreak(Char **v, struct command *c)
478 stderror(ERR_NAME | ERR_NOTWHILE);
485 doexit(Char **v, struct command *c)
489 if (chkstop == 0 && (intty || intact) && evalvec == 0)
492 * Don't DEMAND parentheses here either.
496 setv(STRstatus, putn(expr(&v)), VAR_READWRITE);
498 stderror(ERR_NAME | ERR_EXPRESSION);
504 /* Always close, why only on ttys? */
510 doforeach(Char **v, struct command *c)
520 stderror(ERR_NAME | ERR_VARBEGIN);
523 } while (alnum(*cp));
525 stderror(ERR_NAME | ERR_VARALNUM);
527 if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
528 stderror(ERR_NAME | ERR_NOPAREN);
532 v = globall(v, gflag);
533 if (v == 0 && !noexec)
534 stderror(ERR_NAME | ERR_NOMATCH);
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;
548 * Pre-read the loop so as to be more comprehensible to a terminal user.
559 dowhile(Char **v, struct command *c)
562 int again = whyles != 0 &&
563 SEEKEQ(&whyles->w_start, &lineloc) &&
564 whyles->w_fename == 0;
569 * Implement prereading here also, taking care not to evaluate the
570 * expression before the loop has been read up from a terminal.
574 else if (intty && !again)
575 status = !exp0(&v, 1);
579 stderror(ERR_NAME | ERR_EXPRESSION);
581 struct whyle *nwp = xcalloc(1, sizeof(*nwp));
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;
600 /* We ain't gonna loop no more, no more! */
607 int old_pintr_disabled;
609 whyles->w_end.type = TCSH_I_SEEK;
611 pintr_push_enable(&old_pintr_disabled);
612 search(TC_BREAK, 0, NULL); /* read the expression in */
614 cleanup_until(&old_pintr_disabled);
615 btell(&whyles->w_end);
620 doend(Char **v, struct command *c)
625 stderror(ERR_NAME | ERR_NOTWHILE);
626 btell(&whyles->w_end);
633 docontin(Char **v, struct command *c)
638 stderror(ERR_NAME | ERR_NOTWHILE);
646 /* Repeating a while is simple */
647 if (whyles->w_fename == 0) {
648 bseek(&whyles->w_start);
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
656 if (!whyles->w_fe[1]) {
660 setv(whyles->w_fename, quote(Strsave(*whyles->w_fe++)), VAR_READWRITE);
661 bseek(&whyles->w_start);
665 dorepeat(Char **v, struct command *kp)
672 } while (v[0] != NULL && Strcmp(v[0], STRrepeat) == 0);
678 cleanup_push(&pintr_disabled, disabled_cleanup);
681 if (setintr && pintr_disabled == 1) {
682 cleanup_until(&pintr_disabled);
684 cleanup_push(&pintr_disabled, disabled_cleanup);
689 if (setintr && pintr_disabled == 1)
690 cleanup_until(&pintr_disabled);
696 doswbrk(Char **v, struct command *c)
701 search(TC_BRKSW, 0, NULL);
707 struct srch *sp, *sp1, *sp2;
711 * Ignore keywords inside heredocs
717 * Binary search Sp1 is the beginning of the current search range. Sp2 is
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)
736 struct srch *sp, *sp2;
738 for (sp = srchn, sp2 = srchn + nsrchn; sp < sp2; sp++)
739 if (sp->s_value == n)
749 search(int type, int level, Char *goal)
751 struct Strbuf word = Strbuf_INIT;
755 struct wordent *histent = NULL, *ohistent = NULL;
759 if (type == TC_GOTO) {
761 a.type = TCSH_F_SEEK;
766 cleanup_push(&word, Strbuf_cleanup);
770 histent = xmalloc(sizeof(*histent));
771 ohistent = xmalloc(sizeof(*histent));
772 ohistent->word = STRNULL;
773 ohistent->next = histent;
774 histent->prev = ohistent;
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);
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;
790 switch (srchx(word.s)) {
793 if (level == 0 && type == TC_IF)
798 while (getword(&word)) {
800 histent->word = Strsave(word.s);
801 histent->next = xmalloc(sizeof(*histent));
802 histent->next->prev = histent;
803 histent = histent->next;
808 if ((type == TC_IF || type == TC_ELSE) &&
814 if (type == TC_IF || type == TC_ELSE)
821 if (type == TC_BREAK)
826 if (type == TC_BRKSW) {
835 if (type == TC_BREAK)
841 if (type == TC_SWITCH || type == TC_BRKSW)
846 if (type == TC_SWITCH || type == TC_BRKSW)
851 if (type == TC_GOTO && getword(&word) && eq(word.s, goal))
856 if (type != TC_GOTO && (type != TC_SWITCH || level != 0))
858 if (word.len == 0 || word.s[word.len - 1] != ':')
860 word.s[--word.len] = 0;
861 if ((type == TC_GOTO && eq(word.s, goal)) ||
862 (type == TC_SWITCH && eq(word.s, STRdefault)))
867 if (type != TC_SWITCH || level != 0)
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))
880 if (type == TC_SWITCH && level == 0)
885 ohistent->prev = histgetword(histent);
886 ohistent->prev->next = ohistent;
887 savehist(ohistent, 0);
891 (void) getword(NULL);
892 } while (level >= 0);
894 cleanup_until(&word);
897 static struct wordent *
898 histgetword(struct wordent *histent)
904 tmp = xmalloc(sizeof(*tmp));
912 Strbuf_terminate (tmp);
913 while (c == ' ' || c == '\t')
918 while (c != CHAR_ERR && c != '\n');
928 if (c == '\\' && !e) {
929 if ((c = readc(1)) == '\n') {
937 if ((c == '\'' || c == '"') && !e) {
946 Strbuf_append1(tmp, (Char) c);
948 if (!first && !d && c == '(' && !e) {
952 } while (d || e || (c != ' ' && c != '\t' && c != '\n'));
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;
964 Strbuf_append1(tmp, (Char) c);
965 Strbuf_terminate(tmp);
966 histent->word = Strsave(tmp->s);
975 stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
979 stderror(ERR_NAME | ERR_NOTFOUND, "endif");
984 stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
988 stderror(ERR_NAME | ERR_NOTFOUND, "end");
992 setname(short2str(Sgoal));
993 stderror(ERR_NAME | ERR_NOTFOUND, "label");
1004 getword(struct Strbuf *wp)
1006 int found = 0, first;
1014 while (c == ' ' || c == '\t')
1019 while (c != CHAR_ERR && c != '\n');
1032 if (c == '\\' && (c = readc(1)) == '\n')
1034 if (c == '\'' || c == '"') {
1043 Strbuf_append1(wp, (Char) c);
1044 if (!d && c == ')') {
1050 Strbuf_terminate(wp);
1055 if (!first && !d && c == '(') {
1062 } while ((d || (c != ' ' && c != '\t')) && c != '\n');
1069 Strbuf_terminate(wp);
1078 stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
1082 stderror(ERR_NAME | ERR_NOTFOUND, "endif");
1087 stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
1091 stderror(ERR_NAME | ERR_NOTFOUND, "end");
1095 setname(short2str(Sgoal));
1096 stderror(ERR_NAME | ERR_NOTFOUND, "label");
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--;
1115 bseek(&whyles->w_end);
1121 wpfree(struct whyle *wp)
1125 xfree(wp->w_fename);
1135 nwp = NULL; /* sun lint is dumb! */
1139 static const char foo[] = "IAFE";
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);
1149 for (; whyles; whyles = nwp) {
1150 struct whyle *wp = whyles;
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);
1162 * XXX: We free loops that have different seek types.
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))
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))
1184 doecho(Char **v, struct command *c)
1192 doglob(Char **v, struct command *c)
1200 xecho(int sep, Char **v)
1202 Char *cp, **globbed = NULL;
1204 int echo_style = ECHO_STYLE;
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;
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);
1228 v = glob_all_or_error(v);
1231 if (globbed != NULL)
1232 cleanup_push(globbed, blk_cleanup);
1234 if ((echo_style & BSD_ECHO) != 0 && sep == ' ' && *v && eq(*v, STRmn))
1237 while ((cp = *v++) != 0) {
1241 int old_pintr_disabled;
1243 pintr_push_enable(&old_pintr_disabled);
1244 cleanup_until(&old_pintr_disabled);
1246 while ((c = *cp++) != 0) {
1247 if ((echo_style & SYSV_ECHO) != 0 && c == '\\') {
1248 switch (c = *cp++) {
1259 #if 0 /* Windows does not understand \e */
1262 c = CTL_ESC('\033');
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';
1297 xputchar('\\' | QUOTE);
1301 xputwchar(c | QUOTE);
1305 xputchar(sep | QUOTE);
1308 if (sep && nonl == 0)
1312 if (globbed != NULL)
1313 cleanup_until(globbed);
1316 /* check whether an environment variable should invoke 'set_locale()' */
1318 islocale_var(Char *var)
1320 static Char *locale_vars[] = {
1321 STRLANG, STRLC_ALL, STRLC_CTYPE, STRLC_NUMERIC,
1322 STRLC_TIME, STRLC_COLLATE, STRLC_MESSAGES, STRLC_MONETARY, 0
1326 for (v = locale_vars; *v; ++v)
1333 xlate_cr_cleanup(void *dummy)
1341 doprintenv(Char **v, struct command *c)
1351 cleanup_push(&xlate_cr, xlate_cr_cleanup);
1352 for (ep = STR_environ; *ep; ep++) {
1354 int old_pintr_disabled;
1356 pintr_push_enable(&old_pintr_disabled);
1357 cleanup_until(&old_pintr_disabled);
1359 xprintf("%S\n", *ep);
1361 cleanup_until(&xlate_cr);
1363 else if ((e = tgetenv(*v)) != NULL) {
1366 old_output_raw = output_raw;
1368 cleanup_push(&old_output_raw, output_raw_restore);
1370 cleanup_until(&old_output_raw);
1373 setcopy(STRstatus, STR1, VAR_READWRITE);
1376 /* from "Karl Berry." <karl%mote.umb.edu@relay.cs.net> -- for NeXT things
1377 (and anything else with a modern compiler) */
1381 dosetenv(Char **v, struct command *c)
1395 stderror(ERR_NAME | ERR_VARBEGIN);
1398 } while (alnum(*lp) || *lp == '.');
1400 stderror(ERR_NAME | ERR_VARALNUM);
1402 if ((lp = *v++) == 0)
1405 lp = globone(lp, G_APPEND);
1406 cleanup_push(lp, xfree);
1408 if (eq(vp, STRKPATH)) {
1416 if (eq(vp, STRSYSTYPE)) {
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);
1431 if (islocale_var(vp)) {
1435 # ifdef SETLOCALEBUG
1437 # endif /* SETLOCALEBUG */
1438 (void) setlocale(LC_ALL, "");
1440 (void) setlocale(LC_COLLATE, "");
1443 (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1444 # endif /* LC_CTYPE */
1445 # if defined(AUTOSET_KANJI)
1447 # endif /* AUTOSET_KANJI */
1448 # ifdef NLS_CATALOGS
1450 (void) setlocale(LC_MESSAGES, "");
1451 # endif /* LC_MESSAGES */
1454 # endif /* NLS_CATALOGS */
1455 # ifdef SETLOCALEBUG
1457 # endif /* SETLOCALEBUG */
1460 # endif /* STRCOLLBUG */
1461 tw_cmd_free(); /* since the collation sequence has changed */
1462 for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1464 AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1468 NLSMapsAreInited = 0;
1470 if (MapsAreInited && !NLSMapsAreInited)
1477 if (eq(vp, STRNLSPATH)) {
1483 if (eq(vp, STRNOREBIND)) {
1486 NLSMapsAreInited = 0;
1492 if (eq(vp, STRtcshlang)) {
1497 #endif /* WINNT_NATIVE */
1498 if (eq(vp, STRKTERM)) {
1501 setv(STRterm, quote(lp), VAR_READWRITE); /* lp memory used here */
1505 if (noediting && strcmp(t, "unknown") != 0 && strcmp(t,"dumb") != 0) {
1515 if (eq(vp, STRKHOME)) {
1518 * convert to canonical pathname (possibly resolving symlinks)
1521 canon = dcanon(lp, lp);
1522 cleanup_push(canon, xfree);
1523 setv(STRhome, quote(canon), VAR_READWRITE); /* lp memory used here */
1524 cleanup_ignore(canon);
1525 cleanup_until(canon);
1527 /* fix directory stack for new tilde home */
1532 if (eq(vp, STRKSHLVL)) {
1533 setv(STRshlvl, quote(lp), VAR_READWRITE); /* lp memory used here */
1539 if (eq(vp, STRKUSER)) {
1540 setv(STRuser, quote(lp), VAR_READWRITE); /* lp memory used here */
1546 if (eq(vp, STRKGROUP)) {
1547 setv(STRgroup, quote(lp), VAR_READWRITE); /* lp memory used here */
1554 if (eq(vp, STRLS_COLORS)) {
1559 if (eq(vp, STRLSCOLORS)) {
1564 #endif /* COLOR_LS_F */
1568 * Load/Update $LINES $COLUMNS
1570 if ((eq(lp, STRNULL) && (eq(vp, STRLINES) || eq(vp, STRCOLUMNS))) ||
1571 eq(vp, STRTERMCAP)) {
1573 check_window_size(1);
1578 * Change the size to the one directed by $LINES and $COLUMNS
1580 if (eq(vp, STRLINES) || eq(vp, STRCOLUMNS)) {
1588 #endif /* SIG_WINDOW */
1594 dounsetenv(Char **v, struct command *c)
1596 Char **ep, *p, *n, *name;
1601 * Find the longest environment variable
1603 for (maxi = 0, ep = STR_environ; *ep; ep++) {
1604 for (i = 0, p = *ep; *p && *p != '='; p++, i++)
1610 name = xmalloc((maxi + 1) * sizeof(Char));
1611 cleanup_push(name, xfree);
1614 for (maxi = 1; maxi;)
1615 for (maxi = 0, ep = STR_environ; *ep; ep++) {
1616 for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
1619 if (!Gmatch(name, *v))
1623 /* Unset the name. This wasn't being done until
1624 * later but most of the stuff following won't
1625 * work (particularly the setlocale() and getenv()
1626 * stuff) as intended until the name is actually
1631 if (eq(name, STRNOREBIND)) {
1634 NLSMapsAreInited = 0;
1638 else if (eq(name, STRSYSTYPE))
1641 else if (islocale_var(name)) {
1645 # ifdef SETLOCALEBUG
1647 # endif /* SETLOCALEBUG */
1648 (void) setlocale(LC_ALL, "");
1650 (void) setlocale(LC_COLLATE, "");
1653 (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1654 # endif /* LC_CTYPE */
1655 # ifdef NLS_CATALOGS
1657 (void) setlocale(LC_MESSAGES, "");
1658 # endif /* LC_MESSAGES */
1661 # endif /* NLS_CATALOGS */
1662 # ifdef SETLOCALEBUG
1664 # endif /* SETLOCALEBUG */
1667 # endif /* STRCOLLBUG */
1668 tw_cmd_free();/* since the collation sequence has changed */
1669 for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1671 AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1673 AsciiOnly = getenv("LANG") == NULL &&
1674 getenv("LC_CTYPE") == NULL;
1676 NLSMapsAreInited = 0;
1678 if (MapsAreInited && !NLSMapsAreInited)
1683 else if (eq(name,(STRtcshlang))) {
1687 #endif /* WINNT_NATIVE */
1689 else if (eq(name, STRLS_COLORS))
1691 else if (eq(name, STRLSCOLORS))
1693 #endif /* COLOR_LS_F */
1695 else if (eq(name, STRNLSPATH)) {
1701 * start again cause the environment changes
1705 cleanup_until(name);
1709 tsetenv(const Char *name, const Char *val)
1711 #ifdef SETENV_IN_LIB
1713 * XXX: This does not work right, since tcsh cannot track changes to
1714 * the environment this way. (the builtin setenv without arguments does
1715 * not print the right stuff neither does unsetenv). This was for Mach,
1716 * it is not needed anymore.
1723 cname = strsave(short2str(name));
1724 setenv(cname, short2str(val), 1);
1726 #else /* !SETENV_IN_LIB */
1727 Char **ep = STR_environ;
1734 nt_set_env(name,val);
1735 #endif /* WINNT_NATIVE */
1738 for (ccp = name, dp = *ep; *ccp && Tolower(*ccp & TRIM) == Tolower(*dp);
1741 for (ccp = name, dp = *ep; *ccp && (*ccp & TRIM) == *dp; ccp++, dp++)
1742 #endif /* WINNT_NATIVE */
1744 if (*ccp != 0 || *dp != '=')
1746 cp = Strspl(STRequal, val);
1748 *ep = strip(Strspl(name, cp));
1750 blkfree((Char **) environ);
1751 environ = short2blk(STR_environ);
1754 cp = Strspl(name, STRequal);
1755 blk[0] = strip(Strspl(cp, val));
1758 STR_environ = blkspl(STR_environ, blk);
1759 blkfree((Char **) environ);
1760 environ = short2blk(STR_environ);
1762 #endif /* SETENV_IN_LIB */
1766 Unsetenv(Char *name)
1768 Char **ep = STR_environ;
1773 nt_set_env(name,NULL);
1774 #endif /*WINNT_NATIVE */
1776 for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
1778 if (*cp != 0 || *dp != '=')
1782 STR_environ = blkspl(STR_environ, ep + 1);
1783 blkfree((Char **) environ);
1784 environ = short2blk(STR_environ);
1794 doumask(Char **v, struct command *c)
1807 while (Isdigit(*cp) && *cp != '8' && *cp != '9')
1808 i = i * 8 + *cp++ - '0';
1809 if (*cp || i < 0 || i > 0777)
1810 stderror(ERR_NAME | ERR_MASK);
1816 typedef long RLIM_TYPE;
1817 # ifdef _OSD_POSIX /* BS2000 */
1818 # include <ulimit.h>
1820 # ifndef RLIM_INFINITY
1821 # if !defined(_MINIX) && !defined(__clipper__) && !defined(_CRAY)
1822 extern RLIM_TYPE ulimit();
1823 # endif /* ! _MINIX && !__clipper__ */
1824 # define RLIM_INFINITY 0x003fffff
1825 # define RLIMIT_FSIZE 1
1826 # endif /* RLIM_INFINITY */
1828 # define toset(a) (((a) == 3) ? 1004 : (a) + 1)
1829 # define RLIMIT_DATA 3
1830 # define RLIMIT_STACK 1005
1832 # define toset(a) ((a) + 1)
1834 # else /* BSDLIMIT */
1835 # if (defined(BSD4_4) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (HPUXVERSION >= 1100)) && !defined(__386BSD__)
1836 typedef rlim_t RLIM_TYPE;
1838 # if defined(SOLARIS2) || (defined(sgi) && SYSVREL > 3)
1839 typedef rlim_t RLIM_TYPE;
1842 typedef long long RLIM_TYPE;
1844 typedef unsigned long RLIM_TYPE;
1846 # endif /* SOLARIS2 || (sgi && SYSVREL > 3) */
1847 # endif /* BSD4_4 && !__386BSD__ */
1848 # endif /* BSDLIMIT */
1850 # if (HPUXVERSION > 700) && (HPUXVERSION < 1100) && defined(BSDLIMIT)
1851 /* Yes hpux8.0 has limits but <sys/resource.h> does not make them public */
1852 /* Yes, we could have defined _KERNEL, and -I/etc/conf/h, but is that better? */
1854 # define RLIMIT_CPU 0
1855 # define RLIMIT_FSIZE 1
1856 # define RLIMIT_DATA 2
1857 # define RLIMIT_STACK 3
1858 # define RLIMIT_CORE 4
1859 # define RLIMIT_RSS 5
1860 # define RLIMIT_NOFILE 6
1861 # endif /* RLIMIT_CPU */
1862 # ifndef RLIM_INFINITY
1863 # define RLIM_INFINITY 0x7fffffff
1864 # endif /* RLIM_INFINITY */
1866 * old versions of HP/UX counted limits in 512 bytes
1869 # define FILESIZE512
1870 # endif /* SIGRTMIN */
1871 # endif /* (HPUXVERSION > 700) && (HPUXVERSION < 1100) && BSDLIMIT */
1873 # if SYSVREL > 3 && defined(BSDLIMIT) && !defined(_SX)
1874 /* In order to use rusage, we included "/usr/ucbinclude/sys/resource.h" in */
1875 /* sh.h. However, some SVR4 limits are defined in <sys/resource.h>. Rather */
1876 /* than include both and get warnings, we define the extra SVR4 limits here. */
1877 /* XXX: I don't understand if RLIMIT_AS is defined, why don't we define */
1878 /* RLIMIT_VMEM based on it? */
1879 # ifndef RLIMIT_VMEM
1880 # define RLIMIT_VMEM 6
1883 # define RLIMIT_AS RLIMIT_VMEM
1885 # endif /* SYSVREL > 3 && BSDLIMIT */
1887 # if (defined(__linux__) || defined(__GNU__) || defined(__GLIBC__))
1888 # if defined(RLIMIT_AS) && !defined(RLIMIT_VMEM)
1889 # define RLIMIT_VMEM RLIMIT_AS
1892 * Oh well, <asm-generic/resource.h> has it, but <bits/resource.h> does not
1893 * Linux headers: When the left hand does not know what the right hand does.
1895 # if defined(RLIMIT_RTPRIO) && !defined(RLIMIT_RTTIME)
1896 # define RLIMIT_RTTIME (RLIMIT_RTPRIO + 1)
1900 struct limits limits[] =
1903 { RLIMIT_CPU, "cputime", 1, "seconds" },
1904 # endif /* RLIMIT_CPU */
1906 # ifdef RLIMIT_FSIZE
1908 { RLIMIT_FSIZE, "filesize", 1024, "kbytes" },
1910 { RLIMIT_FSIZE, "filesize", 512, "blocks" },
1912 # endif /* RLIMIT_FSIZE */
1915 { RLIMIT_DATA, "datasize", 1024, "kbytes" },
1916 # endif /* RLIMIT_DATA */
1918 # ifdef RLIMIT_STACK
1920 { RLIMIT_STACK, "stacksize", 1024, "kbytes" },
1922 { RLIMIT_STACK, "stacksize", 1024 * 1024, "kbytes"},
1924 # endif /* RLIMIT_STACK */
1927 { RLIMIT_CORE, "coredumpsize", 1024, "kbytes" },
1928 # endif /* RLIMIT_CORE */
1931 { RLIMIT_RSS, "memoryuse", 1024, "kbytes" },
1932 # endif /* RLIMIT_RSS */
1935 { RLIMIT_UMEM, "memoryuse", 1024, "kbytes" },
1936 # endif /* RLIMIT_UMEM */
1939 { RLIMIT_VMEM, "vmemoryuse", 1024, "kbytes" },
1940 # endif /* RLIMIT_VMEM */
1942 # if defined(RLIMIT_HEAP) /* found on BS2000/OSD systems */
1943 { RLIMIT_HEAP, "heapsize", 1024, "kbytes" },
1944 # endif /* RLIMIT_HEAP */
1946 # ifdef RLIMIT_NOFILE
1947 { RLIMIT_NOFILE, "descriptors", 1, "" },
1948 # endif /* RLIMIT_NOFILE */
1951 { RLIMIT_NPTS, "pseudoterminals", 1, "" },
1952 # endif /* RLIMIT_NPTS */
1954 # ifdef RLIMIT_KQUEUES
1955 { RLIMIT_KQUEUES, "kqueues", 1, "" },
1956 # endif /* RLIMIT_KQUEUES */
1958 # ifdef RLIMIT_CONCUR
1959 { RLIMIT_CONCUR, "concurrency", 1, "thread(s)" },
1960 # endif /* RLIMIT_CONCUR */
1962 # ifdef RLIMIT_MEMLOCK
1963 { RLIMIT_MEMLOCK, "memorylocked", 1024, "kbytes" },
1964 # endif /* RLIMIT_MEMLOCK */
1966 # ifdef RLIMIT_NPROC
1967 { RLIMIT_NPROC, "maxproc", 1, "" },
1968 # endif /* RLIMIT_NPROC */
1971 { RLIMIT_NTHR, "maxthread", 1, "" },
1972 # endif /* RLIMIT_NTHR */
1974 # if defined(RLIMIT_OFILE) && !defined(RLIMIT_NOFILE)
1975 { RLIMIT_OFILE, "openfiles", 1, "" },
1976 # endif /* RLIMIT_OFILE && !defined(RLIMIT_NOFILE) */
1978 # ifdef RLIMIT_SBSIZE
1979 { RLIMIT_SBSIZE, "sbsize", 1, "" },
1980 # endif /* RLIMIT_SBSIZE */
1983 { RLIMIT_SWAP, "swapsize", 1024, "kbytes" },
1984 # endif /* RLIMIT_SWAP */
1986 # ifdef RLIMIT_LOCKS
1987 { RLIMIT_LOCKS, "maxlocks", 1, "" },
1988 # endif /* RLIMIT_LOCKS */
1990 # ifdef RLIMIT_POSIXLOCKS
1991 { RLIMIT_POSIXLOCKS,"posixlocks", 1, "" },
1992 # endif /* RLIMIT_POSIXLOCKS */
1994 # ifdef RLIMIT_SIGPENDING
1995 { RLIMIT_SIGPENDING,"maxsignal", 1, "" },
1996 # endif /* RLIMIT_SIGPENDING */
1998 # ifdef RLIMIT_MSGQUEUE
1999 { RLIMIT_MSGQUEUE, "maxmessage", 1, "" },
2000 # endif /* RLIMIT_MSGQUEUE */
2003 { RLIMIT_NICE, "maxnice", 1, "" },
2004 # endif /* RLIMIT_NICE */
2006 # ifdef RLIMIT_RTPRIO
2007 { RLIMIT_RTPRIO, "maxrtprio", 1, "" },
2008 # endif /* RLIMIT_RTPRIO */
2010 # ifdef RLIMIT_RTTIME
2011 { RLIMIT_RTTIME, "maxrttime", 1, "usec" },
2012 # endif /* RLIMIT_RTTIME */
2014 { -1, NULL, 0, NULL }
2017 static struct limits *findlim (Char *);
2018 static RLIM_TYPE getval (struct limits *, Char **);
2019 static int strtail (Char *, const char *);
2020 static void limtail (Char *, const char *);
2021 static void limtail2 (Char *, const char *, const char *);
2022 static void plim (struct limits *, int);
2023 static int setlim (struct limits *, int, RLIM_TYPE);
2027 restrict_limit(double value)
2030 * is f too large to cope with? return the maximum or minimum int
2032 if (value > (double) INT_MAX)
2033 return (RLIM_TYPE) INT_MAX;
2034 else if (value < (double) INT_MIN)
2035 return (RLIM_TYPE) INT_MIN;
2037 return (RLIM_TYPE) value;
2040 # define restrict_limit(x) ((RLIM_TYPE) (x))
2044 static struct limits *
2047 struct limits *lp, *res;
2050 for (lp = limits; lp->limconst >= 0; lp++)
2051 if (prefix(cp, str2short(lp->limname))) {
2053 stderror(ERR_NAME | ERR_AMBIG);
2058 stderror(ERR_NAME | ERR_LIMIT);
2065 dolimit(Char **v, struct command *c)
2073 if (*v && eq(*v, STRmh)) {
2078 for (lp = limits; lp->limconst >= 0; lp++)
2087 limit = getval(lp, v + 1);
2088 if (setlim(lp, hard, limit) < 0)
2089 stderror(ERR_SILENT);
2093 getval(struct limits *lp, Char **v)
2098 f = atof(short2str(cp));
2102 * is f too large to cope with. limit f to minint, maxint - X-6768 by
2105 if ((f < (double) INT_MIN) || (f > (double) INT_MAX)) {
2106 stderror(ERR_NAME | ERR_TOOLARGE);
2108 # endif /* convex */
2110 while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
2114 return restrict_limit((f * lp->limdiv) + 0.5);
2120 if (lp->limconst != RLIMIT_CPU)
2122 return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f * 60.0 + atof(short2str(cp + 1))));
2124 if (lp->limconst != RLIMIT_CPU)
2126 limtail(cp, "hours");
2129 # endif /* RLIMIT_CPU */
2132 if (lp->limconst == RLIMIT_CPU) {
2133 limtail(cp, "minutes");
2137 # endif /* RLIMIT_CPU */
2138 limtail2(cp, "megabytes", "mbytes");
2139 f *= 1024.0 * 1024.0;
2143 if (lp->limconst != RLIMIT_CPU)
2145 limtail(cp, "seconds");
2147 # endif /* RLIMIT_CPU */
2153 if (lp->limconst == RLIMIT_CPU)
2155 # endif /* RLIMIT_CPU */
2156 limtail2(cp, "gigabytes", "gbytes");
2157 f *= 1024.0 * 1024.0 * 1024.0;
2161 if (lp->limconst == RLIMIT_CPU)
2163 # endif /* RLIMIT_CPU */
2165 limtail2(cp, "megabytes", "mbytes");
2166 f *= 1024.0 * 1024.0;
2170 if (lp->limconst == RLIMIT_CPU)
2172 # endif /* RLIMIT_CPU */
2173 limtail2(cp, "kilobytes", "kbytes");
2178 if (lp->limconst == RLIMIT_CPU)
2180 # endif /* RLIMIT_CPU */
2181 limtail(cp, "blocks");
2185 limtail(cp, "unlimited");
2186 return ((RLIM_TYPE) RLIM_INFINITY);
2190 # endif /* RLIMIT_CPU */
2191 stderror(ERR_NAME | ERR_SCALEF);
2194 return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f + 0.5));
2197 if (f > (float) ((RLIM_TYPE) RLIM_INFINITY))
2198 return ((RLIM_TYPE) RLIM_INFINITY);
2200 return ((RLIM_TYPE) f);
2201 # endif /* convex */
2205 strtail(Char *cp, const char *str)
2207 while (*cp && *cp == (Char)*str)
2209 return (*cp != '\0');
2213 limtail(Char *cp, const char *str)
2215 if (strtail(cp, str))
2216 stderror(ERR_BADSCALE, str);
2220 limtail2(Char *cp, const char *str1, const char *str2)
2222 if (strtail(cp, str1) && strtail(cp, str2))
2223 stderror(ERR_BADSCALE, str1);
2228 plim(struct limits *lp, int hard)
2232 # endif /* BSDLIMIT */
2234 int xdiv = lp->limdiv;
2236 xprintf("%-13.13s", lp->limname);
2239 limit = ulimit(lp->limconst, 0);
2241 if (lp->limconst == RLIMIT_DATA)
2242 limit -= 0x20000000;
2244 # else /* BSDLIMIT */
2245 (void) getrlimit(lp->limconst, &rlim);
2246 limit = hard ? rlim.rlim_max : rlim.rlim_cur;
2247 # endif /* BSDLIMIT */
2249 # if !defined(BSDLIMIT) || defined(FILESIZE512)
2251 * Christos: filesize comes in 512 blocks. we divide by 2 to get 1024
2252 * blocks. Note we cannot pre-multiply cause we might overflow (A/UX)
2254 if (lp->limconst == RLIMIT_FSIZE) {
2255 if (limit >= (RLIM_INFINITY / 512))
2256 limit = RLIM_INFINITY;
2258 xdiv = (xdiv == 1024 ? 2 : 1);
2260 # endif /* !BSDLIMIT || FILESIZE512 */
2262 if (limit == RLIM_INFINITY)
2263 xprintf("unlimited");
2265 # if defined(RLIMIT_CPU) && defined(_OSD_POSIX)
2266 if (lp->limconst == RLIMIT_CPU &&
2267 (unsigned long)limit >= 0x7ffffffdUL)
2268 xprintf("unlimited");
2272 if (lp->limconst == RLIMIT_CPU)
2275 # endif /* RLIMIT_CPU */
2276 xprintf("%ld %s", (long) (limit / xdiv), lp->limscale);
2282 dounlimit(Char **v, struct command *c)
2290 while (*++v && **v == '-') {
2301 stderror(ERR_ULIMUS);
2307 for (lp = limits; lp->limconst >= 0; lp++)
2308 if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
2311 stderror(ERR_SILENT);
2316 if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0 && !force)
2317 stderror(ERR_SILENT);
2322 setlim(struct limits *lp, int hard, RLIM_TYPE limit)
2327 (void) getrlimit(lp->limconst, &rlim);
2330 /* Even though hpux has setrlimit(), it expects fsize in 512 byte blocks */
2331 if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2333 # endif /* FILESIZE512 */
2335 rlim.rlim_max = limit;
2336 else if (limit == RLIM_INFINITY && euid != 0)
2337 rlim.rlim_cur = rlim.rlim_max;
2339 rlim.rlim_cur = limit;
2341 if (rlim.rlim_cur > rlim.rlim_max)
2342 rlim.rlim_max = rlim.rlim_cur;
2344 if (setrlimit(lp->limconst, &rlim) < 0) {
2345 # else /* BSDLIMIT */
2346 if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2349 if (lp->limconst == RLIMIT_DATA)
2350 limit += 0x20000000;
2352 if (ulimit(toset(lp->limconst), limit) < 0) {
2353 # endif /* BSDLIMIT */
2358 op = strsave(limit == RLIM_INFINITY ? CGETS(15, 2, "remove") :
2359 CGETS(15, 3, "set"));
2360 cleanup_push(op, xfree);
2361 type = strsave(hard ? CGETS(15, 4, " hard") : "");
2362 cleanup_push(type, xfree);
2363 xprintf(CGETS(15, 1, "%s: %s: Can't %s%s limit (%s)\n"), bname,
2364 lp->limname, op, type, strerror(err));
2371 #endif /* !HAVENOLIMIT */
2375 dosuspend(Char **v, struct command *c)
2378 struct sigaction old;
2379 #endif /* BSDJOBS */
2385 stderror(ERR_SUSPLOG);
2389 sigaction(SIGTSTP, NULL, &old);
2390 signal(SIGTSTP, SIG_DFL);
2391 (void) kill(0, SIGTSTP);
2392 /* the shell stops here */
2393 sigaction(SIGTSTP, &old, NULL);
2394 #else /* !BSDJOBS */
2395 stderror(ERR_JOBCONTROL);
2396 #endif /* BSDJOBS */
2400 if (grabpgrp(FSHTTY, opgrp) == -1)
2401 stderror(ERR_SYSTEM, "tcgetpgrp", strerror(errno));
2402 (void) setpgid(0, shpgrp);
2403 (void) tcsetpgrp(FSHTTY, shpgrp);
2405 #endif /* BSDJOBS */
2406 (void) setdisc(FSHTTY);
2409 /* This is the dreaded EVAL built-in.
2410 * If you don't fiddle with file descriptors, and reset didfds,
2411 * this command will either ignore redirection inside or outside
2412 * its arguments, e.g. eval "date >x" vs. eval "date" >x
2413 * The stuff here seems to work, but I did it by trial and error rather
2414 * than really knowing what was going on. If tpgrp is zero, we are
2415 * probably a background eval, e.g. "eval date &", and we want to
2416 * make sure that any processes we start stay in our pgrp.
2417 * This is also the case for "time eval date" -- stay in same pgrp.
2418 * Otherwise, under stty tostop, processes will stop in the wrong
2419 * pgrp, with no way for the shell to get them going again. -IAN!
2424 Char **evalvec, *evalp;
2426 #ifndef CLOSE_ON_EXEC
2429 int saveIN, saveOUT, saveDIAG;
2430 int SHIN, SHOUT, SHDIAG;
2434 doeval_cleanup(void *xstate)
2436 struct doeval_state *state;
2439 evalvec = state->evalvec;
2440 evalp = state->evalp;
2442 #ifndef CLOSE_ON_EXEC
2443 didcch = state->didcch;
2444 #endif /* CLOSE_ON_EXEC */
2445 didfds = state->didfds;
2446 if (state->saveIN != SHIN)
2448 if (state->saveOUT != SHOUT)
2450 if (state->saveDIAG != SHDIAG)
2452 close_on_exec(SHIN = dmove(state->saveIN, state->SHIN), 1);
2453 close_on_exec(SHOUT = dmove(state->saveOUT, state->SHOUT), 1);
2454 close_on_exec(SHDIAG = dmove(state->saveDIAG, state->SHDIAG), 1);
2456 close_on_exec(dcopy(SHIN, 0), 1);
2457 close_on_exec(dcopy(SHOUT, 1), 1);
2458 close_on_exec(dcopy(SHDIAG, 2), 1);
2465 doeval(Char **v, struct command *c)
2467 struct doeval_state state;
2468 int gflag, my_reenter;
2478 gv = v = globall(v, gflag);
2480 stderror(ERR_NOMATCH);
2481 cleanup_push(gv, blk_cleanup);
2491 state.evalvec = evalvec;
2492 state.evalp = evalp;
2493 state.didfds = didfds;
2494 #ifndef CLOSE_ON_EXEC
2495 state.didcch = didcch;
2496 #endif /* CLOSE_ON_EXEC */
2498 state.SHOUT = SHOUT;
2499 state.SHDIAG = SHDIAG;
2501 (void)close_on_exec(state.saveIN = dcopy(SHIN, -1), 1);
2502 (void)close_on_exec(state.saveOUT = dcopy(SHOUT, -1), 1);
2503 (void)close_on_exec(state.saveDIAG = dcopy(SHDIAG, -1), 1);
2505 cleanup_push(&state, doeval_cleanup);
2509 /* PWP: setjmp/longjmp bugfix for optimizing compilers */
2511 my_reenter = 1; /* assume non-zero return val */
2512 if (setexit() == 0) {
2513 my_reenter = 0; /* Oh well, we were wrong */
2515 if ((my_reenter = setexit()) == 0) {
2519 (void)close_on_exec(SHIN = dcopy(0, -1), 1);
2520 (void)close_on_exec(SHOUT = dcopy(1, -1), 1);
2521 (void)close_on_exec(SHDIAG = dcopy(2, -1), 1);
2522 #ifndef CLOSE_ON_EXEC
2524 #endif /* CLOSE_ON_EXEC */
2531 if (my_reenter == 0) {
2532 cleanup_until(&state);
2539 stderror(ERR_SILENT);
2542 /*************************************************************************/
2543 /* print list of builtin commands */
2546 lbuffed_cleanup (void *dummy)
2554 dobuiltins(Char **v, struct command *c)
2556 /* would use print_by_column() in tw.parse.c but that assumes
2557 * we have an array of Char * to pass.. (sg)
2559 const struct biltins *b;
2560 int row, col, columns, rows;
2561 unsigned int w, maxwidth;
2565 lbuffed = 0; /* turn off line buffering */
2566 cleanup_push(&lbuffed, lbuffed_cleanup);
2568 /* find widest string */
2569 for (maxwidth = 0, b = bfunc; b < &bfunc[nbfunc]; ++b)
2570 maxwidth = max(maxwidth, strlen(b->bname));
2571 ++maxwidth; /* for space */
2573 columns = (TermH + 1) / maxwidth; /* PWP: terminal size change */
2576 rows = (nbfunc + (columns - 1)) / columns;
2578 for (b = bfunc, row = 0; row < rows; row++) {
2579 for (col = 0; col < columns; col++) {
2580 if (b < &bfunc[nbfunc]) {
2581 w = strlen(b->bname);
2582 xprintf("%s", b->bname);
2583 if (col < (columns - 1)) /* Not last column? */
2584 for (; w < maxwidth; w++)
2589 if (row < (rows - 1)) {
2596 nt_print_builtins(maxwidth);
2601 #endif /* WINNT_NATIVE */
2603 cleanup_until(&lbuffed); /* turn back on line buffering */
2609 xcatgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2614 while ((res = catgets(ctd, set_id, msg_id, s)) == s && errno == EINTR) {
2615 handle_pending_signals();
2622 # if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2624 iconv_catgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2626 static char *buf = NULL;
2627 static size_t buf_size = 0;
2629 char *orig, *dest, *p;
2630 ICONV_CONST char *src;
2631 size_t src_size, dest_size;
2633 orig = xcatgets(ctd, set_id, msg_id, s);
2634 if (catgets_iconv == (iconv_t)-1 || orig == s)
2637 src_size = strlen(src) + 1;
2638 if (buf == NULL && (buf = xmalloc(buf_size = src_size + 32)) == NULL)
2641 while (src_size != 0) {
2642 dest_size = buf + buf_size - dest;
2643 if (iconv(catgets_iconv, &src, &src_size, &dest, &dest_size)
2647 if ((p = xrealloc(buf, buf_size * 2)) == NULL)
2650 dest = p + (dest - buf);
2654 case EILSEQ: case EINVAL: default:
2661 # endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2662 #endif /* NLS_CATALOGS */
2668 static const char default_catalog[] = "tcsh";
2670 char *catalog = (char *)(intptr_t)default_catalog;
2672 if (adrof(STRcatalog) != NULL)
2673 catalog = xasprintf("tcsh.%s", short2str(varval(STRcatalog)));
2674 #ifdef NL_CAT_LOCALE /* POSIX-compliant. */
2676 * Check if LC_MESSAGES is set in the environment and use it, if so.
2677 * If not, fall back to the setting of LANG.
2679 catd = catopen(catalog, tgetenv(STRLC_MESSAGES) ? NL_CAT_LOCALE : 0);
2680 #else /* pre-POSIX */
2681 # ifndef MCLoadBySet
2682 # define MCLoadBySet 0
2684 catd = catopen(catalog, MCLoadBySet);
2686 if (catalog != default_catalog)
2688 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2689 /* xcatgets (), not CGETS, the charset name should be in ASCII anyway. */
2690 catgets_iconv = iconv_open (nl_langinfo (CODESET),
2691 xcatgets(catd, 255, 1, "UTF-8"));
2692 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2693 #endif /* NLS_CATALOGS */
2696 #endif /* WINNT_NATIVE */
2697 errinit(); /* init the errorlist in correct locale */
2698 mesginit(); /* init the messages for signals */
2699 dateinit(); /* init the messages for dates */
2700 editinit(); /* init the editor messages */
2701 terminit(); /* init the termcap messages */
2708 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2709 if (catgets_iconv != (iconv_t)-1) {
2710 iconv_close(catgets_iconv);
2711 catgets_iconv = (iconv_t)-1;
2713 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2714 if (catd != (nl_catd)-1) {
2716 * catclose can call other functions which can call longjmp
2717 * making us re-enter this code. Prevent infinite recursion
2718 * by resetting catd. Problem reported and solved by:
2721 nl_catd oldcatd = catd;
2723 while (catclose(oldcatd) == -1 && errno == EINTR)
2724 handle_pending_signals();
2726 #endif /* NLS_CATALOGS */
2730 getYN(const char *prompt)
2735 xprintf("%s", prompt);
2737 (void) force_read(SHIN, &c, sizeof(c));
2739 * Perhaps we should use the yesexpr from the
2742 doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
2743 while (c != '\n' && force_read(SHIN, &c, sizeof(c)) == sizeof(c))