145e5710bSMark Peek /*
2c80476e4SDavid E. O'Brien * sh.func.c: csh builtin functions
3c80476e4SDavid E. O'Brien */
4c80476e4SDavid E. O'Brien /*-
5c80476e4SDavid E. O'Brien * Copyright (c) 1980, 1991 The Regents of the University of California.
6c80476e4SDavid E. O'Brien * All rights reserved.
7c80476e4SDavid E. O'Brien *
8c80476e4SDavid E. O'Brien * Redistribution and use in source and binary forms, with or without
9c80476e4SDavid E. O'Brien * modification, are permitted provided that the following conditions
10c80476e4SDavid E. O'Brien * are met:
11c80476e4SDavid E. O'Brien * 1. Redistributions of source code must retain the above copyright
12c80476e4SDavid E. O'Brien * notice, this list of conditions and the following disclaimer.
13c80476e4SDavid E. O'Brien * 2. Redistributions in binary form must reproduce the above copyright
14c80476e4SDavid E. O'Brien * notice, this list of conditions and the following disclaimer in the
15c80476e4SDavid E. O'Brien * documentation and/or other materials provided with the distribution.
16c80476e4SDavid E. O'Brien * 3. Neither the name of the University nor the names of its contributors
1729301572SMark Peek * may be used to endorse or promote products derived from this software
18c80476e4SDavid E. O'Brien * without specific prior written permission.
19c80476e4SDavid E. O'Brien *
20c80476e4SDavid E. O'Brien * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21c80476e4SDavid E. O'Brien * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22c80476e4SDavid E. O'Brien * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23c80476e4SDavid E. O'Brien * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24c80476e4SDavid E. O'Brien * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25c80476e4SDavid E. O'Brien * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26c80476e4SDavid E. O'Brien * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27c80476e4SDavid E. O'Brien * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28c80476e4SDavid E. O'Brien * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29c80476e4SDavid E. O'Brien * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30c80476e4SDavid E. O'Brien * SUCH DAMAGE.
31c80476e4SDavid E. O'Brien */
32c80476e4SDavid E. O'Brien #include "sh.h"
33c80476e4SDavid E. O'Brien #include "ed.h"
34c80476e4SDavid E. O'Brien #include "tw.h"
3545e5710bSMark Peek #include "tc.h"
36c80476e4SDavid E. O'Brien #ifdef WINNT_NATIVE
37c80476e4SDavid E. O'Brien #include "nt.const.h"
38c80476e4SDavid E. O'Brien #endif /* WINNT_NATIVE */
39c80476e4SDavid E. O'Brien
403b6eaa7bSAndrey A. Chernov #if defined (NLS_CATALOGS) && defined(HAVE_ICONV)
41c80476e4SDavid E. O'Brien static iconv_t catgets_iconv; /* Or (iconv_t)-1 */
423b6eaa7bSAndrey A. Chernov #endif
43c80476e4SDavid E. O'Brien
4445e5710bSMark Peek /*
4523338178SMark Peek * C shell
4623338178SMark Peek */
4723338178SMark Peek
4823338178SMark Peek extern int MapsAreInited;
49c80476e4SDavid E. O'Brien extern int NLSMapsAreInited;
50c80476e4SDavid E. O'Brien extern int GotTermCaps;
51c80476e4SDavid E. O'Brien
52c80476e4SDavid E. O'Brien static int zlast = -1;
5323338178SMark Peek
5423338178SMark Peek static void islogin (void);
5523338178SMark Peek static void preread (void);
56c80476e4SDavid E. O'Brien static void doagain (void);
57c80476e4SDavid E. O'Brien static const char *isrchx (int);
58c80476e4SDavid E. O'Brien static void search (int, int, Char *);
5945e5710bSMark Peek static int getword (struct Strbuf *);
6045e5710bSMark Peek static struct wordent *histgetword (struct wordent *);
6145e5710bSMark Peek static void toend (void);
6245e5710bSMark Peek static void xecho (int, Char **);
6345e5710bSMark Peek static int islocale_var (Char *);
6445e5710bSMark Peek static void wpfree (struct whyle *);
6545e5710bSMark Peek
6645e5710bSMark Peek const struct biltins *
isbfunc(struct command * t)6745e5710bSMark Peek isbfunc(struct command *t)
6845e5710bSMark Peek {
69c80476e4SDavid E. O'Brien Char *cp = t->t_dcom[0];
7045e5710bSMark Peek const struct biltins *bp, *bp1, *bp2;
7145e5710bSMark Peek static struct biltins label = {"", dozip, 0, 0};
72c80476e4SDavid E. O'Brien static struct biltins foregnd = {"%job", dofg1, 0, 0};
7323338178SMark Peek static struct biltins backgnd = {"%job &", dobg1, 0, 0};
7445e5710bSMark Peek
75c80476e4SDavid E. O'Brien /*
76c80476e4SDavid E. O'Brien * We never match a builtin that has quoted the first
77c80476e4SDavid E. O'Brien * character; this has been the traditional way to escape
78c80476e4SDavid E. O'Brien * builtin commands.
79c80476e4SDavid E. O'Brien */
80c80476e4SDavid E. O'Brien if (*cp & QUOTE)
81c80476e4SDavid E. O'Brien return NULL;
82c80476e4SDavid E. O'Brien
83c80476e4SDavid E. O'Brien if (*cp != ':' && lastchr(cp) == ':') {
84c80476e4SDavid E. O'Brien label.bname = short2str(cp);
85c80476e4SDavid E. O'Brien return (&label);
86c80476e4SDavid E. O'Brien }
87c80476e4SDavid E. O'Brien if (*cp == '%') {
88c80476e4SDavid E. O'Brien if (t->t_dflg & F_AMPERSAND) {
89c80476e4SDavid E. O'Brien t->t_dflg &= ~F_AMPERSAND;
90c80476e4SDavid E. O'Brien backgnd.bname = short2str(cp);
91c80476e4SDavid E. O'Brien return (&backgnd);
92c80476e4SDavid E. O'Brien }
93c80476e4SDavid E. O'Brien foregnd.bname = short2str(cp);
94c80476e4SDavid E. O'Brien return (&foregnd);
95c80476e4SDavid E. O'Brien }
96c80476e4SDavid E. O'Brien #ifdef WARP
97c80476e4SDavid E. O'Brien /*
98c80476e4SDavid E. O'Brien * This is a perhaps kludgy way to determine if the warp builtin is to be
99c80476e4SDavid E. O'Brien * acknowledged or not. If checkwarp() fails, then we are to assume that
100c80476e4SDavid E. O'Brien * the warp command is invalid, and carry on as we would handle any other
101c80476e4SDavid E. O'Brien * non-builtin command. -- JDK 2/4/88
102c80476e4SDavid E. O'Brien */
103c80476e4SDavid E. O'Brien if (eq(STRwarp, cp) && !checkwarp()) {
104c80476e4SDavid E. O'Brien return (0); /* this builtin disabled */
105c80476e4SDavid E. O'Brien }
106c80476e4SDavid E. O'Brien #endif /* WARP */
107c80476e4SDavid E. O'Brien /*
108c80476e4SDavid E. O'Brien * Binary search Bp1 is the beginning of the current search range. Bp2 is
109c80476e4SDavid E. O'Brien * one past the end.
110c80476e4SDavid E. O'Brien */
111c80476e4SDavid E. O'Brien for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
112c80476e4SDavid E. O'Brien int i;
113c80476e4SDavid E. O'Brien
114c80476e4SDavid E. O'Brien bp = bp1 + ((bp2 - bp1) >> 1);
115c80476e4SDavid E. O'Brien if ((i = ((char) *cp) - *bp->bname) == 0 &&
116c80476e4SDavid E. O'Brien (i = StrQcmp(cp, str2short(bp->bname))) == 0)
117c80476e4SDavid E. O'Brien return bp;
118c80476e4SDavid E. O'Brien if (i < 0)
119c80476e4SDavid E. O'Brien bp2 = bp;
120c80476e4SDavid E. O'Brien else
121c80476e4SDavid E. O'Brien bp1 = bp + 1;
122c80476e4SDavid E. O'Brien }
123c80476e4SDavid E. O'Brien #ifdef WINNT_NATIVE
124c80476e4SDavid E. O'Brien return nt_check_additional_builtins(cp);
125c80476e4SDavid E. O'Brien #endif /*WINNT_NATIVE*/
126c80476e4SDavid E. O'Brien return (0);
1273b6eaa7bSAndrey A. Chernov }
128c80476e4SDavid E. O'Brien
1293b6eaa7bSAndrey A. Chernov void
func(struct command * t,const struct biltins * bp)130c80476e4SDavid E. O'Brien func(struct command *t, const struct biltins *bp)
131c80476e4SDavid E. O'Brien {
132c80476e4SDavid E. O'Brien int i;
133c80476e4SDavid E. O'Brien
13445e5710bSMark Peek xechoit(t->t_dcom);
135c80476e4SDavid E. O'Brien setname(bp->bname);
136c80476e4SDavid E. O'Brien i = blklen(t->t_dcom) - 1;
137c80476e4SDavid E. O'Brien if (i < bp->minargs)
138c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_TOOFEW);
139c80476e4SDavid E. O'Brien if (i > bp->maxargs)
140c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_TOOMANY);
141c80476e4SDavid E. O'Brien (*bp->bfunct) (t->t_dcom, t);
142c80476e4SDavid E. O'Brien }
143c80476e4SDavid E. O'Brien
144c80476e4SDavid E. O'Brien /*ARGSUSED*/
145c80476e4SDavid E. O'Brien void
doonintr(Char ** v,struct command * c)146c80476e4SDavid E. O'Brien doonintr(Char **v, struct command *c)
147c80476e4SDavid E. O'Brien {
148c80476e4SDavid E. O'Brien Char *cp;
149c80476e4SDavid E. O'Brien Char *vv = v[1];
15045e5710bSMark Peek
151c80476e4SDavid E. O'Brien USE(c);
15223338178SMark Peek if (parintr.sa_handler == SIG_IGN)
15323338178SMark Peek return;
154c80476e4SDavid E. O'Brien if (setintr && intty)
155c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_TERMINAL);
15645e5710bSMark Peek cp = gointr;
157c80476e4SDavid E. O'Brien gointr = 0;
158c80476e4SDavid E. O'Brien xfree(cp);
159c80476e4SDavid E. O'Brien if (vv == 0) {
160c80476e4SDavid E. O'Brien if (setintr)
161c80476e4SDavid E. O'Brien sigset_interrupting(SIGINT, queue_pintr);
16245e5710bSMark Peek else
163c80476e4SDavid E. O'Brien (void) signal(SIGINT, SIG_DFL);
16445e5710bSMark Peek gointr = 0;
16545e5710bSMark Peek }
166c80476e4SDavid E. O'Brien else if (eq((vv = strip(vv)), STRminus)) {
167c80476e4SDavid E. O'Brien (void) signal(SIGINT, SIG_IGN);
168c80476e4SDavid E. O'Brien gointr = Strsave(STRminus);
169c80476e4SDavid E. O'Brien }
170c80476e4SDavid E. O'Brien else {
171c80476e4SDavid E. O'Brien gointr = Strsave(vv);
172c80476e4SDavid E. O'Brien sigset_interrupting(SIGINT, queue_pintr);
173c80476e4SDavid E. O'Brien }
174c80476e4SDavid E. O'Brien }
175c80476e4SDavid E. O'Brien
17645e5710bSMark Peek /*ARGSUSED*/
177c80476e4SDavid E. O'Brien void
donohup(Char ** v,struct command * c)178c80476e4SDavid E. O'Brien donohup(Char **v, struct command *c)
179c80476e4SDavid E. O'Brien {
180c80476e4SDavid E. O'Brien USE(c);
181c80476e4SDavid E. O'Brien USE(v);
18245e5710bSMark Peek if (intty)
183c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_TERMINAL);
184c80476e4SDavid E. O'Brien if (setintr == 0) {
185c80476e4SDavid E. O'Brien (void) signal(SIGHUP, SIG_IGN);
186c80476e4SDavid E. O'Brien phup_disabled = 1;
187c80476e4SDavid E. O'Brien #ifdef CC
188c80476e4SDavid E. O'Brien submit(getpid());
189c80476e4SDavid E. O'Brien #endif /* CC */
19045e5710bSMark Peek }
191c80476e4SDavid E. O'Brien }
192c80476e4SDavid E. O'Brien
193c80476e4SDavid E. O'Brien /*ARGSUSED*/
194c80476e4SDavid E. O'Brien void
dohup(Char ** v,struct command * c)195c80476e4SDavid E. O'Brien dohup(Char **v, struct command *c)
196c80476e4SDavid E. O'Brien {
197c80476e4SDavid E. O'Brien USE(c);
198c80476e4SDavid E. O'Brien USE(v);
19945e5710bSMark Peek if (intty)
200c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_TERMINAL);
201c80476e4SDavid E. O'Brien if (setintr == 0)
202c80476e4SDavid E. O'Brien sigset_interrupting(SIGHUP, SIG_DFL);
203c80476e4SDavid E. O'Brien }
204c80476e4SDavid E. O'Brien
205c80476e4SDavid E. O'Brien
206c80476e4SDavid E. O'Brien /*ARGSUSED*/
207c80476e4SDavid E. O'Brien void
dozip(Char ** v,struct command * c)208c80476e4SDavid E. O'Brien dozip(Char **v, struct command *c)
209c80476e4SDavid E. O'Brien {
210c80476e4SDavid E. O'Brien USE(c);
211c80476e4SDavid E. O'Brien USE(v);
21245e5710bSMark Peek }
213c80476e4SDavid E. O'Brien
214c80476e4SDavid E. O'Brien /*ARGSUSED*/
215c80476e4SDavid E. O'Brien void
dofiletest(Char ** v,struct command * c)216c80476e4SDavid E. O'Brien dofiletest(Char **v, struct command *c)
217c80476e4SDavid E. O'Brien {
218c80476e4SDavid E. O'Brien Char **globbed, **fileptr, *ftest, *res;
219c80476e4SDavid E. O'Brien
22045e5710bSMark Peek USE(c);
221c80476e4SDavid E. O'Brien if (*(ftest = *++v) != '-')
22245e5710bSMark Peek stderror(ERR_NAME | ERR_FILEINQ);
223c80476e4SDavid E. O'Brien ++v;
22423338178SMark Peek
225c80476e4SDavid E. O'Brien v = glob_all_or_error(v);
226c80476e4SDavid E. O'Brien globbed = v;
227c80476e4SDavid E. O'Brien cleanup_push(globbed, blk_cleanup);
228c80476e4SDavid E. O'Brien
22945e5710bSMark Peek while (*(fileptr = v++) != NULL) {
23045e5710bSMark Peek res = filetest(ftest, &fileptr, 0);
23145e5710bSMark Peek cleanup_push(res, xfree);
232c80476e4SDavid E. O'Brien xprintf("%S", res);
233c80476e4SDavid E. O'Brien cleanup_until(res);
23445e5710bSMark Peek if (*v)
23545e5710bSMark Peek xprintf(" ");
23645e5710bSMark Peek }
23745e5710bSMark Peek xprintf("\n");
238c80476e4SDavid E. O'Brien
239c80476e4SDavid E. O'Brien cleanup_until(globbed);
240c80476e4SDavid E. O'Brien }
241c80476e4SDavid E. O'Brien
242c80476e4SDavid E. O'Brien void
prvars(void)24345e5710bSMark Peek prvars(void)
244c80476e4SDavid E. O'Brien {
245c80476e4SDavid E. O'Brien plist(&shvhed, VAR_ALL);
246c80476e4SDavid E. O'Brien }
24745e5710bSMark Peek
248c80476e4SDavid E. O'Brien /*ARGSUSED*/
249c80476e4SDavid E. O'Brien void
doalias(Char ** v,struct command * c)250c80476e4SDavid E. O'Brien doalias(Char **v, struct command *c)
251c80476e4SDavid E. O'Brien {
252c80476e4SDavid E. O'Brien struct varent *vp;
253c80476e4SDavid E. O'Brien Char *p;
25445e5710bSMark Peek
255c80476e4SDavid E. O'Brien USE(c);
25623338178SMark Peek v++;
25723338178SMark Peek p = *v++;
258c80476e4SDavid E. O'Brien if (p == 0)
259c80476e4SDavid E. O'Brien plist(&aliases, VAR_ALL);
260c80476e4SDavid E. O'Brien else if (*v == 0) {
261c80476e4SDavid E. O'Brien vp = adrof1(strip(p), &aliases);
262c80476e4SDavid E. O'Brien if (vp && vp->vec)
263c80476e4SDavid E. O'Brien blkpr(vp->vec), xputchar('\n');
264c80476e4SDavid E. O'Brien }
265c80476e4SDavid E. O'Brien else {
26629301572SMark Peek if (eq(p, STRalias) || eq(p, STRunalias)) {
267c80476e4SDavid E. O'Brien setname(short2str(p));
268c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_DANGER);
269c80476e4SDavid E. O'Brien }
270c80476e4SDavid E. O'Brien set1(strip(p), saveblk(v), &aliases, VAR_READWRITE);
271c80476e4SDavid E. O'Brien tw_cmd_free();
272c80476e4SDavid E. O'Brien }
273c80476e4SDavid E. O'Brien }
274c80476e4SDavid E. O'Brien
275c80476e4SDavid E. O'Brien /*ARGSUSED*/
276c80476e4SDavid E. O'Brien void
unalias(Char ** v,struct command * c)277c80476e4SDavid E. O'Brien unalias(Char **v, struct command *c)
278c80476e4SDavid E. O'Brien {
279c80476e4SDavid E. O'Brien USE(c);
280c80476e4SDavid E. O'Brien unset1(v, &aliases);
28145e5710bSMark Peek tw_cmd_free();
282c80476e4SDavid E. O'Brien }
283c80476e4SDavid E. O'Brien
284c80476e4SDavid E. O'Brien /*ARGSUSED*/
285c80476e4SDavid E. O'Brien void
dologout(Char ** v,struct command * c)286c80476e4SDavid E. O'Brien dologout(Char **v, struct command *c)
287c80476e4SDavid E. O'Brien {
288c80476e4SDavid E. O'Brien USE(c);
289c80476e4SDavid E. O'Brien USE(v);
29045e5710bSMark Peek islogin();
291c80476e4SDavid E. O'Brien goodbye(NULL, NULL);
292c80476e4SDavid E. O'Brien }
293c80476e4SDavid E. O'Brien
294c80476e4SDavid E. O'Brien /*ARGSUSED*/
295c80476e4SDavid E. O'Brien void
dologin(Char ** v,struct command * c)296c80476e4SDavid E. O'Brien dologin(Char **v, struct command *c)
297c80476e4SDavid E. O'Brien {
298c80476e4SDavid E. O'Brien #ifdef WINNT_NATIVE
299c80476e4SDavid E. O'Brien USE(c);
30045e5710bSMark Peek USE(v);
301c80476e4SDavid E. O'Brien #else /* !WINNT_NATIVE */
3023b6eaa7bSAndrey A. Chernov char **p = short2blk(v);
303b2d5d167SMark Peek
304c80476e4SDavid E. O'Brien USE(c);
3053b6eaa7bSAndrey A. Chernov cleanup_push((Char **)p, blk_cleanup);
306b2d5d167SMark Peek islogin();
30745e5710bSMark Peek rechist(NULL, adrof(STRsavehist) != NULL);
308b2d5d167SMark Peek sigaction(SIGTERM, &parterm, NULL);
30945e5710bSMark Peek (void) execv(_PATH_BIN_LOGIN, p);
310c80476e4SDavid E. O'Brien (void) execv(_PATH_USRBIN_LOGIN, p);
311c80476e4SDavid E. O'Brien cleanup_until((Char **)p);
31245e5710bSMark Peek untty();
313b2d5d167SMark Peek xexit(1);
314b2d5d167SMark Peek #endif /* !WINNT_NATIVE */
31545e5710bSMark Peek }
316c80476e4SDavid E. O'Brien
317c80476e4SDavid E. O'Brien
3183b6eaa7bSAndrey A. Chernov #ifdef NEWGRP
319c80476e4SDavid E. O'Brien /*ARGSUSED*/
320c80476e4SDavid E. O'Brien void
donewgrp(Char ** v,struct command * c)321c80476e4SDavid E. O'Brien donewgrp(Char **v, struct command *c)
322c80476e4SDavid E. O'Brien {
323c80476e4SDavid E. O'Brien char **p;
324c80476e4SDavid E. O'Brien if (chkstop == 0 && setintr)
32545e5710bSMark Peek panystop(0);
326c80476e4SDavid E. O'Brien sigaction(SIGTERM, &parterm, NULL);
327c80476e4SDavid E. O'Brien p = short2blk(v);
328c80476e4SDavid E. O'Brien /*
329c80476e4SDavid E. O'Brien * From Beto Appleton (beto@aixwiz.austin.ibm.com)
33045e5710bSMark Peek * Newgrp can take 2 arguments...
331c80476e4SDavid E. O'Brien */
332c80476e4SDavid E. O'Brien (void) execv(_PATH_BIN_NEWGRP, p);
333c80476e4SDavid E. O'Brien (void) execv(_PATH_USRBIN_NEWGRP, p);
334c80476e4SDavid E. O'Brien blkfree((Char **) p);
335c80476e4SDavid E. O'Brien untty();
336c80476e4SDavid E. O'Brien xexit(1);
337c80476e4SDavid E. O'Brien }
338c80476e4SDavid E. O'Brien #endif /* NEWGRP */
339c80476e4SDavid E. O'Brien
340c80476e4SDavid E. O'Brien static void
islogin(void)341c80476e4SDavid E. O'Brien islogin(void)
342c80476e4SDavid E. O'Brien {
343c80476e4SDavid E. O'Brien if (chkstop == 0 && setintr)
344c80476e4SDavid E. O'Brien panystop(0);
34545e5710bSMark Peek if (loginsh)
346c80476e4SDavid E. O'Brien return;
347c80476e4SDavid E. O'Brien stderror(ERR_NOTLOGIN);
348c80476e4SDavid E. O'Brien }
349c80476e4SDavid E. O'Brien
350c80476e4SDavid E. O'Brien void
doif(Char ** v,struct command * kp)351c80476e4SDavid E. O'Brien doif(Char **v, struct command *kp)
352c80476e4SDavid E. O'Brien {
353c80476e4SDavid E. O'Brien int i;
354c80476e4SDavid E. O'Brien Char **vv;
35545e5710bSMark Peek
356c80476e4SDavid E. O'Brien v++;
35723338178SMark Peek i = noexec ? 1 : expr(&v);
35823338178SMark Peek vv = v;
359c80476e4SDavid E. O'Brien if (*vv == NULL)
360c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_EMPTYIF);
36145e5710bSMark Peek if (eq(*vv, STRthen)) {
362c80476e4SDavid E. O'Brien if (*++vv)
363c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_IMPRTHEN);
364c80476e4SDavid E. O'Brien setname(short2str(STRthen));
365c80476e4SDavid E. O'Brien /*
366c80476e4SDavid E. O'Brien * If expression was zero, then scan to else , otherwise just fall into
367c80476e4SDavid E. O'Brien * following code.
368c80476e4SDavid E. O'Brien */
369c80476e4SDavid E. O'Brien if (!i)
370c80476e4SDavid E. O'Brien search(TC_IF, 0, NULL);
371c80476e4SDavid E. O'Brien return;
372c80476e4SDavid E. O'Brien }
373c80476e4SDavid E. O'Brien /*
374c80476e4SDavid E. O'Brien * Simple command attached to this if. Left shift the node in this tree,
375c80476e4SDavid E. O'Brien * munging it so we can reexecute it.
376c80476e4SDavid E. O'Brien */
377c80476e4SDavid E. O'Brien if (i) {
378c80476e4SDavid E. O'Brien lshift(kp->t_dcom, vv - kp->t_dcom);
379c80476e4SDavid E. O'Brien reexecute(kp);
380c80476e4SDavid E. O'Brien donefds();
381c80476e4SDavid E. O'Brien }
382c80476e4SDavid E. O'Brien }
383c80476e4SDavid E. O'Brien
384c80476e4SDavid E. O'Brien /*
385c80476e4SDavid E. O'Brien * Reexecute a command, being careful not
386c80476e4SDavid E. O'Brien * to redo i/o redirection, which is already set up.
387c80476e4SDavid E. O'Brien */
388c80476e4SDavid E. O'Brien void
reexecute(struct command * kp)389c80476e4SDavid E. O'Brien reexecute(struct command *kp)
390c80476e4SDavid E. O'Brien {
391c80476e4SDavid E. O'Brien kp->t_dflg &= F_SAVE;
392c80476e4SDavid E. O'Brien kp->t_dflg |= F_REPEAT;
39345e5710bSMark Peek /*
394c80476e4SDavid E. O'Brien * If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
395c80476e4SDavid E. O'Brien * pgrp's as the jobs would then have no way to get the tty (we can't give
396c80476e4SDavid E. O'Brien * it to them, and our parent wouldn't know their pgrp, etc.
397c80476e4SDavid E. O'Brien */
398c80476e4SDavid E. O'Brien execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL, TRUE);
399c80476e4SDavid E. O'Brien }
400c80476e4SDavid E. O'Brien
401c80476e4SDavid E. O'Brien /*ARGSUSED*/
40229301572SMark Peek void
doelse(Char ** v,struct command * c)403c80476e4SDavid E. O'Brien doelse (Char **v, struct command *c)
404c80476e4SDavid E. O'Brien {
405c80476e4SDavid E. O'Brien USE(c);
406c80476e4SDavid E. O'Brien USE(v);
40745e5710bSMark Peek if (!noexec)
408c80476e4SDavid E. O'Brien search(TC_ELSE, 0, NULL);
409c80476e4SDavid E. O'Brien }
410c80476e4SDavid E. O'Brien
41145e5710bSMark Peek /*ARGSUSED*/
412c80476e4SDavid E. O'Brien void
dogoto(Char ** v,struct command * c)413c80476e4SDavid E. O'Brien dogoto(Char **v, struct command *c)
414c80476e4SDavid E. O'Brien {
415c80476e4SDavid E. O'Brien Char *lp;
416c80476e4SDavid E. O'Brien
41745e5710bSMark Peek USE(c);
418c80476e4SDavid E. O'Brien lp = globone(v[1], G_ERROR);
419c80476e4SDavid E. O'Brien cleanup_push(lp, xfree);
420c80476e4SDavid E. O'Brien if (!noexec)
421c80476e4SDavid E. O'Brien gotolab(lp);
42245e5710bSMark Peek cleanup_until(lp);
42345e5710bSMark Peek }
42445e5710bSMark Peek
42545e5710bSMark Peek void
gotolab(Char * lab)42645e5710bSMark Peek gotolab(Char *lab)
427c80476e4SDavid E. O'Brien {
428c80476e4SDavid E. O'Brien struct whyle *wp;
429c80476e4SDavid E. O'Brien /*
43045e5710bSMark Peek * While we still can, locate any unknown ends of existing loops. This
431c80476e4SDavid E. O'Brien * obscure code is the WORST result of the fact that we don't really parse.
43223338178SMark Peek */
433c80476e4SDavid E. O'Brien zlast = TC_GOTO;
434c80476e4SDavid E. O'Brien for (wp = whyles; wp; wp = wp->w_next)
435c80476e4SDavid E. O'Brien if (wp->w_end.type == TCSH_F_SEEK && wp->w_end.f_seek == 0) {
436c80476e4SDavid E. O'Brien search(TC_BREAK, 0, NULL);
437c80476e4SDavid E. O'Brien btell(&wp->w_end);
438c80476e4SDavid E. O'Brien }
4393b6eaa7bSAndrey A. Chernov else {
440c80476e4SDavid E. O'Brien bseek(&wp->w_end);
441c80476e4SDavid E. O'Brien }
442c80476e4SDavid E. O'Brien search(TC_GOTO, 0, lab);
443c80476e4SDavid E. O'Brien /*
444c80476e4SDavid E. O'Brien * Eliminate loops which were exited.
445c80476e4SDavid E. O'Brien */
446c80476e4SDavid E. O'Brien wfree();
447c80476e4SDavid E. O'Brien }
448c80476e4SDavid E. O'Brien
449c80476e4SDavid E. O'Brien /*ARGSUSED*/
450c80476e4SDavid E. O'Brien void
doswitch(Char ** v,struct command * c)451c80476e4SDavid E. O'Brien doswitch(Char **v, struct command *c)
452c80476e4SDavid E. O'Brien {
453c80476e4SDavid E. O'Brien Char *cp, *lp;
454c80476e4SDavid E. O'Brien
45545e5710bSMark Peek USE(c);
456c80476e4SDavid E. O'Brien v++;
45723338178SMark Peek if (!*v || *(*v++) != '(')
458c80476e4SDavid E. O'Brien stderror(ERR_SYNTAX);
459c80476e4SDavid E. O'Brien cp = **v == ')' ? STRNULL : *v++;
460c80476e4SDavid E. O'Brien if (*(*v++) != ')')
461c80476e4SDavid E. O'Brien v--;
462c80476e4SDavid E. O'Brien if (*v)
463c80476e4SDavid E. O'Brien stderror(ERR_SYNTAX);
464c80476e4SDavid E. O'Brien lp = globone(cp, G_ERROR);
465c80476e4SDavid E. O'Brien cleanup_push(lp, xfree);
466c80476e4SDavid E. O'Brien if (!noexec)
467c80476e4SDavid E. O'Brien search(TC_SWITCH, 0, lp);
46845e5710bSMark Peek cleanup_until(lp);
46945e5710bSMark Peek }
47045e5710bSMark Peek
47145e5710bSMark Peek /*ARGSUSED*/
47245e5710bSMark Peek void
dobreak(Char ** v,struct command * c)473c80476e4SDavid E. O'Brien dobreak(Char **v, struct command *c)
474c80476e4SDavid E. O'Brien {
475c80476e4SDavid E. O'Brien USE(v);
476c80476e4SDavid E. O'Brien USE(c);
47745e5710bSMark Peek if (whyles == NULL)
478c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTWHILE);
479c80476e4SDavid E. O'Brien if (!noexec)
480c80476e4SDavid E. O'Brien toend();
48145e5710bSMark Peek }
482c80476e4SDavid E. O'Brien
48345e5710bSMark Peek /*ARGSUSED*/
48445e5710bSMark Peek void
doexit(Char ** v,struct command * c)485c80476e4SDavid E. O'Brien doexit(Char **v, struct command *c)
486c80476e4SDavid E. O'Brien {
487c80476e4SDavid E. O'Brien USE(c);
488c80476e4SDavid E. O'Brien
48945e5710bSMark Peek if (chkstop == 0 && (intty || intact) && evalvec == 0)
490c80476e4SDavid E. O'Brien panystop(0);
491c80476e4SDavid E. O'Brien /*
492c80476e4SDavid E. O'Brien * Don't DEMAND parentheses here either.
493c80476e4SDavid E. O'Brien */
494c80476e4SDavid E. O'Brien v++;
495c80476e4SDavid E. O'Brien if (*v) {
496c80476e4SDavid E. O'Brien setv(STRstatus, putn(expr(&v)), VAR_READWRITE);
497c80476e4SDavid E. O'Brien if (*v)
498c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_EXPRESSION);
499c80476e4SDavid E. O'Brien }
50045e5710bSMark Peek btoeof();
501c80476e4SDavid E. O'Brien #if 0
502c80476e4SDavid E. O'Brien if (intty)
503c80476e4SDavid E. O'Brien #endif
504c80476e4SDavid E. O'Brien /* Always close, why only on ttys? */
505c80476e4SDavid E. O'Brien xclose(SHIN);
506c80476e4SDavid E. O'Brien }
507c80476e4SDavid E. O'Brien
508c80476e4SDavid E. O'Brien /*ARGSUSED*/
50945e5710bSMark Peek void
doforeach(Char ** v,struct command * c)510c80476e4SDavid E. O'Brien doforeach(Char **v, struct command *c)
511c80476e4SDavid E. O'Brien {
512c80476e4SDavid E. O'Brien Char *cp, *sp;
513c80476e4SDavid E. O'Brien struct whyle *nwp;
51445e5710bSMark Peek int gflag;
515c80476e4SDavid E. O'Brien
51623338178SMark Peek USE(c);
51723338178SMark Peek v++;
51845e5710bSMark Peek cp = sp = strip(*v);
519c80476e4SDavid E. O'Brien if (!letter(*cp))
520c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_VARBEGIN);
521c80476e4SDavid E. O'Brien do {
522c80476e4SDavid E. O'Brien cp++;
523c80476e4SDavid E. O'Brien } while (alnum(*cp));
524c80476e4SDavid E. O'Brien if (*cp != '\0')
525c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_VARALNUM);
526c80476e4SDavid E. O'Brien cp = *v++;
527c80476e4SDavid E. O'Brien if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
528c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOPAREN);
529c80476e4SDavid E. O'Brien v++;
530c80476e4SDavid E. O'Brien gflag = tglob(v);
531c80476e4SDavid E. O'Brien if (gflag) {
532c80476e4SDavid E. O'Brien v = globall(v, gflag);
53345e5710bSMark Peek if (v == 0 && !noexec)
534c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOMATCH);
53545e5710bSMark Peek }
53645e5710bSMark Peek else {
537c80476e4SDavid E. O'Brien v = saveblk(v);
538c80476e4SDavid E. O'Brien trim(v);
539c80476e4SDavid E. O'Brien }
54045e5710bSMark Peek nwp = xcalloc(1, sizeof *nwp);
541c80476e4SDavid E. O'Brien nwp->w_fe = nwp->w_fe0 = v;
542c80476e4SDavid E. O'Brien btell(&nwp->w_start);
54345e5710bSMark Peek nwp->w_fename = Strsave(cp);
544c80476e4SDavid E. O'Brien nwp->w_next = whyles;
545c80476e4SDavid E. O'Brien nwp->w_end.type = TCSH_F_SEEK;
546c80476e4SDavid E. O'Brien whyles = nwp;
547c80476e4SDavid E. O'Brien /*
5483b6eaa7bSAndrey A. Chernov * Pre-read the loop so as to be more comprehensible to a terminal user.
549c80476e4SDavid E. O'Brien */
550c80476e4SDavid E. O'Brien zlast = TC_FOREACH;
551c80476e4SDavid E. O'Brien if (intty)
552c80476e4SDavid E. O'Brien preread();
553c80476e4SDavid E. O'Brien if (!noexec)
554c80476e4SDavid E. O'Brien doagain();
555c80476e4SDavid E. O'Brien }
55645e5710bSMark Peek
557c80476e4SDavid E. O'Brien /*ARGSUSED*/
558c80476e4SDavid E. O'Brien void
dowhile(Char ** v,struct command * c)559c80476e4SDavid E. O'Brien dowhile(Char **v, struct command *c)
560c80476e4SDavid E. O'Brien {
561c80476e4SDavid E. O'Brien int status;
56245e5710bSMark Peek int again = whyles != 0 &&
563c80476e4SDavid E. O'Brien SEEKEQ(&whyles->w_start, &lineloc) &&
56423338178SMark Peek whyles->w_fename == 0;
56523338178SMark Peek
566c80476e4SDavid E. O'Brien USE(c);
567c80476e4SDavid E. O'Brien v++;
568c80476e4SDavid E. O'Brien /*
569c80476e4SDavid E. O'Brien * Implement prereading here also, taking care not to evaluate the
570c80476e4SDavid E. O'Brien * expression before the loop has been read up from a terminal.
571c80476e4SDavid E. O'Brien */
572c80476e4SDavid E. O'Brien if (noexec)
573c80476e4SDavid E. O'Brien status = 0;
574c80476e4SDavid E. O'Brien else if (intty && !again)
57545e5710bSMark Peek status = !exp0(&v, 1);
57645e5710bSMark Peek else
57745e5710bSMark Peek status = !expr(&v);
578c80476e4SDavid E. O'Brien if (*v && !noexec)
579c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_EXPRESSION);
580c80476e4SDavid E. O'Brien if (!again) {
58145e5710bSMark Peek struct whyle *nwp = xcalloc(1, sizeof(*nwp));
582c80476e4SDavid E. O'Brien
583c80476e4SDavid E. O'Brien nwp->w_start = lineloc;
58445e5710bSMark Peek nwp->w_end.type = TCSH_F_SEEK;
585c80476e4SDavid E. O'Brien nwp->w_end.f_seek = 0;
586c80476e4SDavid E. O'Brien nwp->w_end.a_seek = 0;
5873b6eaa7bSAndrey A. Chernov nwp->w_next = whyles;
588c80476e4SDavid E. O'Brien whyles = nwp;
589c80476e4SDavid E. O'Brien zlast = TC_WHILE;
590c80476e4SDavid E. O'Brien if (intty) {
591c80476e4SDavid E. O'Brien /*
592c80476e4SDavid E. O'Brien * The tty preread
593c80476e4SDavid E. O'Brien */
594c80476e4SDavid E. O'Brien preread();
595c80476e4SDavid E. O'Brien doagain();
596c80476e4SDavid E. O'Brien return;
597c80476e4SDavid E. O'Brien }
598c80476e4SDavid E. O'Brien }
599c80476e4SDavid E. O'Brien if (status)
600c80476e4SDavid E. O'Brien /* We ain't gonna loop no more, no more! */
601c80476e4SDavid E. O'Brien toend();
602c80476e4SDavid E. O'Brien }
603c80476e4SDavid E. O'Brien
604c80476e4SDavid E. O'Brien static void
preread(void)605c80476e4SDavid E. O'Brien preread(void)
606c80476e4SDavid E. O'Brien {
60745e5710bSMark Peek int old_pintr_disabled;
608c80476e4SDavid E. O'Brien
60945e5710bSMark Peek whyles->w_end.type = TCSH_I_SEEK;
61045e5710bSMark Peek if (setintr)
6113b6eaa7bSAndrey A. Chernov pintr_push_enable(&old_pintr_disabled);
612c80476e4SDavid E. O'Brien search(TC_BREAK, 0, NULL); /* read the expression in */
61345e5710bSMark Peek if (setintr)
614c80476e4SDavid E. O'Brien cleanup_until(&old_pintr_disabled);
615c80476e4SDavid E. O'Brien btell(&whyles->w_end);
61645e5710bSMark Peek }
617c80476e4SDavid E. O'Brien
618c80476e4SDavid E. O'Brien /*ARGSUSED*/
619c80476e4SDavid E. O'Brien void
doend(Char ** v,struct command * c)620c80476e4SDavid E. O'Brien doend(Char **v, struct command *c)
621c80476e4SDavid E. O'Brien {
62245e5710bSMark Peek USE(v);
623c80476e4SDavid E. O'Brien USE(c);
624c80476e4SDavid E. O'Brien if (!whyles)
625c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTWHILE);
626c80476e4SDavid E. O'Brien btell(&whyles->w_end);
627c80476e4SDavid E. O'Brien if (!noexec)
628c80476e4SDavid E. O'Brien doagain();
62945e5710bSMark Peek }
630c80476e4SDavid E. O'Brien
631c80476e4SDavid E. O'Brien /*ARGSUSED*/
632c80476e4SDavid E. O'Brien void
docontin(Char ** v,struct command * c)633c80476e4SDavid E. O'Brien docontin(Char **v, struct command *c)
634c80476e4SDavid E. O'Brien {
63545e5710bSMark Peek USE(v);
636c80476e4SDavid E. O'Brien USE(c);
637c80476e4SDavid E. O'Brien if (!whyles)
638c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTWHILE);
639c80476e4SDavid E. O'Brien if (!noexec)
640c80476e4SDavid E. O'Brien doagain();
64145e5710bSMark Peek }
642c80476e4SDavid E. O'Brien
643c80476e4SDavid E. O'Brien static void
doagain(void)644c80476e4SDavid E. O'Brien doagain(void)
645c80476e4SDavid E. O'Brien {
64645e5710bSMark Peek /* Repeating a while is simple */
647c80476e4SDavid E. O'Brien if (whyles->w_fename == 0) {
648c80476e4SDavid E. O'Brien bseek(&whyles->w_start);
649c80476e4SDavid E. O'Brien return;
650c80476e4SDavid E. O'Brien }
651c80476e4SDavid E. O'Brien /*
652c80476e4SDavid E. O'Brien * The foreach variable list actually has a spurious word ")" at the end of
653c80476e4SDavid E. O'Brien * the w_fe list. Thus we are at the of the list if one word beyond this
654c80476e4SDavid E. O'Brien * is 0.
655c80476e4SDavid E. O'Brien */
656c80476e4SDavid E. O'Brien if (!whyles->w_fe[1]) {
657c80476e4SDavid E. O'Brien dobreak(NULL, NULL);
658c80476e4SDavid E. O'Brien return;
659c80476e4SDavid E. O'Brien }
660c80476e4SDavid E. O'Brien setv(whyles->w_fename, quote(Strsave(*whyles->w_fe++)), VAR_READWRITE);
661c80476e4SDavid E. O'Brien bseek(&whyles->w_start);
66245e5710bSMark Peek }
663c80476e4SDavid E. O'Brien
664c80476e4SDavid E. O'Brien void
dorepeat(Char ** v,struct command * kp)665c80476e4SDavid E. O'Brien dorepeat(Char **v, struct command *kp)
666c80476e4SDavid E. O'Brien {
66745e5710bSMark Peek int i = 1;
668c80476e4SDavid E. O'Brien
66929301572SMark Peek do {
670c80476e4SDavid E. O'Brien i *= getn(v[1]);
67129301572SMark Peek lshift(v, 2);
67229301572SMark Peek } while (v[0] != NULL && Strcmp(v[0], STRrepeat) == 0);
67329301572SMark Peek if (noexec)
67429301572SMark Peek i = 1;
67545e5710bSMark Peek
67645e5710bSMark Peek if (setintr) {
67729301572SMark Peek pintr_disabled++;
67845e5710bSMark Peek cleanup_push(&pintr_disabled, disabled_cleanup);
67945e5710bSMark Peek }
68045e5710bSMark Peek while (i > 0) {
68145e5710bSMark Peek if (setintr && pintr_disabled == 1) {
682c80476e4SDavid E. O'Brien cleanup_until(&pintr_disabled);
68345e5710bSMark Peek pintr_disabled++;
68445e5710bSMark Peek cleanup_push(&pintr_disabled, disabled_cleanup);
68545e5710bSMark Peek }
68645e5710bSMark Peek reexecute(kp);
68745e5710bSMark Peek --i;
688c80476e4SDavid E. O'Brien }
689c80476e4SDavid E. O'Brien if (setintr && pintr_disabled == 1)
690c80476e4SDavid E. O'Brien cleanup_until(&pintr_disabled);
69145e5710bSMark Peek donefds();
692c80476e4SDavid E. O'Brien }
693c80476e4SDavid E. O'Brien
694c80476e4SDavid E. O'Brien /*ARGSUSED*/
695c80476e4SDavid E. O'Brien void
doswbrk(Char ** v,struct command * c)696c80476e4SDavid E. O'Brien doswbrk(Char **v, struct command *c)
69745e5710bSMark Peek {
698c80476e4SDavid E. O'Brien USE(v);
699c80476e4SDavid E. O'Brien USE(c);
700c80476e4SDavid E. O'Brien if (!noexec)
70145e5710bSMark Peek search(TC_BRKSW, 0, NULL);
702c80476e4SDavid E. O'Brien }
703c80476e4SDavid E. O'Brien
704c80476e4SDavid E. O'Brien int
srchx(Char * cp)705c80476e4SDavid E. O'Brien srchx(Char *cp)
70645e5710bSMark Peek {
707c80476e4SDavid E. O'Brien struct srch *sp, *sp1, *sp2;
708c80476e4SDavid E. O'Brien int i;
709c80476e4SDavid E. O'Brien
710c80476e4SDavid E. O'Brien /*
711c80476e4SDavid E. O'Brien * Ignore keywords inside heredocs
712c80476e4SDavid E. O'Brien */
713c80476e4SDavid E. O'Brien if (inheredoc)
714c80476e4SDavid E. O'Brien return -1;
715c80476e4SDavid E. O'Brien
716c80476e4SDavid E. O'Brien /*
717c80476e4SDavid E. O'Brien * Binary search Sp1 is the beginning of the current search range. Sp2 is
718c80476e4SDavid E. O'Brien * one past the end.
719c80476e4SDavid E. O'Brien */
720c80476e4SDavid E. O'Brien for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
721c80476e4SDavid E. O'Brien sp = sp1 + ((sp2 - sp1) >> 1);
722c80476e4SDavid E. O'Brien if ((i = *cp - *sp->s_name) == 0 &&
723c80476e4SDavid E. O'Brien (i = Strcmp(cp, str2short(sp->s_name))) == 0)
724c80476e4SDavid E. O'Brien return sp->s_value;
725c80476e4SDavid E. O'Brien if (i < 0)
726c80476e4SDavid E. O'Brien sp2 = sp;
727c80476e4SDavid E. O'Brien else
728c80476e4SDavid E. O'Brien sp1 = sp + 1;
729c80476e4SDavid E. O'Brien }
730c80476e4SDavid E. O'Brien return (-1);
731c80476e4SDavid E. O'Brien }
732c80476e4SDavid E. O'Brien
733c80476e4SDavid E. O'Brien static const char *
isrchx(int n)73423338178SMark Peek isrchx(int n)
73545e5710bSMark Peek {
736c80476e4SDavid E. O'Brien struct srch *sp, *sp2;
73723338178SMark Peek
738c80476e4SDavid E. O'Brien for (sp = srchn, sp2 = srchn + nsrchn; sp < sp2; sp++)
739c80476e4SDavid E. O'Brien if (sp->s_value == n)
740c80476e4SDavid E. O'Brien return (sp->s_name);
741c80476e4SDavid E. O'Brien return ("");
742c80476e4SDavid E. O'Brien }
743c80476e4SDavid E. O'Brien
744c80476e4SDavid E. O'Brien
745c80476e4SDavid E. O'Brien static int Stype;
74645e5710bSMark Peek static Char *Sgoal;
747c80476e4SDavid E. O'Brien
748c80476e4SDavid E. O'Brien static void
search(int type,int level,Char * goal)749c80476e4SDavid E. O'Brien search(int type, int level, Char *goal)
75045e5710bSMark Peek {
751c80476e4SDavid E. O'Brien struct Strbuf word = Strbuf_INIT;
75245e5710bSMark Peek Char *cp;
75323338178SMark Peek struct whyle *wp;
754b2d5d167SMark Peek int wlevel = 0;
755b2d5d167SMark Peek struct wordent *histent = NULL, *ohistent = NULL;
756c80476e4SDavid E. O'Brien
75745e5710bSMark Peek Stype = type;
758c80476e4SDavid E. O'Brien Sgoal = goal;
759c80476e4SDavid E. O'Brien if (type == TC_GOTO) {
760c80476e4SDavid E. O'Brien struct Ain a;
7613b6eaa7bSAndrey A. Chernov a.type = TCSH_F_SEEK;
762c80476e4SDavid E. O'Brien a.f_seek = 0;
763c80476e4SDavid E. O'Brien a.a_seek = 0;
764c80476e4SDavid E. O'Brien bseek(&a);
76545e5710bSMark Peek }
766c80476e4SDavid E. O'Brien cleanup_push(&word, Strbuf_cleanup);
7673b6eaa7bSAndrey A. Chernov do {
768c80476e4SDavid E. O'Brien
769c80476e4SDavid E. O'Brien if (intty) {
77045e5710bSMark Peek histent = xmalloc(sizeof(*histent));
77145e5710bSMark Peek ohistent = xmalloc(sizeof(*histent));
77245e5710bSMark Peek ohistent->word = STRNULL;
773c80476e4SDavid E. O'Brien ohistent->next = histent;
774c80476e4SDavid E. O'Brien histent->prev = ohistent;
775c80476e4SDavid E. O'Brien }
77645e5710bSMark Peek
777c80476e4SDavid E. O'Brien if (intty && fseekp == feobp && aret == TCSH_F_SEEK)
778c80476e4SDavid E. O'Brien printprompt(1, isrchx(type == TC_BREAK ? zlast : type));
779c80476e4SDavid E. O'Brien /* xprintf("? "), flush(); */
78045e5710bSMark Peek (void) getword(&word);
781c80476e4SDavid E. O'Brien Strbuf_terminate(&word);
782c80476e4SDavid E. O'Brien
78345e5710bSMark Peek if (intty && Strlen(word.s) > 0) {
784c80476e4SDavid E. O'Brien histent->word = Strsave(word.s);
785c80476e4SDavid E. O'Brien histent->next = xmalloc(sizeof(*histent));
786c80476e4SDavid E. O'Brien histent->next->prev = histent;
787c80476e4SDavid E. O'Brien histent = histent->next;
788c80476e4SDavid E. O'Brien }
789c80476e4SDavid E. O'Brien
790c80476e4SDavid E. O'Brien switch (srchx(word.s)) {
791c80476e4SDavid E. O'Brien
792c80476e4SDavid E. O'Brien case TC_ELSE:
793c80476e4SDavid E. O'Brien if (level == 0 && type == TC_IF)
794b2d5d167SMark Peek goto end;
795c80476e4SDavid E. O'Brien break;
796c80476e4SDavid E. O'Brien
797c80476e4SDavid E. O'Brien case TC_IF:
798c80476e4SDavid E. O'Brien while (getword(&word)) {
799c80476e4SDavid E. O'Brien if (intty) {
800b2d5d167SMark Peek histent->word = Strsave(word.s);
801b2d5d167SMark Peek histent->next = xmalloc(sizeof(*histent));
802b2d5d167SMark Peek histent->next->prev = histent;
803b2d5d167SMark Peek histent = histent->next;
804b2d5d167SMark Peek }
805b2d5d167SMark Peek continue;
806b2d5d167SMark Peek }
807b2d5d167SMark Peek
808b2d5d167SMark Peek if ((type == TC_IF || type == TC_ELSE) &&
809c80476e4SDavid E. O'Brien eq(word.s, STRthen))
810c80476e4SDavid E. O'Brien level++;
811b2d5d167SMark Peek break;
812c80476e4SDavid E. O'Brien
813c80476e4SDavid E. O'Brien case TC_ENDIF:
814c80476e4SDavid E. O'Brien if (type == TC_IF || type == TC_ELSE)
815c80476e4SDavid E. O'Brien level--;
816c80476e4SDavid E. O'Brien break;
817c80476e4SDavid E. O'Brien
818c80476e4SDavid E. O'Brien case TC_FOREACH:
819c80476e4SDavid E. O'Brien case TC_WHILE:
820c80476e4SDavid E. O'Brien wlevel++;
821c80476e4SDavid E. O'Brien if (type == TC_BREAK)
822c80476e4SDavid E. O'Brien level++;
823c80476e4SDavid E. O'Brien break;
824c80476e4SDavid E. O'Brien
82545e5710bSMark Peek case TC_END:
826c80476e4SDavid E. O'Brien if (type == TC_BRKSW) {
827c80476e4SDavid E. O'Brien if (wlevel == 0) {
828c80476e4SDavid E. O'Brien wp = whyles;
829c80476e4SDavid E. O'Brien if (wp) {
830c80476e4SDavid E. O'Brien whyles = wp->w_next;
831c80476e4SDavid E. O'Brien wpfree(wp);
83245e5710bSMark Peek }
833c80476e4SDavid E. O'Brien }
83445e5710bSMark Peek }
83545e5710bSMark Peek if (type == TC_BREAK)
83645e5710bSMark Peek level--;
837c80476e4SDavid E. O'Brien wlevel--;
838c80476e4SDavid E. O'Brien break;
839c80476e4SDavid E. O'Brien
840c80476e4SDavid E. O'Brien case TC_SWITCH:
841c80476e4SDavid E. O'Brien if (type == TC_SWITCH || type == TC_BRKSW)
842c80476e4SDavid E. O'Brien level++;
84345e5710bSMark Peek break;
84445e5710bSMark Peek
84545e5710bSMark Peek case TC_ENDSW:
84645e5710bSMark Peek if (type == TC_SWITCH || type == TC_BRKSW)
84745e5710bSMark Peek level--;
848c80476e4SDavid E. O'Brien break;
849c80476e4SDavid E. O'Brien
85045e5710bSMark Peek case TC_LABEL:
851c80476e4SDavid E. O'Brien if (type == TC_GOTO && getword(&word) && eq(word.s, goal))
852c80476e4SDavid E. O'Brien level = -1;
853c80476e4SDavid E. O'Brien break;
854c80476e4SDavid E. O'Brien
855c80476e4SDavid E. O'Brien default:
856c80476e4SDavid E. O'Brien if (type != TC_GOTO && (type != TC_SWITCH || level != 0))
857c80476e4SDavid E. O'Brien break;
858c80476e4SDavid E. O'Brien if (word.len == 0 || word.s[word.len - 1] != ':')
859c80476e4SDavid E. O'Brien break;
86045e5710bSMark Peek word.s[--word.len] = 0;
86145e5710bSMark Peek if ((type == TC_GOTO && eq(word.s, goal)) ||
862c80476e4SDavid E. O'Brien (type == TC_SWITCH && eq(word.s, STRdefault)))
863c80476e4SDavid E. O'Brien level = -1;
864c80476e4SDavid E. O'Brien break;
86545e5710bSMark Peek
866c80476e4SDavid E. O'Brien case TC_CASE:
867c80476e4SDavid E. O'Brien if (type != TC_SWITCH || level != 0)
86823338178SMark Peek break;
869c80476e4SDavid E. O'Brien (void) getword(&word);
87045e5710bSMark Peek if (word.len != 0 && word.s[word.len - 1] == ':')
87145e5710bSMark Peek word.s[--word.len] = 0;
872c80476e4SDavid E. O'Brien cp = strip(Dfix1(word.s));
873c80476e4SDavid E. O'Brien cleanup_push(cp, xfree);
874c80476e4SDavid E. O'Brien if (Gmatch(goal, cp))
875c80476e4SDavid E. O'Brien level = -1;
876c80476e4SDavid E. O'Brien cleanup_until(cp);
877c80476e4SDavid E. O'Brien break;
878c80476e4SDavid E. O'Brien
879c80476e4SDavid E. O'Brien case TC_DEFAULT:
88023338178SMark Peek if (type == TC_SWITCH && level == 0)
88123338178SMark Peek level = -1;
882c80476e4SDavid E. O'Brien break;
883c80476e4SDavid E. O'Brien }
884c80476e4SDavid E. O'Brien if (intty) {
885c80476e4SDavid E. O'Brien ohistent->prev = histgetword(histent);
886c80476e4SDavid E. O'Brien ohistent->prev->next = ohistent;
887c80476e4SDavid E. O'Brien savehist(ohistent, 0);
888c80476e4SDavid E. O'Brien freelex(ohistent);
889c80476e4SDavid E. O'Brien xfree(ohistent);
890c80476e4SDavid E. O'Brien } else
891c80476e4SDavid E. O'Brien (void) getword(NULL);
892c80476e4SDavid E. O'Brien } while (level >= 0);
893c80476e4SDavid E. O'Brien end:
894c80476e4SDavid E. O'Brien cleanup_until(&word);
895c80476e4SDavid E. O'Brien }
896c80476e4SDavid E. O'Brien
897c80476e4SDavid E. O'Brien static struct wordent *
histgetword(struct wordent * histent)898c80476e4SDavid E. O'Brien histgetword(struct wordent *histent)
899c80476e4SDavid E. O'Brien {
900c80476e4SDavid E. O'Brien int first;
90123338178SMark Peek eChar c, d;
902c80476e4SDavid E. O'Brien int e;
90345e5710bSMark Peek struct Strbuf *tmp;
90445e5710bSMark Peek tmp = xmalloc(sizeof(*tmp));
905c80476e4SDavid E. O'Brien tmp->size = 0;
90645e5710bSMark Peek tmp->s = NULL;
90745e5710bSMark Peek c = readc(1);
908c80476e4SDavid E. O'Brien d = 0;
909c80476e4SDavid E. O'Brien e = 0;
910c80476e4SDavid E. O'Brien for (;;) {
911c80476e4SDavid E. O'Brien tmp->len = 0;
912c80476e4SDavid E. O'Brien Strbuf_terminate (tmp);
913c80476e4SDavid E. O'Brien while (c == ' ' || c == '\t')
914c80476e4SDavid E. O'Brien c = readc(1);
91545e5710bSMark Peek if (c == '#')
916c80476e4SDavid E. O'Brien do
91745e5710bSMark Peek c = readc(1);
91845e5710bSMark Peek while (c != CHAR_ERR && c != '\n');
91945e5710bSMark Peek if (c == CHAR_ERR)
92045e5710bSMark Peek goto past;
921c80476e4SDavid E. O'Brien if (c == '\n')
922c80476e4SDavid E. O'Brien goto nl;
923c80476e4SDavid E. O'Brien unreadc(c);
924c80476e4SDavid E. O'Brien first = 1;
925c80476e4SDavid E. O'Brien do {
926c80476e4SDavid E. O'Brien e = (c == '\\');
927c80476e4SDavid E. O'Brien c = readc(1);
928c80476e4SDavid E. O'Brien if (c == '\\' && !e) {
929c80476e4SDavid E. O'Brien if ((c = readc(1)) == '\n') {
930c80476e4SDavid E. O'Brien e = 1;
931c80476e4SDavid E. O'Brien c = ' ';
932c80476e4SDavid E. O'Brien } else {
933c80476e4SDavid E. O'Brien unreadc(c);
934c80476e4SDavid E. O'Brien c = '\\';
935c80476e4SDavid E. O'Brien }
936c80476e4SDavid E. O'Brien }
937c80476e4SDavid E. O'Brien if ((c == '\'' || c == '"') && !e) {
938c80476e4SDavid E. O'Brien if (d == 0)
939c80476e4SDavid E. O'Brien d = c;
940c80476e4SDavid E. O'Brien else if (d == c)
941c80476e4SDavid E. O'Brien d = 0;
942c80476e4SDavid E. O'Brien }
943c80476e4SDavid E. O'Brien if (c == CHAR_ERR)
944c80476e4SDavid E. O'Brien goto past;
945c80476e4SDavid E. O'Brien
946c80476e4SDavid E. O'Brien Strbuf_append1(tmp, (Char) c);
947c80476e4SDavid E. O'Brien
948c80476e4SDavid E. O'Brien if (!first && !d && c == '(' && !e) {
949c80476e4SDavid E. O'Brien break;
950c80476e4SDavid E. O'Brien }
951c80476e4SDavid E. O'Brien first = 0;
952c80476e4SDavid E. O'Brien } while (d || e || (c != ' ' && c != '\t' && c != '\n'));
953c80476e4SDavid E. O'Brien tmp->len--;
954c80476e4SDavid E. O'Brien if (tmp->len) {
955c80476e4SDavid E. O'Brien Strbuf_terminate(tmp);
956c80476e4SDavid E. O'Brien histent->word = Strsave(tmp->s);
95745e5710bSMark Peek histent->next = xmalloc(sizeof (*histent));
958c80476e4SDavid E. O'Brien histent->next->prev = histent;
9593b6eaa7bSAndrey A. Chernov histent = histent->next;
960c80476e4SDavid E. O'Brien }
961c80476e4SDavid E. O'Brien if (c == '\n') {
962c80476e4SDavid E. O'Brien nl:
963c80476e4SDavid E. O'Brien tmp->len = 0;
964c80476e4SDavid E. O'Brien Strbuf_append1(tmp, (Char) c);
965c80476e4SDavid E. O'Brien Strbuf_terminate(tmp);
966c80476e4SDavid E. O'Brien histent->word = Strsave(tmp->s);
967c80476e4SDavid E. O'Brien return histent;
968c80476e4SDavid E. O'Brien }
969c80476e4SDavid E. O'Brien }
970b2d5d167SMark Peek
97145e5710bSMark Peek past:
972b2d5d167SMark Peek switch (Stype) {
973b2d5d167SMark Peek
974b2d5d167SMark Peek case TC_IF:
97545e5710bSMark Peek stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
97645e5710bSMark Peek break;
977b2d5d167SMark Peek
978b2d5d167SMark Peek case TC_ELSE:
979c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTFOUND, "endif");
98045e5710bSMark Peek break;
981c80476e4SDavid E. O'Brien
982c80476e4SDavid E. O'Brien case TC_BRKSW:
983c80476e4SDavid E. O'Brien case TC_SWITCH:
984c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
985c80476e4SDavid E. O'Brien break;
986c80476e4SDavid E. O'Brien
987c80476e4SDavid E. O'Brien case TC_BREAK:
988c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTFOUND, "end");
98945e5710bSMark Peek break;
990c80476e4SDavid E. O'Brien
991c80476e4SDavid E. O'Brien case TC_GOTO:
992c80476e4SDavid E. O'Brien setname(short2str(Sgoal));
993c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTFOUND, "label");
994c80476e4SDavid E. O'Brien break;
995c80476e4SDavid E. O'Brien
996c80476e4SDavid E. O'Brien default:
997c80476e4SDavid E. O'Brien break;
998c80476e4SDavid E. O'Brien }
999c80476e4SDavid E. O'Brien /* NOTREACHED */
100023338178SMark Peek return NULL;
1001c80476e4SDavid E. O'Brien }
1002c80476e4SDavid E. O'Brien
1003c80476e4SDavid E. O'Brien static int
getword(struct Strbuf * wp)1004c80476e4SDavid E. O'Brien getword(struct Strbuf *wp)
1005c80476e4SDavid E. O'Brien {
1006c80476e4SDavid E. O'Brien int found = 0, first;
1007c80476e4SDavid E. O'Brien eChar c, d;
1008c80476e4SDavid E. O'Brien
1009c80476e4SDavid E. O'Brien if (wp)
1010c80476e4SDavid E. O'Brien wp->len = 0;
1011c80476e4SDavid E. O'Brien c = readc(1);
1012c80476e4SDavid E. O'Brien d = 0;
1013c80476e4SDavid E. O'Brien do {
10143b6eaa7bSAndrey A. Chernov while (c == ' ' || c == '\t')
1015c80476e4SDavid E. O'Brien c = readc(1);
10163b6eaa7bSAndrey A. Chernov if (c == '#')
1017c80476e4SDavid E. O'Brien do
1018c80476e4SDavid E. O'Brien c = readc(1);
1019c80476e4SDavid E. O'Brien while (c != CHAR_ERR && c != '\n');
1020c80476e4SDavid E. O'Brien if (c == CHAR_ERR)
1021c80476e4SDavid E. O'Brien goto past;
1022c80476e4SDavid E. O'Brien if (c == '\n') {
1023c80476e4SDavid E. O'Brien if (wp)
1024c80476e4SDavid E. O'Brien break;
1025c80476e4SDavid E. O'Brien return (0);
1026c80476e4SDavid E. O'Brien }
1027c80476e4SDavid E. O'Brien unreadc(c);
1028b2d5d167SMark Peek found = 1;
1029c80476e4SDavid E. O'Brien first = 1;
1030c80476e4SDavid E. O'Brien do {
1031c80476e4SDavid E. O'Brien c = readc(1);
1032c80476e4SDavid E. O'Brien if (c == '\\' && (c = readc(1)) == '\n')
1033c80476e4SDavid E. O'Brien c = ' ';
103445e5710bSMark Peek if (c == '\'' || c == '"') {
1035c80476e4SDavid E. O'Brien if (d == 0)
1036c80476e4SDavid E. O'Brien d = c;
1037c80476e4SDavid E. O'Brien else if (d == c)
1038c80476e4SDavid E. O'Brien d = 0;
1039c80476e4SDavid E. O'Brien }
1040c80476e4SDavid E. O'Brien if (c == CHAR_ERR)
1041c80476e4SDavid E. O'Brien goto past;
104245e5710bSMark Peek if (wp)
1043c80476e4SDavid E. O'Brien Strbuf_append1(wp, (Char) c);
1044c80476e4SDavid E. O'Brien if (!d && c == ')') {
1045c80476e4SDavid E. O'Brien if (!first && wp) {
1046c80476e4SDavid E. O'Brien goto past_word_end;
1047c80476e4SDavid E. O'Brien } else {
1048c80476e4SDavid E. O'Brien if (wp) {
1049c80476e4SDavid E. O'Brien wp->len = 1;
105045e5710bSMark Peek Strbuf_terminate(wp);
1051c80476e4SDavid E. O'Brien }
105245e5710bSMark Peek return found;
1053c80476e4SDavid E. O'Brien }
1054c80476e4SDavid E. O'Brien }
1055c80476e4SDavid E. O'Brien if (!first && !d && c == '(') {
1056c80476e4SDavid E. O'Brien if (wp)
1057c80476e4SDavid E. O'Brien goto past_word_end;
1058c80476e4SDavid E. O'Brien else
1059c80476e4SDavid E. O'Brien break;
1060c80476e4SDavid E. O'Brien }
1061c80476e4SDavid E. O'Brien first = 0;
1062c80476e4SDavid E. O'Brien } while ((d || (c != ' ' && c != '\t')) && c != '\n');
1063c80476e4SDavid E. O'Brien } while (wp == 0);
1064c80476e4SDavid E. O'Brien
1065c80476e4SDavid E. O'Brien past_word_end:
1066c80476e4SDavid E. O'Brien unreadc(c);
1067c80476e4SDavid E. O'Brien if (found) {
1068c80476e4SDavid E. O'Brien wp->len--;
1069c80476e4SDavid E. O'Brien Strbuf_terminate(wp);
1070c80476e4SDavid E. O'Brien }
10716767bd61SMark Peek
107245e5710bSMark Peek return (found);
107345e5710bSMark Peek
107445e5710bSMark Peek past:
107545e5710bSMark Peek switch (Stype) {
107645e5710bSMark Peek
107745e5710bSMark Peek case TC_IF:
107845e5710bSMark Peek stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
1079c80476e4SDavid E. O'Brien break;
108045e5710bSMark Peek
108145e5710bSMark Peek case TC_ELSE:
108245e5710bSMark Peek stderror(ERR_NAME | ERR_NOTFOUND, "endif");
1083c80476e4SDavid E. O'Brien break;
1084c80476e4SDavid E. O'Brien
1085c80476e4SDavid E. O'Brien case TC_BRKSW:
1086c80476e4SDavid E. O'Brien case TC_SWITCH:
1087c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
108823338178SMark Peek break;
1089c80476e4SDavid E. O'Brien
109045e5710bSMark Peek case TC_BREAK:
109145e5710bSMark Peek stderror(ERR_NAME | ERR_NOTFOUND, "end");
109245e5710bSMark Peek break;
109345e5710bSMark Peek
109445e5710bSMark Peek case TC_GOTO:
109545e5710bSMark Peek setname(short2str(Sgoal));
1096c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_NOTFOUND, "label");
1097c80476e4SDavid E. O'Brien break;
1098c80476e4SDavid E. O'Brien
1099c80476e4SDavid E. O'Brien default:
1100c80476e4SDavid E. O'Brien break;
1101c80476e4SDavid E. O'Brien }
1102c80476e4SDavid E. O'Brien /* NOTREACHED */
1103c80476e4SDavid E. O'Brien return (0);
1104c80476e4SDavid E. O'Brien }
1105c80476e4SDavid E. O'Brien
1106c80476e4SDavid E. O'Brien static void
toend(void)1107c80476e4SDavid E. O'Brien toend(void)
1108c80476e4SDavid E. O'Brien {
1109c80476e4SDavid E. O'Brien if (whyles->w_end.type == TCSH_F_SEEK && whyles->w_end.f_seek == 0) {
1110c80476e4SDavid E. O'Brien search(TC_BREAK, 0, NULL);
1111c80476e4SDavid E. O'Brien btell(&whyles->w_end);
111245e5710bSMark Peek whyles->w_end.f_seek--;
1113c80476e4SDavid E. O'Brien }
1114c80476e4SDavid E. O'Brien else {
1115c80476e4SDavid E. O'Brien bseek(&whyles->w_end);
1116c80476e4SDavid E. O'Brien }
1117c80476e4SDavid E. O'Brien wfree();
1118c80476e4SDavid E. O'Brien }
1119c80476e4SDavid E. O'Brien
1120c80476e4SDavid E. O'Brien static void
wpfree(struct whyle * wp)1121c80476e4SDavid E. O'Brien wpfree(struct whyle *wp)
1122c80476e4SDavid E. O'Brien {
1123c80476e4SDavid E. O'Brien if (wp->w_fe0)
1124c80476e4SDavid E. O'Brien blkfree(wp->w_fe0);
1125c80476e4SDavid E. O'Brien xfree(wp->w_fename);
1126c80476e4SDavid E. O'Brien xfree(wp);
1127c80476e4SDavid E. O'Brien }
1128c80476e4SDavid E. O'Brien
1129c80476e4SDavid E. O'Brien void
wfree(void)1130c80476e4SDavid E. O'Brien wfree(void)
1131c80476e4SDavid E. O'Brien {
1132c80476e4SDavid E. O'Brien struct Ain o;
1133c80476e4SDavid E. O'Brien struct whyle *nwp;
1134c80476e4SDavid E. O'Brien #ifdef lint
1135c80476e4SDavid E. O'Brien nwp = NULL; /* sun lint is dumb! */
1136c80476e4SDavid E. O'Brien #endif
1137c80476e4SDavid E. O'Brien
1138c80476e4SDavid E. O'Brien #ifdef FDEBUG
1139c80476e4SDavid E. O'Brien static const char foo[] = "IAFE";
1140c80476e4SDavid E. O'Brien #endif /* FDEBUG */
1141c80476e4SDavid E. O'Brien
1142c80476e4SDavid E. O'Brien btell(&o);
1143c80476e4SDavid E. O'Brien
1144c80476e4SDavid E. O'Brien #ifdef FDEBUG
1145c80476e4SDavid E. O'Brien xprintf("o->type %c o->a_seek %d o->f_seek %d\n",
1146c80476e4SDavid E. O'Brien foo[o.type + 1], o.a_seek, o.f_seek);
1147c80476e4SDavid E. O'Brien #endif /* FDEBUG */
1148c80476e4SDavid E. O'Brien
1149c80476e4SDavid E. O'Brien for (; whyles; whyles = nwp) {
1150c80476e4SDavid E. O'Brien struct whyle *wp = whyles;
115123338178SMark Peek nwp = wp->w_next;
1152c80476e4SDavid E. O'Brien
1153c80476e4SDavid E. O'Brien #ifdef FDEBUG
1154c80476e4SDavid E. O'Brien xprintf("start->type %c start->a_seek %d start->f_seek %d\n",
1155c80476e4SDavid E. O'Brien foo[wp->w_start.type+1],
1156c80476e4SDavid E. O'Brien wp->w_start.a_seek, wp->w_start.f_seek);
1157c80476e4SDavid E. O'Brien xprintf("end->type %c end->a_seek %d end->f_seek %d\n",
1158c80476e4SDavid E. O'Brien foo[wp->w_end.type + 1], wp->w_end.a_seek, wp->w_end.f_seek);
1159c80476e4SDavid E. O'Brien #endif /* FDEBUG */
1160c80476e4SDavid E. O'Brien
1161c80476e4SDavid E. O'Brien /*
116245e5710bSMark Peek * XXX: We free loops that have different seek types.
116345e5710bSMark Peek */
1164c80476e4SDavid E. O'Brien if (wp->w_end.type != TCSH_I_SEEK && wp->w_start.type == wp->w_end.type &&
1165c80476e4SDavid E. O'Brien wp->w_start.type == o.type) {
1166c80476e4SDavid E. O'Brien if (wp->w_end.type == TCSH_F_SEEK) {
116723338178SMark Peek if (o.f_seek >= wp->w_start.f_seek &&
116845e5710bSMark Peek (wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
1169c80476e4SDavid E. O'Brien break;
1170c80476e4SDavid E. O'Brien }
1171b2d5d167SMark Peek else {
1172b2d5d167SMark Peek if (o.a_seek >= wp->w_start.a_seek &&
1173c80476e4SDavid E. O'Brien (wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
117423338178SMark Peek break;
1175c80476e4SDavid E. O'Brien }
1176c80476e4SDavid E. O'Brien }
1177c80476e4SDavid E. O'Brien
1178c80476e4SDavid E. O'Brien wpfree(wp);
1179c80476e4SDavid E. O'Brien }
1180c80476e4SDavid E. O'Brien }
1181c80476e4SDavid E. O'Brien
118245e5710bSMark Peek /*ARGSUSED*/
118345e5710bSMark Peek void
doecho(Char ** v,struct command * c)118445e5710bSMark Peek doecho(Char **v, struct command *c)
118545e5710bSMark Peek {
118645e5710bSMark Peek USE(c);
118745e5710bSMark Peek xecho(' ', v);
118845e5710bSMark Peek }
1189c80476e4SDavid E. O'Brien
1190c80476e4SDavid E. O'Brien /*ARGSUSED*/
119145e5710bSMark Peek void
doglob(Char ** v,struct command * c)1192c80476e4SDavid E. O'Brien doglob(Char **v, struct command *c)
1193c80476e4SDavid E. O'Brien {
1194c80476e4SDavid E. O'Brien USE(c);
1195c80476e4SDavid E. O'Brien xecho(0, v);
1196c80476e4SDavid E. O'Brien flush();
1197c80476e4SDavid E. O'Brien }
119823338178SMark Peek
1199c80476e4SDavid E. O'Brien static void
xecho(int sep,Char ** v)1200c80476e4SDavid E. O'Brien xecho(int sep, Char **v)
120145e5710bSMark Peek {
120245e5710bSMark Peek Char *cp, **globbed = NULL;
120345e5710bSMark Peek int nonl = 0;
120445e5710bSMark Peek int echo_style = ECHO_STYLE;
120545e5710bSMark Peek struct varent *vp;
120645e5710bSMark Peek
120745e5710bSMark Peek if ((vp = adrof(STRecho_style)) != NULL && vp->vec != NULL &&
120845e5710bSMark Peek vp->vec[0] != NULL) {
1209c80476e4SDavid E. O'Brien if (Strcmp(vp->vec[0], STRbsd) == 0)
121045e5710bSMark Peek echo_style = BSD_ECHO;
121145e5710bSMark Peek else if (Strcmp(vp->vec[0], STRsysv) == 0)
1212c80476e4SDavid E. O'Brien echo_style = SYSV_ECHO;
1213c80476e4SDavid E. O'Brien else if (Strcmp(vp->vec[0], STRboth) == 0)
121445e5710bSMark Peek echo_style = BOTH_ECHO;
121545e5710bSMark Peek else if (Strcmp(vp->vec[0], STRnone) == 0)
121645e5710bSMark Peek echo_style = NONE_ECHO;
1217c80476e4SDavid E. O'Brien }
121845e5710bSMark Peek
1219c80476e4SDavid E. O'Brien v++;
122045e5710bSMark Peek if (*v == 0)
1221c80476e4SDavid E. O'Brien goto done;
1222c80476e4SDavid E. O'Brien if (setintr) {
122345e5710bSMark Peek int old_pintr_disabled;
1224c80476e4SDavid E. O'Brien pintr_push_enable(&old_pintr_disabled);
1225c80476e4SDavid E. O'Brien v = glob_all_or_error(v);
1226c80476e4SDavid E. O'Brien cleanup_until(&old_pintr_disabled);
1227c80476e4SDavid E. O'Brien } else {
1228c80476e4SDavid E. O'Brien v = glob_all_or_error(v);
1229c80476e4SDavid E. O'Brien }
1230c80476e4SDavid E. O'Brien globbed = v;
123145e5710bSMark Peek if (globbed != NULL)
1232c80476e4SDavid E. O'Brien cleanup_push(globbed, blk_cleanup);
1233c80476e4SDavid E. O'Brien
1234c80476e4SDavid E. O'Brien if ((echo_style & BSD_ECHO) != 0 && sep == ' ' && *v && eq(*v, STRmn))
1235c80476e4SDavid E. O'Brien nonl++, v++;
1236c80476e4SDavid E. O'Brien
1237c80476e4SDavid E. O'Brien while ((cp = *v++) != 0) {
1238c80476e4SDavid E. O'Brien Char c;
1239c80476e4SDavid E. O'Brien
1240c80476e4SDavid E. O'Brien if (setintr) {
1241c80476e4SDavid E. O'Brien int old_pintr_disabled;
1242c80476e4SDavid E. O'Brien
124329301572SMark Peek pintr_push_enable(&old_pintr_disabled);
124429301572SMark Peek cleanup_until(&old_pintr_disabled);
1245b2d5d167SMark Peek }
1246b2d5d167SMark Peek while ((c = *cp++) != 0) {
124729301572SMark Peek if ((echo_style & SYSV_ECHO) != 0 && c == '\\') {
1248b2d5d167SMark Peek switch (c = *cp++) {
1249c80476e4SDavid E. O'Brien case 'a':
1250c80476e4SDavid E. O'Brien c = '\a';
1251c80476e4SDavid E. O'Brien break;
125245e5710bSMark Peek case 'b':
125345e5710bSMark Peek c = '\b';
125445e5710bSMark Peek break;
1255c80476e4SDavid E. O'Brien case 'c':
1256c80476e4SDavid E. O'Brien nonl = 1;
1257c80476e4SDavid E. O'Brien goto done;
125845e5710bSMark Peek case 'e':
1259c80476e4SDavid E. O'Brien #if 0 /* Windows does not understand \e */
1260c80476e4SDavid E. O'Brien c = '\e';
1261c80476e4SDavid E. O'Brien #else
1262c80476e4SDavid E. O'Brien c = CTL_ESC('\033');
1263c80476e4SDavid E. O'Brien #endif
1264c80476e4SDavid E. O'Brien break;
126545e5710bSMark Peek case 'f':
1266c80476e4SDavid E. O'Brien c = '\f';
1267c80476e4SDavid E. O'Brien break;
1268c80476e4SDavid E. O'Brien case 'n':
1269c80476e4SDavid E. O'Brien c = '\n';
1270c80476e4SDavid E. O'Brien break;
1271c80476e4SDavid E. O'Brien case 'r':
1272c80476e4SDavid E. O'Brien c = '\r';
1273c80476e4SDavid E. O'Brien break;
1274c80476e4SDavid E. O'Brien case 't':
1275c80476e4SDavid E. O'Brien c = '\t';
1276c80476e4SDavid E. O'Brien break;
1277c80476e4SDavid E. O'Brien case 'v':
1278c80476e4SDavid E. O'Brien c = '\v';
1279c80476e4SDavid E. O'Brien break;
1280c80476e4SDavid E. O'Brien case '\\':
1281c80476e4SDavid E. O'Brien c = '\\';
1282c80476e4SDavid E. O'Brien break;
1283c80476e4SDavid E. O'Brien case '0':
1284c80476e4SDavid E. O'Brien c = 0;
1285c80476e4SDavid E. O'Brien if (*cp >= '0' && *cp < '8')
1286c80476e4SDavid E. O'Brien c = c * 8 + *cp++ - '0';
1287c80476e4SDavid E. O'Brien if (*cp >= '0' && *cp < '8')
1288c80476e4SDavid E. O'Brien c = c * 8 + *cp++ - '0';
128923338178SMark Peek if (*cp >= '0' && *cp < '8')
129023338178SMark Peek c = c * 8 + *cp++ - '0';
129123338178SMark Peek break;
1292c80476e4SDavid E. O'Brien case '\0':
1293c80476e4SDavid E. O'Brien c = '\\';
1294c80476e4SDavid E. O'Brien cp--;
1295c80476e4SDavid E. O'Brien break;
129623338178SMark Peek default:
1297c80476e4SDavid E. O'Brien xputchar('\\' | QUOTE);
1298c80476e4SDavid E. O'Brien break;
1299c80476e4SDavid E. O'Brien }
1300c80476e4SDavid E. O'Brien }
1301c80476e4SDavid E. O'Brien xputwchar(c | QUOTE);
1302c80476e4SDavid E. O'Brien
1303c80476e4SDavid E. O'Brien }
1304c80476e4SDavid E. O'Brien if (*v)
1305c80476e4SDavid E. O'Brien xputchar(sep | QUOTE);
130645e5710bSMark Peek }
1307c80476e4SDavid E. O'Brien done:
130823338178SMark Peek if (sep && nonl == 0)
1309c80476e4SDavid E. O'Brien xputchar('\n');
1310c80476e4SDavid E. O'Brien else
1311c80476e4SDavid E. O'Brien flush();
1312c80476e4SDavid E. O'Brien if (globbed != NULL)
1313c80476e4SDavid E. O'Brien cleanup_until(globbed);
1314c80476e4SDavid E. O'Brien }
1315c80476e4SDavid E. O'Brien
131645e5710bSMark Peek /* check whether an environment variable should invoke 'set_locale()' */
1317c80476e4SDavid E. O'Brien static int
islocale_var(Char * var)1318c80476e4SDavid E. O'Brien islocale_var(Char *var)
1319c80476e4SDavid E. O'Brien {
132029301572SMark Peek static Char *locale_vars[] = {
132129301572SMark Peek STRLANG, STRLC_ALL, STRLC_CTYPE, STRLC_NUMERIC,
132223338178SMark Peek STRLC_TIME, STRLC_COLLATE, STRLC_MESSAGES, STRLC_MONETARY, 0
132329301572SMark Peek };
132429301572SMark Peek Char **v;
132529301572SMark Peek
132629301572SMark Peek for (v = locale_vars; *v; ++v)
1327c80476e4SDavid E. O'Brien if (eq(var, *v))
1328c80476e4SDavid E. O'Brien return 1;
1329c80476e4SDavid E. O'Brien return 0;
1330c80476e4SDavid E. O'Brien }
1331c80476e4SDavid E. O'Brien
133245e5710bSMark Peek static void
xlate_cr_cleanup(void * dummy)1333c80476e4SDavid E. O'Brien xlate_cr_cleanup(void *dummy)
1334c80476e4SDavid E. O'Brien {
13353b6eaa7bSAndrey A. Chernov USE(dummy);
1336c80476e4SDavid E. O'Brien xlate_cr = 0;
1337c80476e4SDavid E. O'Brien }
133845e5710bSMark Peek
1339c80476e4SDavid E. O'Brien /*ARGSUSED*/
1340c80476e4SDavid E. O'Brien void
doprintenv(Char ** v,struct command * c)13413b6eaa7bSAndrey A. Chernov doprintenv(Char **v, struct command *c)
1342c80476e4SDavid E. O'Brien {
1343c80476e4SDavid E. O'Brien Char *e;
134445e5710bSMark Peek
134545e5710bSMark Peek USE(c);
134645e5710bSMark Peek v++;
134745e5710bSMark Peek if (*v == 0) {
1348c80476e4SDavid E. O'Brien Char **ep;
1349c80476e4SDavid E. O'Brien
1350c80476e4SDavid E. O'Brien xlate_cr = 1;
1351c80476e4SDavid E. O'Brien cleanup_push(&xlate_cr, xlate_cr_cleanup);
135245e5710bSMark Peek for (ep = STR_environ; *ep; ep++) {
1353c80476e4SDavid E. O'Brien if (setintr) {
1354c80476e4SDavid E. O'Brien int old_pintr_disabled;
1355c80476e4SDavid E. O'Brien
1356c80476e4SDavid E. O'Brien pintr_push_enable(&old_pintr_disabled);
1357c80476e4SDavid E. O'Brien cleanup_until(&old_pintr_disabled);
1358c80476e4SDavid E. O'Brien }
1359c80476e4SDavid E. O'Brien xprintf("%S\n", *ep);
136045e5710bSMark Peek }
1361c80476e4SDavid E. O'Brien cleanup_until(&xlate_cr);
1362c80476e4SDavid E. O'Brien }
1363c80476e4SDavid E. O'Brien else if ((e = tgetenv(*v)) != NULL) {
136445e5710bSMark Peek int old_output_raw;
136545e5710bSMark Peek
136645e5710bSMark Peek old_output_raw = output_raw;
136745e5710bSMark Peek output_raw = 1;
136845e5710bSMark Peek cleanup_push(&old_output_raw, output_raw_restore);
136945e5710bSMark Peek xprintf("%S\n", e);
137045e5710bSMark Peek cleanup_until(&old_output_raw);
1371c80476e4SDavid E. O'Brien }
1372c80476e4SDavid E. O'Brien else
1373c80476e4SDavid E. O'Brien setcopy(STRstatus, STR1, VAR_READWRITE);
1374c80476e4SDavid E. O'Brien }
1375c80476e4SDavid E. O'Brien
1376c80476e4SDavid E. O'Brien /* from "Karl Berry." <karl%mote.umb.edu@relay.cs.net> -- for NeXT things
1377c80476e4SDavid E. O'Brien (and anything else with a modern compiler) */
137845e5710bSMark Peek
137945e5710bSMark Peek /*ARGSUSED*/
138045e5710bSMark Peek void
dosetenv(Char ** v,struct command * c)1381c80476e4SDavid E. O'Brien dosetenv(Char **v, struct command *c)
1382c80476e4SDavid E. O'Brien {
1383c80476e4SDavid E. O'Brien Char *vp, *lp;
1384c80476e4SDavid E. O'Brien
138545e5710bSMark Peek USE(c);
138645e5710bSMark Peek if (*++v == 0) {
138745e5710bSMark Peek doprintenv(--v, 0);
1388c80476e4SDavid E. O'Brien return;
1389c80476e4SDavid E. O'Brien }
1390c80476e4SDavid E. O'Brien
1391c80476e4SDavid E. O'Brien vp = *v++;
139245e5710bSMark Peek lp = vp;
139345e5710bSMark Peek
139445e5710bSMark Peek if (!letter(*lp))
1395c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_VARBEGIN);
1396c80476e4SDavid E. O'Brien do {
1397c80476e4SDavid E. O'Brien lp++;
1398c80476e4SDavid E. O'Brien } while (alnum(*lp) || *lp == '.');
1399c80476e4SDavid E. O'Brien if (*lp != '\0')
1400c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_VARALNUM);
140145e5710bSMark Peek
1402c80476e4SDavid E. O'Brien if ((lp = *v++) == 0)
1403c80476e4SDavid E. O'Brien lp = STRNULL;
1404c80476e4SDavid E. O'Brien
1405c80476e4SDavid E. O'Brien lp = globone(lp, G_APPEND);
1406c80476e4SDavid E. O'Brien cleanup_push(lp, xfree);
1407c80476e4SDavid E. O'Brien tsetenv(vp, lp);
1408c80476e4SDavid E. O'Brien if (eq(vp, STRKPATH)) {
1409c80476e4SDavid E. O'Brien importpath(lp);
1410c80476e4SDavid E. O'Brien dohash(NULL, NULL);
1411c80476e4SDavid E. O'Brien cleanup_until(lp);
141245e5710bSMark Peek return;
1413c80476e4SDavid E. O'Brien }
1414c80476e4SDavid E. O'Brien
1415c80476e4SDavid E. O'Brien #ifdef apollo
1416c80476e4SDavid E. O'Brien if (eq(vp, STRSYSTYPE)) {
1417c80476e4SDavid E. O'Brien dohash(NULL, NULL);
1418c80476e4SDavid E. O'Brien cleanup_until(lp);
1419c80476e4SDavid E. O'Brien return;
1420c80476e4SDavid E. O'Brien }
1421c80476e4SDavid E. O'Brien #endif /* apollo */
1422c80476e4SDavid E. O'Brien
1423c80476e4SDavid E. O'Brien /* dspkanji/dspmbyte autosetting */
142445e5710bSMark Peek /* PATCH IDEA FROM Issei.Suzuki VERY THANKS */
1425c80476e4SDavid E. O'Brien #if defined(DSPMBYTE)
1426c80476e4SDavid E. O'Brien if (eq(vp, STRLANG) && !adrof(CHECK_MBYTEVAR)) {
1427c80476e4SDavid E. O'Brien autoset_dspmbyte(lp);
1428c80476e4SDavid E. O'Brien }
142945e5710bSMark Peek #endif
1430c80476e4SDavid E. O'Brien
1431c80476e4SDavid E. O'Brien if (islocale_var(vp)) {
1432c80476e4SDavid E. O'Brien #ifdef NLS
1433c80476e4SDavid E. O'Brien int k;
143445e5710bSMark Peek
1435c80476e4SDavid E. O'Brien # ifdef SETLOCALEBUG
143645e5710bSMark Peek dont_free = 1;
1437c80476e4SDavid E. O'Brien # endif /* SETLOCALEBUG */
1438c80476e4SDavid E. O'Brien (void) setlocale(LC_ALL, "");
1439c80476e4SDavid E. O'Brien # ifdef LC_COLLATE
1440c80476e4SDavid E. O'Brien (void) setlocale(LC_COLLATE, "");
1441c80476e4SDavid E. O'Brien # endif
1442c80476e4SDavid E. O'Brien # ifdef LC_CTYPE
1443c80476e4SDavid E. O'Brien (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1444c80476e4SDavid E. O'Brien # endif /* LC_CTYPE */
1445c80476e4SDavid E. O'Brien # if defined(AUTOSET_KANJI)
1446c80476e4SDavid E. O'Brien autoset_kanji();
1447c80476e4SDavid E. O'Brien # endif /* AUTOSET_KANJI */
1448c80476e4SDavid E. O'Brien # ifdef NLS_CATALOGS
1449c80476e4SDavid E. O'Brien # ifdef LC_MESSAGES
145045e5710bSMark Peek (void) setlocale(LC_MESSAGES, "");
145145e5710bSMark Peek # endif /* LC_MESSAGES */
1452c80476e4SDavid E. O'Brien nlsclose();
1453c80476e4SDavid E. O'Brien nlsinit();
1454c80476e4SDavid E. O'Brien # endif /* NLS_CATALOGS */
1455c80476e4SDavid E. O'Brien # ifdef SETLOCALEBUG
1456c80476e4SDavid E. O'Brien dont_free = 0;
1457c80476e4SDavid E. O'Brien # endif /* SETLOCALEBUG */
1458c80476e4SDavid E. O'Brien # ifdef STRCOLLBUG
1459c80476e4SDavid E. O'Brien fix_strcoll_bug();
1460c80476e4SDavid E. O'Brien # endif /* STRCOLLBUG */
1461c80476e4SDavid E. O'Brien tw_cmd_free(); /* since the collation sequence has changed */
1462c80476e4SDavid E. O'Brien for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1463c80476e4SDavid E. O'Brien continue;
1464c80476e4SDavid E. O'Brien AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1465c80476e4SDavid E. O'Brien #else /* !NLS */
1466c80476e4SDavid E. O'Brien AsciiOnly = 0;
1467c80476e4SDavid E. O'Brien #endif /* NLS */
1468c80476e4SDavid E. O'Brien NLSMapsAreInited = 0;
1469c80476e4SDavid E. O'Brien ed_Init();
1470c80476e4SDavid E. O'Brien if (MapsAreInited && !NLSMapsAreInited)
1471c80476e4SDavid E. O'Brien ed_InitNLSMaps();
1472c80476e4SDavid E. O'Brien cleanup_until(lp);
1473c80476e4SDavid E. O'Brien return;
1474c80476e4SDavid E. O'Brien }
1475c80476e4SDavid E. O'Brien
1476c80476e4SDavid E. O'Brien #ifdef NLS_CATALOGS
1477c80476e4SDavid E. O'Brien if (eq(vp, STRNLSPATH)) {
1478c80476e4SDavid E. O'Brien nlsclose();
1479c80476e4SDavid E. O'Brien nlsinit();
1480c80476e4SDavid E. O'Brien }
1481c80476e4SDavid E. O'Brien #endif
1482c80476e4SDavid E. O'Brien
1483c80476e4SDavid E. O'Brien if (eq(vp, STRNOREBIND)) {
1484c80476e4SDavid E. O'Brien NoNLSRebind = 1;
1485c80476e4SDavid E. O'Brien MapsAreInited = 0;
1486c80476e4SDavid E. O'Brien NLSMapsAreInited = 0;
1487c80476e4SDavid E. O'Brien ed_InitMaps();
1488c80476e4SDavid E. O'Brien cleanup_until(lp);
1489c80476e4SDavid E. O'Brien return;
1490c80476e4SDavid E. O'Brien }
1491c80476e4SDavid E. O'Brien #ifdef WINNT_NATIVE
149223338178SMark Peek if (eq(vp, STRtcshlang)) {
149323338178SMark Peek nlsinit();
149423338178SMark Peek cleanup_until(lp);
1495c80476e4SDavid E. O'Brien return;
1496c80476e4SDavid E. O'Brien }
1497c80476e4SDavid E. O'Brien #endif /* WINNT_NATIVE */
1498c80476e4SDavid E. O'Brien if (eq(vp, STRKTERM)) {
149923338178SMark Peek char *t;
1500c80476e4SDavid E. O'Brien
1501c80476e4SDavid E. O'Brien setv(STRterm, quote(lp), VAR_READWRITE); /* lp memory used here */
1502c80476e4SDavid E. O'Brien cleanup_ignore(lp);
1503c80476e4SDavid E. O'Brien cleanup_until(lp);
1504c80476e4SDavid E. O'Brien t = short2str(lp);
1505c80476e4SDavid E. O'Brien if (noediting && strcmp(t, "unknown") != 0 && strcmp(t,"dumb") != 0) {
1506c80476e4SDavid E. O'Brien editing = 1;
1507c80476e4SDavid E. O'Brien noediting = 0;
1508c80476e4SDavid E. O'Brien setNS(STRedit);
150945e5710bSMark Peek }
1510c80476e4SDavid E. O'Brien GotTermCaps = 0;
151123338178SMark Peek ed_Init();
1512c80476e4SDavid E. O'Brien return;
1513c80476e4SDavid E. O'Brien }
1514c80476e4SDavid E. O'Brien
1515c80476e4SDavid E. O'Brien if (eq(vp, STRKHOME)) {
1516c80476e4SDavid E. O'Brien Char *canon;
1517c80476e4SDavid E. O'Brien /*
1518c80476e4SDavid E. O'Brien * convert to canonical pathname (possibly resolving symlinks)
1519c80476e4SDavid E. O'Brien */
1520c80476e4SDavid E. O'Brien cleanup_ignore(lp);
1521c80476e4SDavid E. O'Brien canon = dcanon(lp, lp);
15223b6eaa7bSAndrey A. Chernov cleanup_push(canon, xfree);
1523c80476e4SDavid E. O'Brien setv(STRhome, quote(canon), VAR_READWRITE); /* lp memory used here */
1524c80476e4SDavid E. O'Brien cleanup_ignore(canon);
1525c80476e4SDavid E. O'Brien cleanup_until(canon);
1526c80476e4SDavid E. O'Brien
15273b6eaa7bSAndrey A. Chernov /* fix directory stack for new tilde home */
1528c80476e4SDavid E. O'Brien dtilde();
1529c80476e4SDavid E. O'Brien return;
1530c80476e4SDavid E. O'Brien }
1531c80476e4SDavid E. O'Brien
153229301572SMark Peek if (eq(vp, STRKSHLVL)) {
153329301572SMark Peek setv(STRshlvl, quote(lp), VAR_READWRITE); /* lp memory used here */
153423338178SMark Peek cleanup_ignore(lp);
153529301572SMark Peek cleanup_until(lp);
153629301572SMark Peek return;
153729301572SMark Peek }
1538c80476e4SDavid E. O'Brien
1539c80476e4SDavid E. O'Brien if (eq(vp, STRKUSER)) {
1540c80476e4SDavid E. O'Brien setv(STRuser, quote(lp), VAR_READWRITE); /* lp memory used here */
1541c80476e4SDavid E. O'Brien cleanup_ignore(lp);
1542c80476e4SDavid E. O'Brien cleanup_until(lp);
154345e5710bSMark Peek return;
1544c80476e4SDavid E. O'Brien }
1545c80476e4SDavid E. O'Brien
1546c80476e4SDavid E. O'Brien if (eq(vp, STRKGROUP)) {
154745e5710bSMark Peek setv(STRgroup, quote(lp), VAR_READWRITE); /* lp memory used here */
1548c80476e4SDavid E. O'Brien cleanup_ignore(lp);
1549c80476e4SDavid E. O'Brien cleanup_until(lp);
1550c80476e4SDavid E. O'Brien return;
1551c80476e4SDavid E. O'Brien }
1552c80476e4SDavid E. O'Brien
1553c80476e4SDavid E. O'Brien #ifdef COLOR_LS_F
1554c80476e4SDavid E. O'Brien if (eq(vp, STRLS_COLORS)) {
1555c80476e4SDavid E. O'Brien parseLS_COLORS(lp);
1556c80476e4SDavid E. O'Brien cleanup_until(lp);
155745e5710bSMark Peek return;
1558c80476e4SDavid E. O'Brien }
155945e5710bSMark Peek if (eq(vp, STRLSCOLORS)) {
1560c80476e4SDavid E. O'Brien parseLSCOLORS(lp);
156145e5710bSMark Peek cleanup_until(lp);
156245e5710bSMark Peek return;
156345e5710bSMark Peek }
1564c80476e4SDavid E. O'Brien #endif /* COLOR_LS_F */
156523338178SMark Peek
156623338178SMark Peek #ifdef SIG_WINDOW
156723338178SMark Peek /*
1568c80476e4SDavid E. O'Brien * Load/Update $LINES $COLUMNS
1569c80476e4SDavid E. O'Brien */
1570c80476e4SDavid E. O'Brien if ((eq(lp, STRNULL) && (eq(vp, STRLINES) || eq(vp, STRCOLUMNS))) ||
15713b6eaa7bSAndrey A. Chernov eq(vp, STRTERMCAP)) {
1572c80476e4SDavid E. O'Brien cleanup_until(lp);
15733b6eaa7bSAndrey A. Chernov check_window_size(1);
1574c80476e4SDavid E. O'Brien return;
15753b6eaa7bSAndrey A. Chernov }
157623338178SMark Peek
157723338178SMark Peek /*
1578c80476e4SDavid E. O'Brien * Change the size to the one directed by $LINES and $COLUMNS
157923338178SMark Peek */
15803b6eaa7bSAndrey A. Chernov if (eq(vp, STRLINES) || eq(vp, STRCOLUMNS)) {
1581c80476e4SDavid E. O'Brien #if 0
158223338178SMark Peek GotTermCaps = 0;
1583c80476e4SDavid E. O'Brien #endif
1584c80476e4SDavid E. O'Brien cleanup_until(lp);
158545e5710bSMark Peek ed_Init();
1586c80476e4SDavid E. O'Brien return;
158745e5710bSMark Peek }
1588c80476e4SDavid E. O'Brien #endif /* SIG_WINDOW */
1589c80476e4SDavid E. O'Brien cleanup_until(lp);
1590c80476e4SDavid E. O'Brien }
1591c80476e4SDavid E. O'Brien
1592c80476e4SDavid E. O'Brien /*ARGSUSED*/
1593c80476e4SDavid E. O'Brien void
dounsetenv(Char ** v,struct command * c)159445e5710bSMark Peek dounsetenv(Char **v, struct command *c)
1595c80476e4SDavid E. O'Brien {
1596c80476e4SDavid E. O'Brien Char **ep, *p, *n, *name;
1597c80476e4SDavid E. O'Brien int i, maxi;
1598c80476e4SDavid E. O'Brien
159945e5710bSMark Peek USE(c);
1600c80476e4SDavid E. O'Brien /*
1601c80476e4SDavid E. O'Brien * Find the longest environment variable
1602c80476e4SDavid E. O'Brien */
1603c80476e4SDavid E. O'Brien for (maxi = 0, ep = STR_environ; *ep; ep++) {
160445e5710bSMark Peek for (i = 0, p = *ep; *p && *p != '='; p++, i++)
1605c80476e4SDavid E. O'Brien continue;
160623338178SMark Peek if (i > maxi)
160723338178SMark Peek maxi = i;
1608c80476e4SDavid E. O'Brien }
1609c80476e4SDavid E. O'Brien
16103b6eaa7bSAndrey A. Chernov name = xmalloc((maxi + 1) * sizeof(Char));
1611c80476e4SDavid E. O'Brien cleanup_push(name, xfree);
16123b6eaa7bSAndrey A. Chernov
1613c80476e4SDavid E. O'Brien while (++v && *v)
1614c80476e4SDavid E. O'Brien for (maxi = 1; maxi;)
1615c80476e4SDavid E. O'Brien for (maxi = 0, ep = STR_environ; *ep; ep++) {
1616c80476e4SDavid E. O'Brien for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
1617c80476e4SDavid E. O'Brien continue;
1618c80476e4SDavid E. O'Brien *n = '\0';
1619c80476e4SDavid E. O'Brien if (!Gmatch(name, *v))
1620c80476e4SDavid E. O'Brien continue;
1621c80476e4SDavid E. O'Brien maxi = 1;
1622c80476e4SDavid E. O'Brien
1623c80476e4SDavid E. O'Brien /* Unset the name. This wasn't being done until
162445e5710bSMark Peek * later but most of the stuff following won't
162545e5710bSMark Peek * work (particularly the setlocale() and getenv()
1626c80476e4SDavid E. O'Brien * stuff) as intended until the name is actually
1627c80476e4SDavid E. O'Brien * removed. (sg)
1628c80476e4SDavid E. O'Brien */
1629c80476e4SDavid E. O'Brien Unsetenv(name);
1630c80476e4SDavid E. O'Brien
1631c80476e4SDavid E. O'Brien if (eq(name, STRNOREBIND)) {
163245e5710bSMark Peek NoNLSRebind = 0;
1633c80476e4SDavid E. O'Brien MapsAreInited = 0;
163423338178SMark Peek NLSMapsAreInited = 0;
163523338178SMark Peek ed_InitMaps();
1636c80476e4SDavid E. O'Brien }
1637c80476e4SDavid E. O'Brien #ifdef apollo
1638c80476e4SDavid E. O'Brien else if (eq(name, STRSYSTYPE))
16398e66bd9eSDavid E. O'Brien dohash(NULL, NULL);
1640c80476e4SDavid E. O'Brien #endif /* apollo */
1641c80476e4SDavid E. O'Brien else if (islocale_var(name)) {
1642c80476e4SDavid E. O'Brien #ifdef NLS
1643c80476e4SDavid E. O'Brien int k;
1644c80476e4SDavid E. O'Brien
1645c80476e4SDavid E. O'Brien # ifdef SETLOCALEBUG
1646c80476e4SDavid E. O'Brien dont_free = 1;
1647c80476e4SDavid E. O'Brien # endif /* SETLOCALEBUG */
1648c80476e4SDavid E. O'Brien (void) setlocale(LC_ALL, "");
1649c80476e4SDavid E. O'Brien # ifdef LC_COLLATE
1650c80476e4SDavid E. O'Brien (void) setlocale(LC_COLLATE, "");
1651c80476e4SDavid E. O'Brien # endif
1652c80476e4SDavid E. O'Brien # ifdef LC_CTYPE
1653c80476e4SDavid E. O'Brien (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1654c80476e4SDavid E. O'Brien # endif /* LC_CTYPE */
165523338178SMark Peek # ifdef NLS_CATALOGS
165623338178SMark Peek # ifdef LC_MESSAGES
165723338178SMark Peek (void) setlocale(LC_MESSAGES, "");
1658c80476e4SDavid E. O'Brien # endif /* LC_MESSAGES */
1659c80476e4SDavid E. O'Brien nlsclose();
1660c80476e4SDavid E. O'Brien nlsinit();
1661c80476e4SDavid E. O'Brien # endif /* NLS_CATALOGS */
1662c80476e4SDavid E. O'Brien # ifdef SETLOCALEBUG
1663c80476e4SDavid E. O'Brien dont_free = 0;
1664c80476e4SDavid E. O'Brien # endif /* SETLOCALEBUG */
1665c80476e4SDavid E. O'Brien # ifdef STRCOLLBUG
1666c80476e4SDavid E. O'Brien fix_strcoll_bug();
1667c80476e4SDavid E. O'Brien # endif /* STRCOLLBUG */
1668c80476e4SDavid E. O'Brien tw_cmd_free();/* since the collation sequence has changed */
1669c80476e4SDavid E. O'Brien for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1670c80476e4SDavid E. O'Brien continue;
1671c80476e4SDavid E. O'Brien AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1672c80476e4SDavid E. O'Brien #else /* !NLS */
167323338178SMark Peek AsciiOnly = getenv("LANG") == NULL &&
167429301572SMark Peek getenv("LC_CTYPE") == NULL;
1675c80476e4SDavid E. O'Brien #endif /* NLS */
1676c80476e4SDavid E. O'Brien NLSMapsAreInited = 0;
1677c80476e4SDavid E. O'Brien ed_Init();
1678c80476e4SDavid E. O'Brien if (MapsAreInited && !NLSMapsAreInited)
1679c80476e4SDavid E. O'Brien ed_InitNLSMaps();
1680c80476e4SDavid E. O'Brien
168129301572SMark Peek }
1682c80476e4SDavid E. O'Brien #ifdef WINNT_NATIVE
1683c80476e4SDavid E. O'Brien else if (eq(name,(STRtcshlang))) {
1684c80476e4SDavid E. O'Brien nls_dll_unload();
1685c80476e4SDavid E. O'Brien nlsinit();
1686c80476e4SDavid E. O'Brien }
1687c80476e4SDavid E. O'Brien #endif /* WINNT_NATIVE */
1688b2d5d167SMark Peek #ifdef COLOR_LS_F
1689c80476e4SDavid E. O'Brien else if (eq(name, STRLS_COLORS))
1690c80476e4SDavid E. O'Brien parseLS_COLORS(n);
1691c80476e4SDavid E. O'Brien else if (eq(name, STRLSCOLORS))
1692c80476e4SDavid E. O'Brien parseLSCOLORS(n);
1693c80476e4SDavid E. O'Brien #endif /* COLOR_LS_F */
1694c80476e4SDavid E. O'Brien #ifdef NLS_CATALOGS
1695c80476e4SDavid E. O'Brien else if (eq(name, STRNLSPATH)) {
1696c80476e4SDavid E. O'Brien nlsclose();
1697c80476e4SDavid E. O'Brien nlsinit();
1698c80476e4SDavid E. O'Brien }
1699c80476e4SDavid E. O'Brien #endif
1700c80476e4SDavid E. O'Brien /*
1701c80476e4SDavid E. O'Brien * start again cause the environment changes
1702c80476e4SDavid E. O'Brien */
1703c80476e4SDavid E. O'Brien break;
1704c80476e4SDavid E. O'Brien }
1705c80476e4SDavid E. O'Brien cleanup_until(name);
1706c80476e4SDavid E. O'Brien }
1707c80476e4SDavid E. O'Brien
1708c80476e4SDavid E. O'Brien void
tsetenv(const Char * name,const Char * val)1709b2d5d167SMark Peek tsetenv(const Char *name, const Char *val)
1710c80476e4SDavid E. O'Brien {
1711c80476e4SDavid E. O'Brien #ifdef SETENV_IN_LIB
1712c80476e4SDavid E. O'Brien /*
1713c80476e4SDavid E. O'Brien * XXX: This does not work right, since tcsh cannot track changes to
1714c80476e4SDavid E. O'Brien * the environment this way. (the builtin setenv without arguments does
17156767bd61SMark Peek * not print the right stuff neither does unsetenv). This was for Mach,
17166767bd61SMark Peek * it is not needed anymore.
1717c80476e4SDavid E. O'Brien */
1718c80476e4SDavid E. O'Brien #undef setenv
1719c80476e4SDavid E. O'Brien char *cname;
1720c80476e4SDavid E. O'Brien
1721c80476e4SDavid E. O'Brien if (name == NULL)
1722c80476e4SDavid E. O'Brien return;
1723c80476e4SDavid E. O'Brien cname = strsave(short2str(name));
1724c80476e4SDavid E. O'Brien setenv(cname, short2str(val), 1);
172523338178SMark Peek xfree(cname);
17266767bd61SMark Peek #else /* !SETENV_IN_LIB */
17276767bd61SMark Peek Char **ep = STR_environ;
17286767bd61SMark Peek const Char *ccp;
1729c80476e4SDavid E. O'Brien Char *cp, *dp;
1730c80476e4SDavid E. O'Brien Char *blk[2];
1731c80476e4SDavid E. O'Brien Char **oep = ep;
1732c80476e4SDavid E. O'Brien
1733c80476e4SDavid E. O'Brien #ifdef WINNT_NATIVE
1734c80476e4SDavid E. O'Brien nt_set_env(name,val);
1735c80476e4SDavid E. O'Brien #endif /* WINNT_NATIVE */
1736c80476e4SDavid E. O'Brien for (; *ep; ep++) {
1737c80476e4SDavid E. O'Brien #ifdef WINNT_NATIVE
1738c80476e4SDavid E. O'Brien for (ccp = name, dp = *ep; *ccp && Tolower(*ccp & TRIM) == Tolower(*dp);
1739c80476e4SDavid E. O'Brien ccp++, dp++)
1740c80476e4SDavid E. O'Brien #else
1741c80476e4SDavid E. O'Brien for (ccp = name, dp = *ep; *ccp && (*ccp & TRIM) == *dp; ccp++, dp++)
1742c80476e4SDavid E. O'Brien #endif /* WINNT_NATIVE */
1743c80476e4SDavid E. O'Brien continue;
1744c80476e4SDavid E. O'Brien if (*ccp != 0 || *dp != '=')
1745c80476e4SDavid E. O'Brien continue;
1746c80476e4SDavid E. O'Brien cp = Strspl(STRequal, val);
1747c80476e4SDavid E. O'Brien xfree(*ep);
1748c80476e4SDavid E. O'Brien *ep = strip(Strspl(name, cp));
1749c80476e4SDavid E. O'Brien xfree(cp);
1750c80476e4SDavid E. O'Brien blkfree((Char **) environ);
1751c80476e4SDavid E. O'Brien environ = short2blk(STR_environ);
1752c80476e4SDavid E. O'Brien return;
1753c80476e4SDavid E. O'Brien }
1754c80476e4SDavid E. O'Brien cp = Strspl(name, STRequal);
1755c80476e4SDavid E. O'Brien blk[0] = strip(Strspl(cp, val));
1756c80476e4SDavid E. O'Brien xfree(cp);
1757c80476e4SDavid E. O'Brien blk[1] = 0;
1758c80476e4SDavid E. O'Brien STR_environ = blkspl(STR_environ, blk);
1759c80476e4SDavid E. O'Brien blkfree((Char **) environ);
1760c80476e4SDavid E. O'Brien environ = short2blk(STR_environ);
1761c80476e4SDavid E. O'Brien xfree(oep);
1762c80476e4SDavid E. O'Brien #endif /* SETENV_IN_LIB */
1763c80476e4SDavid E. O'Brien }
1764c80476e4SDavid E. O'Brien
1765c80476e4SDavid E. O'Brien void
Unsetenv(Char * name)1766c80476e4SDavid E. O'Brien Unsetenv(Char *name)
1767c80476e4SDavid E. O'Brien {
1768c80476e4SDavid E. O'Brien Char **ep = STR_environ;
1769c80476e4SDavid E. O'Brien Char *cp, *dp;
1770c80476e4SDavid E. O'Brien Char **oep = ep;
177123338178SMark Peek
177223338178SMark Peek #ifdef WINNT_NATIVE
177323338178SMark Peek nt_set_env(name,NULL);
177423338178SMark Peek #endif /*WINNT_NATIVE */
1775c80476e4SDavid E. O'Brien for (; *ep; ep++) {
1776c80476e4SDavid E. O'Brien for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
1777c80476e4SDavid E. O'Brien continue;
1778c80476e4SDavid E. O'Brien if (*cp != 0 || *dp != '=')
1779c80476e4SDavid E. O'Brien continue;
1780c80476e4SDavid E. O'Brien cp = *ep;
1781c80476e4SDavid E. O'Brien *ep = 0;
1782c80476e4SDavid E. O'Brien STR_environ = blkspl(STR_environ, ep + 1);
1783c80476e4SDavid E. O'Brien blkfree((Char **) environ);
1784c80476e4SDavid E. O'Brien environ = short2blk(STR_environ);
1785c80476e4SDavid E. O'Brien *ep = cp;
1786c80476e4SDavid E. O'Brien xfree(cp);
1787c80476e4SDavid E. O'Brien xfree(oep);
1788c80476e4SDavid E. O'Brien return;
1789c80476e4SDavid E. O'Brien }
1790c80476e4SDavid E. O'Brien }
179129301572SMark Peek
1792c80476e4SDavid E. O'Brien /*ARGSUSED*/
179329301572SMark Peek void
doumask(Char ** v,struct command * c)179429301572SMark Peek doumask(Char **v, struct command *c)
179529301572SMark Peek {
179629301572SMark Peek Char *cp = v[1];
179729301572SMark Peek int i;
1798c80476e4SDavid E. O'Brien
1799c9253e93SKonstantin Belousov USE(c);
1800c9253e93SKonstantin Belousov if (cp == 0) {
1801c9253e93SKonstantin Belousov i = (int)umask(0);
1802c9253e93SKonstantin Belousov (void) umask(i);
1803c80476e4SDavid E. O'Brien xprintf("%o\n", i);
1804c80476e4SDavid E. O'Brien return;
1805c80476e4SDavid E. O'Brien }
180645e5710bSMark Peek i = 0;
180745e5710bSMark Peek while (Isdigit(*cp) && *cp != '8' && *cp != '9')
180845e5710bSMark Peek i = i * 8 + *cp++ - '0';
180945e5710bSMark Peek if (*cp || i < 0 || i > 0777)
181045e5710bSMark Peek stderror(ERR_NAME | ERR_MASK);
1811c80476e4SDavid E. O'Brien (void) umask(i);
1812c80476e4SDavid E. O'Brien }
1813c80476e4SDavid E. O'Brien
181445e5710bSMark Peek #ifndef HAVENOLIMIT
1815c80476e4SDavid E. O'Brien # ifndef BSDLIMIT
1816c80476e4SDavid E. O'Brien typedef long RLIM_TYPE;
1817c80476e4SDavid E. O'Brien # ifdef _OSD_POSIX /* BS2000 */
1818c80476e4SDavid E. O'Brien # include <ulimit.h>
1819c80476e4SDavid E. O'Brien # endif
1820c80476e4SDavid E. O'Brien # ifndef RLIM_INFINITY
1821c80476e4SDavid E. O'Brien # if !defined(_MINIX) && !defined(__clipper__) && !defined(_CRAY)
1822c80476e4SDavid E. O'Brien extern RLIM_TYPE ulimit();
1823c80476e4SDavid E. O'Brien # endif /* ! _MINIX && !__clipper__ */
1824c80476e4SDavid E. O'Brien # define RLIM_INFINITY 0x003fffff
1825c80476e4SDavid E. O'Brien # define RLIMIT_FSIZE 1
1826c80476e4SDavid E. O'Brien # endif /* RLIM_INFINITY */
1827c80476e4SDavid E. O'Brien # ifdef aiws
1828c80476e4SDavid E. O'Brien # define toset(a) (((a) == 3) ? 1004 : (a) + 1)
1829c80476e4SDavid E. O'Brien # define RLIMIT_DATA 3
1830c80476e4SDavid E. O'Brien # define RLIMIT_STACK 1005
1831c80476e4SDavid E. O'Brien # else /* aiws */
183245e5710bSMark Peek # define toset(a) ((a) + 1)
1833c80476e4SDavid E. O'Brien # endif /* aiws */
183423338178SMark Peek # else /* BSDLIMIT */
1835c80476e4SDavid E. O'Brien # if (defined(BSD4_4) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (HPUXVERSION >= 1100)) && !defined(__386BSD__)
183645e5710bSMark Peek typedef rlim_t RLIM_TYPE;
1837c80476e4SDavid E. O'Brien # else
1838c80476e4SDavid E. O'Brien # if defined(SOLARIS2) || (defined(sgi) && SYSVREL > 3)
1839c80476e4SDavid E. O'Brien typedef rlim_t RLIM_TYPE;
1840c80476e4SDavid E. O'Brien # else
1841c80476e4SDavid E. O'Brien # if defined(_SX)
1842c80476e4SDavid E. O'Brien typedef long long RLIM_TYPE;
1843c80476e4SDavid E. O'Brien # else /* !_SX */
1844c80476e4SDavid E. O'Brien typedef unsigned long RLIM_TYPE;
1845c80476e4SDavid E. O'Brien # endif /* _SX */
1846c80476e4SDavid E. O'Brien # endif /* SOLARIS2 || (sgi && SYSVREL > 3) */
1847c80476e4SDavid E. O'Brien # endif /* BSD4_4 && !__386BSD__ */
1848c80476e4SDavid E. O'Brien # endif /* BSDLIMIT */
1849c80476e4SDavid E. O'Brien
1850c80476e4SDavid E. O'Brien # if (HPUXVERSION > 700) && (HPUXVERSION < 1100) && defined(BSDLIMIT)
1851c80476e4SDavid E. O'Brien /* Yes hpux8.0 has limits but <sys/resource.h> does not make them public */
185245e5710bSMark Peek /* Yes, we could have defined _KERNEL, and -I/etc/conf/h, but is that better? */
1853c80476e4SDavid E. O'Brien # ifndef RLIMIT_CPU
185423338178SMark Peek # define RLIMIT_CPU 0
185523338178SMark Peek # define RLIMIT_FSIZE 1
1856c80476e4SDavid E. O'Brien # define RLIMIT_DATA 2
1857c80476e4SDavid E. O'Brien # define RLIMIT_STACK 3
1858c80476e4SDavid E. O'Brien # define RLIMIT_CORE 4
1859c80476e4SDavid E. O'Brien # define RLIMIT_RSS 5
1860c80476e4SDavid E. O'Brien # define RLIMIT_NOFILE 6
1861c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
1862c80476e4SDavid E. O'Brien # ifndef RLIM_INFINITY
1863c80476e4SDavid E. O'Brien # define RLIM_INFINITY 0x7fffffff
1864c80476e4SDavid E. O'Brien # endif /* RLIM_INFINITY */
1865c80476e4SDavid E. O'Brien /*
1866c80476e4SDavid E. O'Brien * old versions of HP/UX counted limits in 512 bytes
1867c80476e4SDavid E. O'Brien */
1868c80476e4SDavid E. O'Brien # ifndef SIGRTMIN
1869c80476e4SDavid E. O'Brien # define FILESIZE512
1870c80476e4SDavid E. O'Brien # endif /* SIGRTMIN */
1871c80476e4SDavid E. O'Brien # endif /* (HPUXVERSION > 700) && (HPUXVERSION < 1100) && BSDLIMIT */
1872c80476e4SDavid E. O'Brien
1873c80476e4SDavid E. O'Brien # if SYSVREL > 3 && defined(BSDLIMIT) && !defined(_SX)
1874c80476e4SDavid E. O'Brien /* In order to use rusage, we included "/usr/ucbinclude/sys/resource.h" in */
1875c80476e4SDavid E. O'Brien /* sh.h. However, some SVR4 limits are defined in <sys/resource.h>. Rather */
1876c80476e4SDavid E. O'Brien /* than include both and get warnings, we define the extra SVR4 limits here. */
1877c80476e4SDavid E. O'Brien /* XXX: I don't understand if RLIMIT_AS is defined, why don't we define */
1878c80476e4SDavid E. O'Brien /* RLIMIT_VMEM based on it? */
1879c80476e4SDavid E. O'Brien # ifndef RLIMIT_VMEM
188045e5710bSMark Peek # define RLIMIT_VMEM 6
1881c80476e4SDavid E. O'Brien # endif
188223338178SMark Peek # ifndef RLIMIT_AS
1883c80476e4SDavid E. O'Brien # define RLIMIT_AS RLIMIT_VMEM
1884c80476e4SDavid E. O'Brien # endif
1885c80476e4SDavid E. O'Brien # endif /* SYSVREL > 3 && BSDLIMIT */
1886c80476e4SDavid E. O'Brien
1887c80476e4SDavid E. O'Brien # if (defined(__linux__) || defined(__GNU__) || defined(__GLIBC__))
1888c80476e4SDavid E. O'Brien # if defined(RLIMIT_AS) && !defined(RLIMIT_VMEM)
1889c80476e4SDavid E. O'Brien # define RLIMIT_VMEM RLIMIT_AS
1890c80476e4SDavid E. O'Brien # endif
1891c80476e4SDavid E. O'Brien /*
1892c80476e4SDavid E. O'Brien * Oh well, <asm-generic/resource.h> has it, but <bits/resource.h> does not
1893c80476e4SDavid E. O'Brien * Linux headers: When the left hand does not know what the right hand does.
1894c80476e4SDavid E. O'Brien */
1895c80476e4SDavid E. O'Brien # if defined(RLIMIT_RTPRIO) && !defined(RLIMIT_RTTIME)
1896c80476e4SDavid E. O'Brien # define RLIMIT_RTTIME (RLIMIT_RTPRIO + 1)
1897c80476e4SDavid E. O'Brien # endif
1898c80476e4SDavid E. O'Brien # endif
1899c80476e4SDavid E. O'Brien
1900c80476e4SDavid E. O'Brien struct limits limits[] =
19013b6eaa7bSAndrey A. Chernov {
1902c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
1903c80476e4SDavid E. O'Brien { RLIMIT_CPU, "cputime", 1, "seconds" },
1904c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
1905c80476e4SDavid E. O'Brien
1906c80476e4SDavid E. O'Brien # ifdef RLIMIT_FSIZE
1907c80476e4SDavid E. O'Brien # ifndef aiws
1908c80476e4SDavid E. O'Brien { RLIMIT_FSIZE, "filesize", 1024, "kbytes" },
1909c80476e4SDavid E. O'Brien # else
1910c80476e4SDavid E. O'Brien { RLIMIT_FSIZE, "filesize", 512, "blocks" },
1911c80476e4SDavid E. O'Brien # endif /* aiws */
1912c80476e4SDavid E. O'Brien # endif /* RLIMIT_FSIZE */
1913c80476e4SDavid E. O'Brien
1914c80476e4SDavid E. O'Brien # ifdef RLIMIT_DATA
1915c80476e4SDavid E. O'Brien { RLIMIT_DATA, "datasize", 1024, "kbytes" },
1916c80476e4SDavid E. O'Brien # endif /* RLIMIT_DATA */
1917c80476e4SDavid E. O'Brien
1918c80476e4SDavid E. O'Brien # ifdef RLIMIT_STACK
1919c80476e4SDavid E. O'Brien # ifndef aiws
1920c80476e4SDavid E. O'Brien { RLIMIT_STACK, "stacksize", 1024, "kbytes" },
1921c80476e4SDavid E. O'Brien # else
1922c80476e4SDavid E. O'Brien { RLIMIT_STACK, "stacksize", 1024 * 1024, "kbytes"},
1923c80476e4SDavid E. O'Brien # endif /* aiws */
1924c80476e4SDavid E. O'Brien # endif /* RLIMIT_STACK */
1925c80476e4SDavid E. O'Brien
1926c80476e4SDavid E. O'Brien # ifdef RLIMIT_CORE
1927c80476e4SDavid E. O'Brien { RLIMIT_CORE, "coredumpsize", 1024, "kbytes" },
1928c80476e4SDavid E. O'Brien # endif /* RLIMIT_CORE */
1929c80476e4SDavid E. O'Brien
1930c80476e4SDavid E. O'Brien # ifdef RLIMIT_RSS
1931c80476e4SDavid E. O'Brien { RLIMIT_RSS, "memoryuse", 1024, "kbytes" },
1932c80476e4SDavid E. O'Brien # endif /* RLIMIT_RSS */
1933c80476e4SDavid E. O'Brien
1934c80476e4SDavid E. O'Brien # ifdef RLIMIT_UMEM
1935c80476e4SDavid E. O'Brien { RLIMIT_UMEM, "memoryuse", 1024, "kbytes" },
1936c80476e4SDavid E. O'Brien # endif /* RLIMIT_UMEM */
1937c80476e4SDavid E. O'Brien
1938c80476e4SDavid E. O'Brien # ifdef RLIMIT_VMEM
1939c80476e4SDavid E. O'Brien { RLIMIT_VMEM, "vmemoryuse", 1024, "kbytes" },
1940c80476e4SDavid E. O'Brien # endif /* RLIMIT_VMEM */
1941c80476e4SDavid E. O'Brien
1942c80476e4SDavid E. O'Brien # if defined(RLIMIT_HEAP) /* found on BS2000/OSD systems */
1943c80476e4SDavid E. O'Brien { RLIMIT_HEAP, "heapsize", 1024, "kbytes" },
1944c80476e4SDavid E. O'Brien # endif /* RLIMIT_HEAP */
1945c80476e4SDavid E. O'Brien
1946c80476e4SDavid E. O'Brien # ifdef RLIMIT_NOFILE
1947c80476e4SDavid E. O'Brien { RLIMIT_NOFILE, "descriptors", 1, "" },
1948c80476e4SDavid E. O'Brien # endif /* RLIMIT_NOFILE */
1949c80476e4SDavid E. O'Brien
1950c80476e4SDavid E. O'Brien # ifdef RLIMIT_NPTS
1951c80476e4SDavid E. O'Brien { RLIMIT_NPTS, "pseudoterminals", 1, "" },
1952c80476e4SDavid E. O'Brien # endif /* RLIMIT_NPTS */
1953c80476e4SDavid E. O'Brien
1954c80476e4SDavid E. O'Brien # ifdef RLIMIT_KQUEUES
1955c80476e4SDavid E. O'Brien { RLIMIT_KQUEUES, "kqueues", 1, "" },
1956c80476e4SDavid E. O'Brien # endif /* RLIMIT_KQUEUES */
1957c80476e4SDavid E. O'Brien
1958c80476e4SDavid E. O'Brien # ifdef RLIMIT_CONCUR
1959c80476e4SDavid E. O'Brien { RLIMIT_CONCUR, "concurrency", 1, "thread(s)" },
1960c80476e4SDavid E. O'Brien # endif /* RLIMIT_CONCUR */
1961c80476e4SDavid E. O'Brien
1962c80476e4SDavid E. O'Brien # ifdef RLIMIT_MEMLOCK
1963c80476e4SDavid E. O'Brien { RLIMIT_MEMLOCK, "memorylocked", 1024, "kbytes" },
1964c80476e4SDavid E. O'Brien # endif /* RLIMIT_MEMLOCK */
1965c80476e4SDavid E. O'Brien
1966c80476e4SDavid E. O'Brien # ifdef RLIMIT_NPROC
1967c80476e4SDavid E. O'Brien { RLIMIT_NPROC, "maxproc", 1, "" },
1968c80476e4SDavid E. O'Brien # endif /* RLIMIT_NPROC */
1969c80476e4SDavid E. O'Brien
1970c80476e4SDavid E. O'Brien # ifdef RLIMIT_NTHR
1971c80476e4SDavid E. O'Brien { RLIMIT_NTHR, "maxthread", 1, "" },
1972c80476e4SDavid E. O'Brien # endif /* RLIMIT_NTHR */
1973c80476e4SDavid E. O'Brien
1974c80476e4SDavid E. O'Brien # if defined(RLIMIT_OFILE) && !defined(RLIMIT_NOFILE)
1975c80476e4SDavid E. O'Brien { RLIMIT_OFILE, "openfiles", 1, "" },
1976c80476e4SDavid E. O'Brien # endif /* RLIMIT_OFILE && !defined(RLIMIT_NOFILE) */
1977c80476e4SDavid E. O'Brien
197845e5710bSMark Peek # ifdef RLIMIT_SBSIZE
1979c80476e4SDavid E. O'Brien { RLIMIT_SBSIZE, "sbsize", 1, "" },
198023338178SMark Peek # endif /* RLIMIT_SBSIZE */
1981dc86a98eSDavid E. O'Brien
1982dc86a98eSDavid E. O'Brien # ifdef RLIMIT_SWAP
198323338178SMark Peek { RLIMIT_SWAP, "swapsize", 1024, "kbytes" },
1984c80476e4SDavid E. O'Brien # endif /* RLIMIT_SWAP */
1985c80476e4SDavid E. O'Brien
1986dc86a98eSDavid E. O'Brien # ifdef RLIMIT_LOCKS
1987c80476e4SDavid E. O'Brien { RLIMIT_LOCKS, "maxlocks", 1, "" },
1988c80476e4SDavid E. O'Brien # endif /* RLIMIT_LOCKS */
1989c80476e4SDavid E. O'Brien
1990c80476e4SDavid E. O'Brien # ifdef RLIMIT_POSIXLOCKS
1991c80476e4SDavid E. O'Brien { RLIMIT_POSIXLOCKS,"posixlocks", 1, "" },
199245e5710bSMark Peek # endif /* RLIMIT_POSIXLOCKS */
1993c80476e4SDavid E. O'Brien
1994c80476e4SDavid E. O'Brien # ifdef RLIMIT_SIGPENDING
1995c80476e4SDavid E. O'Brien { RLIMIT_SIGPENDING,"maxsignal", 1, "" },
1996c80476e4SDavid E. O'Brien # endif /* RLIMIT_SIGPENDING */
1997c80476e4SDavid E. O'Brien
199823338178SMark Peek # ifdef RLIMIT_MSGQUEUE
1999c80476e4SDavid E. O'Brien { RLIMIT_MSGQUEUE, "maxmessage", 1, "" },
2000b2d5d167SMark Peek # endif /* RLIMIT_MSGQUEUE */
2001c80476e4SDavid E. O'Brien
2002c80476e4SDavid E. O'Brien # ifdef RLIMIT_NICE
2003c80476e4SDavid E. O'Brien { RLIMIT_NICE, "maxnice", 1, "" },
2004c80476e4SDavid E. O'Brien # endif /* RLIMIT_NICE */
2005c80476e4SDavid E. O'Brien
2006c80476e4SDavid E. O'Brien # ifdef RLIMIT_RTPRIO
2007c80476e4SDavid E. O'Brien { RLIMIT_RTPRIO, "maxrtprio", 1, "" },
2008c80476e4SDavid E. O'Brien # endif /* RLIMIT_RTPRIO */
2009c80476e4SDavid E. O'Brien
2010c80476e4SDavid E. O'Brien # ifdef RLIMIT_RTTIME
2011c80476e4SDavid E. O'Brien { RLIMIT_RTTIME, "maxrttime", 1, "usec" },
2012c80476e4SDavid E. O'Brien # endif /* RLIMIT_RTTIME */
2013c80476e4SDavid E. O'Brien
2014c80476e4SDavid E. O'Brien { -1, NULL, 0, NULL }
2015c80476e4SDavid E. O'Brien };
2016c80476e4SDavid E. O'Brien
2017c80476e4SDavid E. O'Brien static struct limits *findlim (Char *);
2018c80476e4SDavid E. O'Brien static RLIM_TYPE getval (struct limits *, Char **);
2019c80476e4SDavid E. O'Brien static int strtail (Char *, const char *);
2020c80476e4SDavid E. O'Brien static void limtail (Char *, const char *);
2021c80476e4SDavid E. O'Brien static void limtail2 (Char *, const char *, const char *);
202223338178SMark Peek static void plim (struct limits *, int);
2023c80476e4SDavid E. O'Brien static int setlim (struct limits *, int, RLIM_TYPE);
2024c80476e4SDavid E. O'Brien
2025c80476e4SDavid E. O'Brien #ifdef convex
2026c80476e4SDavid E. O'Brien static RLIM_TYPE
restrict_limit(double value)2027c80476e4SDavid E. O'Brien restrict_limit(double value)
2028c80476e4SDavid E. O'Brien {
202923338178SMark Peek /*
203023338178SMark Peek * is f too large to cope with? return the maximum or minimum int
203123338178SMark Peek */
203223338178SMark Peek if (value > (double) INT_MAX)
203323338178SMark Peek return (RLIM_TYPE) INT_MAX;
203423338178SMark Peek else if (value < (double) INT_MIN)
2035c80476e4SDavid E. O'Brien return (RLIM_TYPE) INT_MIN;
2036c80476e4SDavid E. O'Brien else
203745e5710bSMark Peek return (RLIM_TYPE) value;
2038c80476e4SDavid E. O'Brien }
2039c80476e4SDavid E. O'Brien #else /* !convex */
204023338178SMark Peek # define restrict_limit(x) ((RLIM_TYPE) (x))
2041c80476e4SDavid E. O'Brien #endif /* convex */
2042c80476e4SDavid E. O'Brien
2043c80476e4SDavid E. O'Brien
2044c80476e4SDavid E. O'Brien static struct limits *
findlim(Char * cp)2045c80476e4SDavid E. O'Brien findlim(Char *cp)
204645e5710bSMark Peek {
2047c80476e4SDavid E. O'Brien struct limits *lp, *res;
204823338178SMark Peek
2049c80476e4SDavid E. O'Brien res = NULL;
2050c80476e4SDavid E. O'Brien for (lp = limits; lp->limconst >= 0; lp++)
2051c80476e4SDavid E. O'Brien if (prefix(cp, str2short(lp->limname))) {
2052c80476e4SDavid E. O'Brien if (res)
2053c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_AMBIG);
2054c80476e4SDavid E. O'Brien res = lp;
2055c80476e4SDavid E. O'Brien }
2056c80476e4SDavid E. O'Brien if (res)
2057c80476e4SDavid E. O'Brien return (res);
2058c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_LIMIT);
2059c80476e4SDavid E. O'Brien /* NOTREACHED */
2060c80476e4SDavid E. O'Brien return (0);
2061c80476e4SDavid E. O'Brien }
2062c80476e4SDavid E. O'Brien
2063c80476e4SDavid E. O'Brien /*ARGSUSED*/
2064c80476e4SDavid E. O'Brien void
dolimit(Char ** v,struct command * c)2065c80476e4SDavid E. O'Brien dolimit(Char **v, struct command *c)
2066c80476e4SDavid E. O'Brien {
2067c80476e4SDavid E. O'Brien struct limits *lp;
2068c80476e4SDavid E. O'Brien RLIM_TYPE limit;
2069c80476e4SDavid E. O'Brien int hard = 0;
2070c80476e4SDavid E. O'Brien
2071c80476e4SDavid E. O'Brien USE(c);
2072c80476e4SDavid E. O'Brien v++;
2073c80476e4SDavid E. O'Brien if (*v && eq(*v, STRmh)) {
2074c80476e4SDavid E. O'Brien hard = 1;
2075c80476e4SDavid E. O'Brien v++;
2076c80476e4SDavid E. O'Brien }
2077c80476e4SDavid E. O'Brien if (*v == 0) {
2078c80476e4SDavid E. O'Brien for (lp = limits; lp->limconst >= 0; lp++)
2079c80476e4SDavid E. O'Brien plim(lp, hard);
2080c80476e4SDavid E. O'Brien return;
2081c80476e4SDavid E. O'Brien }
2082c80476e4SDavid E. O'Brien lp = findlim(v[0]);
2083c80476e4SDavid E. O'Brien if (v[1] == 0) {
2084c80476e4SDavid E. O'Brien plim(lp, hard);
2085c80476e4SDavid E. O'Brien return;
208645e5710bSMark Peek }
2087c80476e4SDavid E. O'Brien limit = getval(lp, v + 1);
2088c80476e4SDavid E. O'Brien if (setlim(lp, hard, limit) < 0)
2089c80476e4SDavid E. O'Brien stderror(ERR_SILENT);
2090c80476e4SDavid E. O'Brien }
2091c80476e4SDavid E. O'Brien
2092c80476e4SDavid E. O'Brien static RLIM_TYPE
getval(struct limits * lp,Char ** v)2093c80476e4SDavid E. O'Brien getval(struct limits *lp, Char **v)
2094c80476e4SDavid E. O'Brien {
2095c80476e4SDavid E. O'Brien float f;
2096c80476e4SDavid E. O'Brien Char *cp = *v++;
2097c80476e4SDavid E. O'Brien
2098c80476e4SDavid E. O'Brien f = atof(short2str(cp));
2099c80476e4SDavid E. O'Brien
2100c80476e4SDavid E. O'Brien # ifdef convex
2101c80476e4SDavid E. O'Brien /*
2102c80476e4SDavid E. O'Brien * is f too large to cope with. limit f to minint, maxint - X-6768 by
2103c80476e4SDavid E. O'Brien * strike
2104c80476e4SDavid E. O'Brien */
210529301572SMark Peek if ((f < (double) INT_MIN) || (f > (double) INT_MAX)) {
210629301572SMark Peek stderror(ERR_NAME | ERR_TOOLARGE);
210729301572SMark Peek }
2108c80476e4SDavid E. O'Brien # endif /* convex */
2109c80476e4SDavid E. O'Brien
2110c80476e4SDavid E. O'Brien while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
2111c80476e4SDavid E. O'Brien cp++;
2112c80476e4SDavid E. O'Brien if (*cp == 0) {
2113c80476e4SDavid E. O'Brien if (*v == 0)
2114c80476e4SDavid E. O'Brien return restrict_limit((f * lp->limdiv) + 0.5);
2115c80476e4SDavid E. O'Brien cp = *v;
2116c80476e4SDavid E. O'Brien }
2117c80476e4SDavid E. O'Brien switch (*cp) {
211823338178SMark Peek # ifdef RLIMIT_CPU
211923338178SMark Peek case ':':
212023338178SMark Peek if (lp->limconst != RLIMIT_CPU)
212123338178SMark Peek goto badscal;
212223338178SMark Peek return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f * 60.0 + atof(short2str(cp + 1))));
212323338178SMark Peek case 'h':
212445e5710bSMark Peek if (lp->limconst != RLIMIT_CPU)
212523338178SMark Peek goto badscal;
212645e5710bSMark Peek limtail(cp, "hours");
212729301572SMark Peek f *= 3600.0;
212823338178SMark Peek break;
212945e5710bSMark Peek # endif /* RLIMIT_CPU */
2130c80476e4SDavid E. O'Brien case 'm':
2131c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
2132c80476e4SDavid E. O'Brien if (lp->limconst == RLIMIT_CPU) {
2133c80476e4SDavid E. O'Brien limtail(cp, "minutes");
2134c80476e4SDavid E. O'Brien f *= 60.0;
2135c80476e4SDavid E. O'Brien break;
2136c80476e4SDavid E. O'Brien }
2137c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
2138c80476e4SDavid E. O'Brien limtail2(cp, "megabytes", "mbytes");
213945e5710bSMark Peek f *= 1024.0 * 1024.0;
2140c80476e4SDavid E. O'Brien break;
2141c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
2142c80476e4SDavid E. O'Brien case 's':
214345e5710bSMark Peek if (lp->limconst != RLIMIT_CPU)
2144c80476e4SDavid E. O'Brien goto badscal;
2145c80476e4SDavid E. O'Brien limtail(cp, "seconds");
2146c80476e4SDavid E. O'Brien break;
2147c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
2148c80476e4SDavid E. O'Brien case 'G':
2149c80476e4SDavid E. O'Brien *cp = 'g';
2150c80476e4SDavid E. O'Brien /*FALLTHROUGH*/
2151c80476e4SDavid E. O'Brien case 'g':
2152c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
2153c80476e4SDavid E. O'Brien if (lp->limconst == RLIMIT_CPU)
215445e5710bSMark Peek goto badscal;
215545e5710bSMark Peek # endif /* RLIMIT_CPU */
2156c80476e4SDavid E. O'Brien limtail2(cp, "gigabytes", "gbytes");
2157c80476e4SDavid E. O'Brien f *= 1024.0 * 1024.0 * 1024.0;
215845e5710bSMark Peek break;
2159c80476e4SDavid E. O'Brien case 'M':
2160c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
2161c80476e4SDavid E. O'Brien if (lp->limconst == RLIMIT_CPU)
2162c80476e4SDavid E. O'Brien goto badscal;
2163c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
2164c80476e4SDavid E. O'Brien *cp = 'm';
2165c80476e4SDavid E. O'Brien limtail2(cp, "megabytes", "mbytes");
2166c80476e4SDavid E. O'Brien f *= 1024.0 * 1024.0;
2167b2d5d167SMark Peek break;
2168b2d5d167SMark Peek case 'k':
2169c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
217045e5710bSMark Peek if (lp->limconst == RLIMIT_CPU)
217145e5710bSMark Peek goto badscal;
2172c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
217345e5710bSMark Peek limtail2(cp, "kilobytes", "kbytes");
2174c80476e4SDavid E. O'Brien f *= 1024.0;
2175c80476e4SDavid E. O'Brien break;
2176c80476e4SDavid E. O'Brien case 'b':
2177c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
2178c80476e4SDavid E. O'Brien if (lp->limconst == RLIMIT_CPU)
2179c80476e4SDavid E. O'Brien goto badscal;
2180c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
2181c80476e4SDavid E. O'Brien limtail(cp, "blocks");
2182c80476e4SDavid E. O'Brien f *= 512.0;
2183c80476e4SDavid E. O'Brien break;
2184c80476e4SDavid E. O'Brien case 'u':
2185c80476e4SDavid E. O'Brien limtail(cp, "unlimited");
2186c80476e4SDavid E. O'Brien return ((RLIM_TYPE) RLIM_INFINITY);
2187c80476e4SDavid E. O'Brien default:
2188c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
2189c80476e4SDavid E. O'Brien badscal:
2190c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
2191c80476e4SDavid E. O'Brien stderror(ERR_NAME | ERR_SCALEF);
2192c80476e4SDavid E. O'Brien }
2193c80476e4SDavid E. O'Brien # ifdef convex
2194c80476e4SDavid E. O'Brien return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f + 0.5));
2195c80476e4SDavid E. O'Brien # else
219645e5710bSMark Peek f += 0.5;
219745e5710bSMark Peek if (f > (float) ((RLIM_TYPE) RLIM_INFINITY))
219845e5710bSMark Peek return ((RLIM_TYPE) RLIM_INFINITY);
219945e5710bSMark Peek else
220045e5710bSMark Peek return ((RLIM_TYPE) f);
220145e5710bSMark Peek # endif /* convex */
220245e5710bSMark Peek }
220345e5710bSMark Peek
220445e5710bSMark Peek static int
strtail(Char * cp,const char * str)220545e5710bSMark Peek strtail(Char *cp, const char *str)
220645e5710bSMark Peek {
220745e5710bSMark Peek while (*cp && *cp == (Char)*str)
220845e5710bSMark Peek cp++, str++;
220945e5710bSMark Peek return (*cp != '\0');
221045e5710bSMark Peek }
221145e5710bSMark Peek
221245e5710bSMark Peek static void
limtail(Char * cp,const char * str)221345e5710bSMark Peek limtail(Char *cp, const char *str)
221445e5710bSMark Peek {
221545e5710bSMark Peek if (strtail(cp, str))
221645e5710bSMark Peek stderror(ERR_BADSCALE, str);
221745e5710bSMark Peek }
221845e5710bSMark Peek
221945e5710bSMark Peek static void
limtail2(Char * cp,const char * str1,const char * str2)222045e5710bSMark Peek limtail2(Char *cp, const char *str1, const char *str2)
222145e5710bSMark Peek {
222245e5710bSMark Peek if (strtail(cp, str1) && strtail(cp, str2))
222345e5710bSMark Peek stderror(ERR_BADSCALE, str1);
222445e5710bSMark Peek }
222545e5710bSMark Peek
222645e5710bSMark Peek /*ARGSUSED*/
2227c80476e4SDavid E. O'Brien static void
plim(struct limits * lp,int hard)2228c80476e4SDavid E. O'Brien plim(struct limits *lp, int hard)
2229c80476e4SDavid E. O'Brien {
223045e5710bSMark Peek # ifdef BSDLIMIT
2231c80476e4SDavid E. O'Brien struct rlimit rlim;
223245e5710bSMark Peek # endif /* BSDLIMIT */
223345e5710bSMark Peek RLIM_TYPE limit;
223445e5710bSMark Peek int xdiv = lp->limdiv;
2235c80476e4SDavid E. O'Brien
2236c80476e4SDavid E. O'Brien xprintf("%-13.13s", lp->limname);
223745e5710bSMark Peek
223845e5710bSMark Peek # ifndef BSDLIMIT
2239c80476e4SDavid E. O'Brien limit = ulimit(lp->limconst, 0);
224045e5710bSMark Peek # ifdef aiws
2241c80476e4SDavid E. O'Brien if (lp->limconst == RLIMIT_DATA)
224245e5710bSMark Peek limit -= 0x20000000;
224345e5710bSMark Peek # endif /* aiws */
2244c80476e4SDavid E. O'Brien # else /* BSDLIMIT */
224545e5710bSMark Peek (void) getrlimit(lp->limconst, &rlim);
224645e5710bSMark Peek limit = hard ? rlim.rlim_max : rlim.rlim_cur;
2247c80476e4SDavid E. O'Brien # endif /* BSDLIMIT */
2248c80476e4SDavid E. O'Brien
2249c80476e4SDavid E. O'Brien # if !defined(BSDLIMIT) || defined(FILESIZE512)
225045e5710bSMark Peek /*
225145e5710bSMark Peek * Christos: filesize comes in 512 blocks. we divide by 2 to get 1024
2252c80476e4SDavid E. O'Brien * blocks. Note we cannot pre-multiply cause we might overflow (A/UX)
2253c80476e4SDavid E. O'Brien */
225445e5710bSMark Peek if (lp->limconst == RLIMIT_FSIZE) {
225545e5710bSMark Peek if (limit >= (RLIM_INFINITY / 512))
225645e5710bSMark Peek limit = RLIM_INFINITY;
225745e5710bSMark Peek else
225845e5710bSMark Peek xdiv = (xdiv == 1024 ? 2 : 1);
225945e5710bSMark Peek }
226045e5710bSMark Peek # endif /* !BSDLIMIT || FILESIZE512 */
226145e5710bSMark Peek
226245e5710bSMark Peek if (limit == RLIM_INFINITY)
2263c80476e4SDavid E. O'Brien xprintf("unlimited");
226445e5710bSMark Peek else
226545e5710bSMark Peek # if defined(RLIMIT_CPU) && defined(_OSD_POSIX)
226645e5710bSMark Peek if (lp->limconst == RLIMIT_CPU &&
2267c80476e4SDavid E. O'Brien (unsigned long)limit >= 0x7ffffffdUL)
226845e5710bSMark Peek xprintf("unlimited");
226945e5710bSMark Peek else
227045e5710bSMark Peek # endif
2271c80476e4SDavid E. O'Brien # ifdef RLIMIT_CPU
227223338178SMark Peek if (lp->limconst == RLIMIT_CPU)
227323338178SMark Peek psecs(limit);
227423338178SMark Peek else
2275c80476e4SDavid E. O'Brien # endif /* RLIMIT_CPU */
2276c80476e4SDavid E. O'Brien xprintf("%ld %s", (long) (limit / xdiv), lp->limscale);
2277c80476e4SDavid E. O'Brien xputchar('\n');
2278c80476e4SDavid E. O'Brien }
2279c80476e4SDavid E. O'Brien
2280c80476e4SDavid E. O'Brien /*ARGSUSED*/
228145e5710bSMark Peek void
dounlimit(Char ** v,struct command * c)2282c80476e4SDavid E. O'Brien dounlimit(Char **v, struct command *c)
2283c80476e4SDavid E. O'Brien {
228445e5710bSMark Peek struct limits *lp;
2285c80476e4SDavid E. O'Brien int lerr = 0;
2286c80476e4SDavid E. O'Brien int hard = 0;
2287c80476e4SDavid E. O'Brien int force = 0;
2288c80476e4SDavid E. O'Brien
2289c80476e4SDavid E. O'Brien USE(c);
229045e5710bSMark Peek while (*++v && **v == '-') {
229145e5710bSMark Peek Char *vp = *v;
229245e5710bSMark Peek while (*++vp)
229345e5710bSMark Peek switch (*vp) {
229445e5710bSMark Peek case 'f':
229545e5710bSMark Peek force = 1;
229645e5710bSMark Peek break;
2297c80476e4SDavid E. O'Brien case 'h':
2298c80476e4SDavid E. O'Brien hard = 1;
229945e5710bSMark Peek break;
2300c80476e4SDavid E. O'Brien default:
2301c80476e4SDavid E. O'Brien stderror(ERR_ULIMUS);
2302c80476e4SDavid E. O'Brien break;
2303c80476e4SDavid E. O'Brien }
230445e5710bSMark Peek }
230523338178SMark Peek
2306c80476e4SDavid E. O'Brien if (*v == 0) {
2307c80476e4SDavid E. O'Brien for (lp = limits; lp->limconst >= 0; lp++)
2308c80476e4SDavid E. O'Brien if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
2309c80476e4SDavid E. O'Brien lerr++;
2310c80476e4SDavid E. O'Brien if (!force && lerr)
231145e5710bSMark Peek stderror(ERR_SILENT);
2312c80476e4SDavid E. O'Brien return;
2313c80476e4SDavid E. O'Brien }
2314c80476e4SDavid E. O'Brien while (*v) {
2315c80476e4SDavid E. O'Brien lp = findlim(*v++);
2316c80476e4SDavid E. O'Brien if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0 && !force)
2317c80476e4SDavid E. O'Brien stderror(ERR_SILENT);
2318c80476e4SDavid E. O'Brien }
2319c80476e4SDavid E. O'Brien }
2320c80476e4SDavid E. O'Brien
2321c80476e4SDavid E. O'Brien static int
setlim(struct limits * lp,int hard,RLIM_TYPE limit)2322c80476e4SDavid E. O'Brien setlim(struct limits *lp, int hard, RLIM_TYPE limit)
2323c80476e4SDavid E. O'Brien {
2324c80476e4SDavid E. O'Brien # ifdef BSDLIMIT
2325c80476e4SDavid E. O'Brien struct rlimit rlim;
2326c80476e4SDavid E. O'Brien
2327c80476e4SDavid E. O'Brien (void) getrlimit(lp->limconst, &rlim);
2328c80476e4SDavid E. O'Brien
2329c80476e4SDavid E. O'Brien # ifdef FILESIZE512
2330c80476e4SDavid E. O'Brien /* Even though hpux has setrlimit(), it expects fsize in 512 byte blocks */
2331c80476e4SDavid E. O'Brien if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2332c80476e4SDavid E. O'Brien limit /= 512;
2333c80476e4SDavid E. O'Brien # endif /* FILESIZE512 */
2334c80476e4SDavid E. O'Brien if (hard)
2335c80476e4SDavid E. O'Brien rlim.rlim_max = limit;
2336c80476e4SDavid E. O'Brien else if (limit == RLIM_INFINITY && euid != 0)
2337c80476e4SDavid E. O'Brien rlim.rlim_cur = rlim.rlim_max;
2338c80476e4SDavid E. O'Brien else
2339c80476e4SDavid E. O'Brien rlim.rlim_cur = limit;
23403b6eaa7bSAndrey A. Chernov
2341c80476e4SDavid E. O'Brien if (rlim.rlim_cur > rlim.rlim_max)
2342c80476e4SDavid E. O'Brien rlim.rlim_max = rlim.rlim_cur;
2343c80476e4SDavid E. O'Brien
2344c80476e4SDavid E. O'Brien if (setrlimit(lp->limconst, &rlim) < 0) {
2345c80476e4SDavid E. O'Brien # else /* BSDLIMIT */
23463b6eaa7bSAndrey A. Chernov if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2347c80476e4SDavid E. O'Brien limit /= 512;
234845e5710bSMark Peek # ifdef aiws
2349c80476e4SDavid E. O'Brien if (lp->limconst == RLIMIT_DATA)
2350c80476e4SDavid E. O'Brien limit += 0x20000000;
2351c80476e4SDavid E. O'Brien # endif /* aiws */
235223338178SMark Peek if (ulimit(toset(lp->limconst), limit) < 0) {
235323338178SMark Peek # endif /* BSDLIMIT */
235445e5710bSMark Peek int err;
235545e5710bSMark Peek char *op, *type;
235645e5710bSMark Peek
235745e5710bSMark Peek err = errno;
235845e5710bSMark Peek op = strsave(limit == RLIM_INFINITY ? CGETS(15, 2, "remove") :
235945e5710bSMark Peek CGETS(15, 3, "set"));
236045e5710bSMark Peek cleanup_push(op, xfree);
236145e5710bSMark Peek type = strsave(hard ? CGETS(15, 4, " hard") : "");
236245e5710bSMark Peek cleanup_push(type, xfree);
236345e5710bSMark Peek xprintf(CGETS(15, 1, "%s: %s: Can't %s%s limit (%s)\n"), bname,
236445e5710bSMark Peek lp->limname, op, type, strerror(err));
236545e5710bSMark Peek cleanup_until(op);
236645e5710bSMark Peek return (-1);
236745e5710bSMark Peek }
236845e5710bSMark Peek return (0);
236945e5710bSMark Peek }
237023338178SMark Peek
237123338178SMark Peek #endif /* !HAVENOLIMIT */
237223338178SMark Peek
237323338178SMark Peek /*ARGSUSED*/
237423338178SMark Peek void
237545e5710bSMark Peek dosuspend(Char **v, struct command *c)
237623338178SMark Peek {
237723338178SMark Peek #ifdef BSDJOBS
237845e5710bSMark Peek struct sigaction old;
237923338178SMark Peek #endif /* BSDJOBS */
238023338178SMark Peek
238123338178SMark Peek USE(c);
238223338178SMark Peek USE(v);
238323338178SMark Peek
238423338178SMark Peek if (loginsh)
238523338178SMark Peek stderror(ERR_SUSPLOG);
238623338178SMark Peek untty();
238723338178SMark Peek
238823338178SMark Peek #ifdef BSDJOBS
238923338178SMark Peek sigaction(SIGTSTP, NULL, &old);
239023338178SMark Peek signal(SIGTSTP, SIG_DFL);
239123338178SMark Peek (void) kill(0, SIGTSTP);
239223338178SMark Peek /* the shell stops here */
239323338178SMark Peek sigaction(SIGTSTP, &old, NULL);
239423338178SMark Peek #else /* !BSDJOBS */
239523338178SMark Peek stderror(ERR_JOBCONTROL);
239623338178SMark Peek #endif /* BSDJOBS */
239723338178SMark Peek
239823338178SMark Peek #ifdef BSDJOBS
239923338178SMark Peek if (tpgrp != -1) {
240023338178SMark Peek if (grabpgrp(FSHTTY, opgrp) == -1)
240123338178SMark Peek stderror(ERR_SYSTEM, "tcgetpgrp", strerror(errno));
240223338178SMark Peek (void) setpgid(0, shpgrp);
240323338178SMark Peek (void) tcsetpgrp(FSHTTY, shpgrp);
240423338178SMark Peek }
240523338178SMark Peek #endif /* BSDJOBS */
240645e5710bSMark Peek (void) setdisc(FSHTTY);
240745e5710bSMark Peek }
240823338178SMark Peek
2409c80476e4SDavid E. O'Brien /* This is the dreaded EVAL built-in.
241045e5710bSMark Peek * If you don't fiddle with file descriptors, and reset didfds,
2411c80476e4SDavid E. O'Brien * this command will either ignore redirection inside or outside
2412c80476e4SDavid E. O'Brien * its arguments, e.g. eval "date >x" vs. eval "date" >x
241345e5710bSMark Peek * The stuff here seems to work, but I did it by trial and error rather
241445e5710bSMark Peek * than really knowing what was going on. If tpgrp is zero, we are
241545e5710bSMark Peek * probably a background eval, e.g. "eval date &", and we want to
24163b6eaa7bSAndrey A. Chernov * make sure that any processes we start stay in our pgrp.
24173b6eaa7bSAndrey A. Chernov * This is also the case for "time eval date" -- stay in same pgrp.
241845e5710bSMark Peek * Otherwise, under stty tostop, processes will stop in the wrong
24193b6eaa7bSAndrey A. Chernov * pgrp, with no way for the shell to get them going again. -IAN!
242045e5710bSMark Peek */
242145e5710bSMark Peek
242245e5710bSMark Peek struct doeval_state
242345e5710bSMark Peek {
242423338178SMark Peek Char **evalvec, *evalp;
242545e5710bSMark Peek int didfds;
242645e5710bSMark Peek #ifndef CLOSE_ON_EXEC
24273b6eaa7bSAndrey A. Chernov int didcch;
24283b6eaa7bSAndrey A. Chernov #endif
2429c80476e4SDavid E. O'Brien int saveIN, saveOUT, saveDIAG;
24303b6eaa7bSAndrey A. Chernov int SHIN, SHOUT, SHDIAG;
2431c80476e4SDavid E. O'Brien };
2432c80476e4SDavid E. O'Brien
2433c80476e4SDavid E. O'Brien static void
2434c80476e4SDavid E. O'Brien doeval_cleanup(void *xstate)
2435c80476e4SDavid E. O'Brien {
2436c80476e4SDavid E. O'Brien struct doeval_state *state;
243723338178SMark Peek
243823338178SMark Peek state = xstate;
243945e5710bSMark Peek evalvec = state->evalvec;
244023338178SMark Peek evalp = state->evalp;
244123338178SMark Peek doneinp = 0;
244245e5710bSMark Peek #ifndef CLOSE_ON_EXEC
244323338178SMark Peek didcch = state->didcch;
244423338178SMark Peek #endif /* CLOSE_ON_EXEC */
244523338178SMark Peek didfds = state->didfds;
244623338178SMark Peek if (state->saveIN != SHIN)
244745e5710bSMark Peek xclose(SHIN);
244845e5710bSMark Peek if (state->saveOUT != SHOUT)
244945e5710bSMark Peek xclose(SHOUT);
245045e5710bSMark Peek if (state->saveDIAG != SHDIAG)
245145e5710bSMark Peek xclose(SHDIAG);
245245e5710bSMark Peek close_on_exec(SHIN = dmove(state->saveIN, state->SHIN), 1);
245345e5710bSMark Peek close_on_exec(SHOUT = dmove(state->saveOUT, state->SHOUT), 1);
245445e5710bSMark Peek close_on_exec(SHDIAG = dmove(state->saveDIAG, state->SHDIAG), 1);
245545e5710bSMark Peek if (didfds) {
245645e5710bSMark Peek close_on_exec(dcopy(SHIN, 0), 1);
245745e5710bSMark Peek close_on_exec(dcopy(SHOUT, 1), 1);
245845e5710bSMark Peek close_on_exec(dcopy(SHDIAG, 2), 1);
245945e5710bSMark Peek }
246023338178SMark Peek }
246123338178SMark Peek
2462 static Char **Ggv;
2463 /*ARGSUSED*/
2464 void
2465 doeval(Char **v, struct command *c)
2466 {
2467 struct doeval_state state;
2468 int gflag, my_reenter;
2469 Char **gv;
2470 jmp_buf_t osetexit;
2471
2472 USE(c);
2473 v++;
2474 if (*v == 0)
2475 return;
2476 gflag = tglob(v);
2477 if (gflag) {
2478 gv = v = globall(v, gflag);
2479 if (v == 0)
2480 stderror(ERR_NOMATCH);
2481 cleanup_push(gv, blk_cleanup);
2482 v = copyblk(v);
2483 }
2484 else {
2485 gv = NULL;
2486 v = copyblk(v);
2487 trim(v);
2488 }
2489
2490 Ggv = gv;
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 */
2497 state.SHIN = SHIN;
2498 state.SHOUT = SHOUT;
2499 state.SHDIAG = SHDIAG;
2500
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);
2504
2505 cleanup_push(&state, doeval_cleanup);
2506
2507 getexit(osetexit);
2508
2509 /* PWP: setjmp/longjmp bugfix for optimizing compilers */
2510 #ifdef cray
2511 my_reenter = 1; /* assume non-zero return val */
2512 if (setexit() == 0) {
2513 my_reenter = 0; /* Oh well, we were wrong */
2514 #else /* !cray */
2515 if ((my_reenter = setexit()) == 0) {
2516 #endif /* cray */
2517 evalvec = v;
2518 evalp = 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
2523 didcch = 0;
2524 #endif /* CLOSE_ON_EXEC */
2525 didfds = 0;
2526 gv = Ggv;
2527 process(0);
2528 Ggv = gv;
2529 }
2530
2531 if (my_reenter == 0) {
2532 cleanup_until(&state);
2533 if (Ggv)
2534 cleanup_until(Ggv);
2535 }
2536
2537 resexit(osetexit);
2538 if (my_reenter)
2539 stderror(ERR_SILENT);
2540 }
2541
2542 /*************************************************************************/
2543 /* print list of builtin commands */
2544
2545 static void
2546 lbuffed_cleanup (void *dummy)
2547 {
2548 USE(dummy);
2549 lbuffed = 1;
2550 }
2551
2552 /*ARGSUSED*/
2553 void
2554 dobuiltins(Char **v, struct command *c)
2555 {
2556 /* would use print_by_column() in tw.parse.c but that assumes
2557 * we have an array of Char * to pass.. (sg)
2558 */
2559 const struct biltins *b;
2560 int row, col, columns, rows;
2561 unsigned int w, maxwidth;
2562
2563 USE(c);
2564 USE(v);
2565 lbuffed = 0; /* turn off line buffering */
2566 cleanup_push(&lbuffed, lbuffed_cleanup);
2567
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 */
2572
2573 columns = (TermH + 1) / maxwidth; /* PWP: terminal size change */
2574 if (!columns)
2575 columns = 1;
2576 rows = (nbfunc + (columns - 1)) / columns;
2577
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++)
2585 xputchar(' ');
2586 ++b;
2587 }
2588 }
2589 if (row < (rows - 1)) {
2590 if (Tty_raw_mode)
2591 xputchar('\r');
2592 xputchar('\n');
2593 }
2594 }
2595 #ifdef WINNT_NATIVE
2596 nt_print_builtins(maxwidth);
2597 #else
2598 if (Tty_raw_mode)
2599 xputchar('\r');
2600 xputchar('\n');
2601 #endif /* WINNT_NATIVE */
2602
2603 cleanup_until(&lbuffed); /* turn back on line buffering */
2604 flush();
2605 }
2606
2607 #ifdef NLS_CATALOGS
2608 char *
2609 xcatgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2610 {
2611 char *res;
2612
2613 errno = 0;
2614 while ((res = catgets(ctd, set_id, msg_id, s)) == s && errno == EINTR) {
2615 handle_pending_signals();
2616 errno = 0;
2617 }
2618 return res;
2619 }
2620
2621
2622 # if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2623 char *
2624 iconv_catgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2625 {
2626 static char *buf = NULL;
2627 static size_t buf_size = 0;
2628
2629 char *orig, *dest, *p;
2630 ICONV_CONST char *src;
2631 size_t src_size, dest_size;
2632
2633 orig = xcatgets(ctd, set_id, msg_id, s);
2634 if (catgets_iconv == (iconv_t)-1 || orig == s)
2635 return orig;
2636 src = orig;
2637 src_size = strlen(src) + 1;
2638 if (buf == NULL && (buf = xmalloc(buf_size = src_size + 32)) == NULL)
2639 return orig;
2640 dest = buf;
2641 while (src_size != 0) {
2642 dest_size = buf + buf_size - dest;
2643 if (iconv(catgets_iconv, &src, &src_size, &dest, &dest_size)
2644 == (size_t)-1) {
2645 switch (errno) {
2646 case E2BIG:
2647 if ((p = xrealloc(buf, buf_size * 2)) == NULL)
2648 return orig;
2649 buf_size *= 2;
2650 dest = p + (dest - buf);
2651 buf = p;
2652 break;
2653
2654 case EILSEQ: case EINVAL: default:
2655 return orig;
2656 }
2657 }
2658 }
2659 return buf;
2660 }
2661 # endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2662 #endif /* NLS_CATALOGS */
2663
2664 void
2665 nlsinit(void)
2666 {
2667 #ifdef NLS_CATALOGS
2668 static const char default_catalog[] = "tcsh";
2669
2670 char *catalog = (char *)(intptr_t)default_catalog;
2671
2672 if (adrof(STRcatalog) != NULL)
2673 catalog = xasprintf("tcsh.%s", short2str(varval(STRcatalog)));
2674 #ifdef NL_CAT_LOCALE /* POSIX-compliant. */
2675 /*
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.
2678 */
2679 catd = catopen(catalog, tgetenv(STRLC_MESSAGES) ? NL_CAT_LOCALE : 0);
2680 #else /* pre-POSIX */
2681 # ifndef MCLoadBySet
2682 # define MCLoadBySet 0
2683 # endif
2684 catd = catopen(catalog, MCLoadBySet);
2685 #endif
2686 if (catalog != default_catalog)
2687 xfree(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 */
2694 #ifdef WINNT_NATIVE
2695 nls_dll_init();
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 */
2702 }
2703
2704 void
2705 nlsclose(void)
2706 {
2707 #ifdef NLS_CATALOGS
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;
2712 }
2713 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2714 if (catd != (nl_catd)-1) {
2715 /*
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:
2719 * Gerhard Niklasch
2720 */
2721 nl_catd oldcatd = catd;
2722 catd = (nl_catd)-1;
2723 while (catclose(oldcatd) == -1 && errno == EINTR)
2724 handle_pending_signals();
2725 }
2726 #endif /* NLS_CATALOGS */
2727 }
2728
2729 int
2730 getYN(const char *prompt)
2731 {
2732 int doit;
2733 char c;
2734
2735 xprintf("%s", prompt);
2736 flush();
2737 (void) force_read(SHIN, &c, sizeof(c));
2738 /*
2739 * Perhaps we should use the yesexpr from the
2740 * actual locale
2741 */
2742 doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
2743 while (c != '\n' && force_read(SHIN, &c, sizeof(c)) == sizeof(c))
2744 continue;
2745 return doit;
2746 }
2747