parser.c revision 1.17 1 1.1 cgd /*-
2 1.11 jtc * Copyright (c) 1991, 1993
3 1.11 jtc * The Regents of the University of California. All rights reserved.
4 1.1 cgd *
5 1.1 cgd * This code is derived from software contributed to Berkeley by
6 1.1 cgd * Kenneth Almquist.
7 1.1 cgd *
8 1.1 cgd * Redistribution and use in source and binary forms, with or without
9 1.1 cgd * modification, are permitted provided that the following conditions
10 1.1 cgd * are met:
11 1.1 cgd * 1. Redistributions of source code must retain the above copyright
12 1.1 cgd * notice, this list of conditions and the following disclaimer.
13 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
14 1.1 cgd * notice, this list of conditions and the following disclaimer in the
15 1.1 cgd * documentation and/or other materials provided with the distribution.
16 1.1 cgd * 3. All advertising materials mentioning features or use of this software
17 1.1 cgd * must display the following acknowledgement:
18 1.1 cgd * This product includes software developed by the University of
19 1.1 cgd * California, Berkeley and its contributors.
20 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
21 1.1 cgd * may be used to endorse or promote products derived from this software
22 1.1 cgd * without specific prior written permission.
23 1.1 cgd *
24 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 1.1 cgd * SUCH DAMAGE.
35 1.1 cgd */
36 1.1 cgd
37 1.1 cgd #ifndef lint
38 1.17 mycroft /*static char sccsid[] = "from: @(#)parser.c 8.1 (Berkeley) 5/31/93";*/
39 1.17 mycroft static char *rcsid = "$Id: parser.c,v 1.17 1994/06/11 16:12:28 mycroft Exp $";
40 1.1 cgd #endif /* not lint */
41 1.1 cgd
42 1.1 cgd #include "shell.h"
43 1.1 cgd #include "parser.h"
44 1.1 cgd #include "nodes.h"
45 1.1 cgd #include "expand.h" /* defines rmescapes() */
46 1.1 cgd #include "redir.h" /* defines copyfd() */
47 1.1 cgd #include "syntax.h"
48 1.1 cgd #include "options.h"
49 1.1 cgd #include "input.h"
50 1.1 cgd #include "output.h"
51 1.1 cgd #include "var.h"
52 1.1 cgd #include "error.h"
53 1.1 cgd #include "memalloc.h"
54 1.1 cgd #include "mystring.h"
55 1.11 jtc #include "alias.h"
56 1.14 cgd #ifndef NO_HISTORY
57 1.11 jtc #include "myhistedit.h"
58 1.14 cgd #endif
59 1.1 cgd
60 1.1 cgd /*
61 1.1 cgd * Shell command parser.
62 1.1 cgd */
63 1.1 cgd
64 1.1 cgd #define EOFMARKLEN 79
65 1.1 cgd
66 1.1 cgd /* values returned by readtoken */
67 1.1 cgd #include "token.def"
68 1.1 cgd
69 1.1 cgd
70 1.1 cgd
71 1.1 cgd struct heredoc {
72 1.1 cgd struct heredoc *next; /* next here document in list */
73 1.1 cgd union node *here; /* redirection node */
74 1.1 cgd char *eofmark; /* string indicating end of input */
75 1.1 cgd int striptabs; /* if set, strip leading tabs */
76 1.1 cgd };
77 1.1 cgd
78 1.1 cgd
79 1.1 cgd
80 1.1 cgd struct heredoc *heredoclist; /* list of here documents to read */
81 1.1 cgd int parsebackquote; /* nonzero if we are inside backquotes */
82 1.1 cgd int doprompt; /* if set, prompt the user */
83 1.1 cgd int needprompt; /* true if interactive and at start of line */
84 1.1 cgd int lasttoken; /* last token read */
85 1.1 cgd MKINIT int tokpushback; /* last token pushed back */
86 1.1 cgd char *wordtext; /* text of last word returned by readtoken */
87 1.11 jtc MKINIT int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
88 1.1 cgd struct nodelist *backquotelist;
89 1.1 cgd union node *redirnode;
90 1.1 cgd struct heredoc *heredoc;
91 1.1 cgd int quoteflag; /* set if (part of) last token was quoted */
92 1.1 cgd int startlinno; /* line # where last token started */
93 1.1 cgd
94 1.1 cgd
95 1.1 cgd #define GDB_HACK 1 /* avoid local declarations which gdb can't handle */
96 1.1 cgd #ifdef GDB_HACK
97 1.1 cgd static const char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'};
98 1.1 cgd static const char types[] = "}-+?=";
99 1.1 cgd #endif
100 1.1 cgd
101 1.1 cgd
102 1.1 cgd STATIC union node *list __P((int));
103 1.1 cgd STATIC union node *andor __P((void));
104 1.1 cgd STATIC union node *pipeline __P((void));
105 1.1 cgd STATIC union node *command __P((void));
106 1.5 sef STATIC union node *simplecmd __P((union node **, union node *));
107 1.1 cgd STATIC void parsefname __P((void));
108 1.1 cgd STATIC void parseheredoc __P((void));
109 1.1 cgd STATIC int readtoken __P((void));
110 1.1 cgd STATIC int readtoken1 __P((int, char const *, char *, int));
111 1.1 cgd STATIC void attyline __P((void));
112 1.1 cgd STATIC int noexpand __P((char *));
113 1.1 cgd STATIC void synexpect __P((int));
114 1.1 cgd STATIC void synerror __P((char *));
115 1.11 jtc STATIC void setprompt __P((int));
116 1.1 cgd
117 1.1 cgd /*
118 1.1 cgd * Read and parse a command. Returns NEOF on end of file. (NULL is a
119 1.1 cgd * valid parse tree indicating a blank line.)
120 1.1 cgd */
121 1.1 cgd
122 1.1 cgd union node *
123 1.1 cgd parsecmd(interact) {
124 1.1 cgd int t;
125 1.1 cgd
126 1.1 cgd doprompt = interact;
127 1.1 cgd if (doprompt)
128 1.11 jtc setprompt(1);
129 1.11 jtc else
130 1.11 jtc setprompt(0);
131 1.1 cgd needprompt = 0;
132 1.11 jtc t = readtoken();
133 1.11 jtc if (t == TEOF)
134 1.1 cgd return NEOF;
135 1.1 cgd if (t == TNL)
136 1.1 cgd return NULL;
137 1.1 cgd tokpushback++;
138 1.1 cgd return list(1);
139 1.1 cgd }
140 1.1 cgd
141 1.1 cgd
142 1.1 cgd STATIC union node *
143 1.1 cgd list(nlflag) {
144 1.1 cgd union node *n1, *n2, *n3;
145 1.12 jtc int tok;
146 1.1 cgd
147 1.1 cgd checkkwd = 2;
148 1.1 cgd if (nlflag == 0 && tokendlist[peektoken()])
149 1.1 cgd return NULL;
150 1.12 jtc n1 = NULL;
151 1.1 cgd for (;;) {
152 1.12 jtc n2 = andor();
153 1.12 jtc tok = readtoken();
154 1.12 jtc if (tok == TBACKGND) {
155 1.12 jtc if (n2->type == NCMD || n2->type == NPIPE) {
156 1.12 jtc n2->ncmd.backgnd = 1;
157 1.12 jtc } else if (n2->type == NREDIR) {
158 1.12 jtc n2->type = NBACKGND;
159 1.1 cgd } else {
160 1.1 cgd n3 = (union node *)stalloc(sizeof (struct nredir));
161 1.1 cgd n3->type = NBACKGND;
162 1.12 jtc n3->nredir.n = n2;
163 1.1 cgd n3->nredir.redirect = NULL;
164 1.12 jtc n2 = n3;
165 1.1 cgd }
166 1.12 jtc }
167 1.12 jtc if (n1 == NULL) {
168 1.12 jtc n1 = n2;
169 1.12 jtc }
170 1.12 jtc else {
171 1.12 jtc n3 = (union node *)stalloc(sizeof (struct nbinary));
172 1.12 jtc n3->type = NSEMI;
173 1.12 jtc n3->nbinary.ch1 = n1;
174 1.12 jtc n3->nbinary.ch2 = n2;
175 1.12 jtc n1 = n3;
176 1.12 jtc }
177 1.12 jtc switch (tok) {
178 1.12 jtc case TBACKGND:
179 1.12 jtc case TSEMI:
180 1.12 jtc tok = readtoken();
181 1.12 jtc /* fall through */
182 1.1 cgd case TNL:
183 1.12 jtc if (tok == TNL) {
184 1.1 cgd parseheredoc();
185 1.1 cgd if (nlflag)
186 1.1 cgd return n1;
187 1.1 cgd } else {
188 1.1 cgd tokpushback++;
189 1.1 cgd }
190 1.1 cgd checkkwd = 2;
191 1.1 cgd if (tokendlist[peektoken()])
192 1.1 cgd return n1;
193 1.1 cgd break;
194 1.1 cgd case TEOF:
195 1.1 cgd if (heredoclist)
196 1.1 cgd parseheredoc();
197 1.1 cgd else
198 1.1 cgd pungetc(); /* push back EOF on input */
199 1.1 cgd return n1;
200 1.1 cgd default:
201 1.1 cgd if (nlflag)
202 1.1 cgd synexpect(-1);
203 1.1 cgd tokpushback++;
204 1.1 cgd return n1;
205 1.1 cgd }
206 1.1 cgd }
207 1.1 cgd }
208 1.1 cgd
209 1.1 cgd
210 1.1 cgd
211 1.1 cgd STATIC union node *
212 1.1 cgd andor() {
213 1.1 cgd union node *n1, *n2, *n3;
214 1.1 cgd int t;
215 1.1 cgd
216 1.1 cgd n1 = pipeline();
217 1.1 cgd for (;;) {
218 1.1 cgd if ((t = readtoken()) == TAND) {
219 1.1 cgd t = NAND;
220 1.1 cgd } else if (t == TOR) {
221 1.1 cgd t = NOR;
222 1.1 cgd } else {
223 1.1 cgd tokpushback++;
224 1.1 cgd return n1;
225 1.1 cgd }
226 1.1 cgd n2 = pipeline();
227 1.1 cgd n3 = (union node *)stalloc(sizeof (struct nbinary));
228 1.1 cgd n3->type = t;
229 1.1 cgd n3->nbinary.ch1 = n1;
230 1.1 cgd n3->nbinary.ch2 = n2;
231 1.1 cgd n1 = n3;
232 1.1 cgd }
233 1.1 cgd }
234 1.1 cgd
235 1.1 cgd
236 1.1 cgd
237 1.1 cgd STATIC union node *
238 1.1 cgd pipeline() {
239 1.11 jtc union node *n1, *pipenode, *notnode;
240 1.1 cgd struct nodelist *lp, *prev;
241 1.11 jtc int negate = 0;
242 1.1 cgd
243 1.11 jtc TRACE(("pipeline: entered\n"));
244 1.11 jtc while (readtoken() == TNOT) {
245 1.11 jtc TRACE(("pipeline: TNOT recognized\n"));
246 1.11 jtc negate = !negate;
247 1.11 jtc }
248 1.11 jtc tokpushback++;
249 1.1 cgd n1 = command();
250 1.1 cgd if (readtoken() == TPIPE) {
251 1.1 cgd pipenode = (union node *)stalloc(sizeof (struct npipe));
252 1.1 cgd pipenode->type = NPIPE;
253 1.1 cgd pipenode->npipe.backgnd = 0;
254 1.1 cgd lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
255 1.1 cgd pipenode->npipe.cmdlist = lp;
256 1.1 cgd lp->n = n1;
257 1.1 cgd do {
258 1.1 cgd prev = lp;
259 1.1 cgd lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
260 1.1 cgd lp->n = command();
261 1.1 cgd prev->next = lp;
262 1.1 cgd } while (readtoken() == TPIPE);
263 1.1 cgd lp->next = NULL;
264 1.1 cgd n1 = pipenode;
265 1.1 cgd }
266 1.1 cgd tokpushback++;
267 1.11 jtc if (negate) {
268 1.11 jtc notnode = (union node *)stalloc(sizeof (struct nnot));
269 1.11 jtc notnode->type = NNOT;
270 1.11 jtc notnode->nnot.com = n1;
271 1.11 jtc n1 = notnode;
272 1.11 jtc }
273 1.1 cgd return n1;
274 1.1 cgd }
275 1.1 cgd
276 1.1 cgd
277 1.1 cgd
278 1.1 cgd STATIC union node *
279 1.1 cgd command() {
280 1.1 cgd union node *n1, *n2;
281 1.1 cgd union node *ap, **app;
282 1.1 cgd union node *cp, **cpp;
283 1.1 cgd union node *redir, **rpp;
284 1.1 cgd int t;
285 1.1 cgd
286 1.1 cgd checkkwd = 2;
287 1.5 sef redir = 0;
288 1.5 sef rpp = &redir;
289 1.5 sef /* Check for redirection which may precede command */
290 1.5 sef while (readtoken() == TREDIR) {
291 1.5 sef *rpp = n2 = redirnode;
292 1.5 sef rpp = &n2->nfile.next;
293 1.5 sef parsefname();
294 1.5 sef }
295 1.5 sef tokpushback++;
296 1.5 sef
297 1.1 cgd switch (readtoken()) {
298 1.1 cgd case TIF:
299 1.1 cgd n1 = (union node *)stalloc(sizeof (struct nif));
300 1.1 cgd n1->type = NIF;
301 1.1 cgd n1->nif.test = list(0);
302 1.1 cgd if (readtoken() != TTHEN)
303 1.1 cgd synexpect(TTHEN);
304 1.1 cgd n1->nif.ifpart = list(0);
305 1.1 cgd n2 = n1;
306 1.1 cgd while (readtoken() == TELIF) {
307 1.1 cgd n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
308 1.1 cgd n2 = n2->nif.elsepart;
309 1.1 cgd n2->type = NIF;
310 1.1 cgd n2->nif.test = list(0);
311 1.1 cgd if (readtoken() != TTHEN)
312 1.1 cgd synexpect(TTHEN);
313 1.1 cgd n2->nif.ifpart = list(0);
314 1.1 cgd }
315 1.1 cgd if (lasttoken == TELSE)
316 1.1 cgd n2->nif.elsepart = list(0);
317 1.1 cgd else {
318 1.1 cgd n2->nif.elsepart = NULL;
319 1.1 cgd tokpushback++;
320 1.1 cgd }
321 1.1 cgd if (readtoken() != TFI)
322 1.1 cgd synexpect(TFI);
323 1.1 cgd checkkwd = 1;
324 1.1 cgd break;
325 1.1 cgd case TWHILE:
326 1.1 cgd case TUNTIL: {
327 1.1 cgd int got;
328 1.1 cgd n1 = (union node *)stalloc(sizeof (struct nbinary));
329 1.1 cgd n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
330 1.1 cgd n1->nbinary.ch1 = list(0);
331 1.1 cgd if ((got=readtoken()) != TDO) {
332 1.1 cgd TRACE(("expecting DO got %s %s\n", tokname[got], got == TWORD ? wordtext : ""));
333 1.1 cgd synexpect(TDO);
334 1.1 cgd }
335 1.1 cgd n1->nbinary.ch2 = list(0);
336 1.1 cgd if (readtoken() != TDONE)
337 1.1 cgd synexpect(TDONE);
338 1.1 cgd checkkwd = 1;
339 1.1 cgd break;
340 1.1 cgd }
341 1.1 cgd case TFOR:
342 1.1 cgd if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
343 1.1 cgd synerror("Bad for loop variable");
344 1.1 cgd n1 = (union node *)stalloc(sizeof (struct nfor));
345 1.1 cgd n1->type = NFOR;
346 1.1 cgd n1->nfor.var = wordtext;
347 1.1 cgd if (readtoken() == TWORD && ! quoteflag && equal(wordtext, "in")) {
348 1.1 cgd app = ≈
349 1.1 cgd while (readtoken() == TWORD) {
350 1.1 cgd n2 = (union node *)stalloc(sizeof (struct narg));
351 1.1 cgd n2->type = NARG;
352 1.1 cgd n2->narg.text = wordtext;
353 1.1 cgd n2->narg.backquote = backquotelist;
354 1.1 cgd *app = n2;
355 1.1 cgd app = &n2->narg.next;
356 1.1 cgd }
357 1.1 cgd *app = NULL;
358 1.1 cgd n1->nfor.args = ap;
359 1.5 sef if (lasttoken != TNL && lasttoken != TSEMI)
360 1.5 sef synexpect(-1);
361 1.1 cgd } else {
362 1.1 cgd #ifndef GDB_HACK
363 1.1 cgd static const char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE,
364 1.1 cgd '@', '=', '\0'};
365 1.1 cgd #endif
366 1.1 cgd n2 = (union node *)stalloc(sizeof (struct narg));
367 1.1 cgd n2->type = NARG;
368 1.1 cgd n2->narg.text = (char *)argvars;
369 1.1 cgd n2->narg.backquote = NULL;
370 1.1 cgd n2->narg.next = NULL;
371 1.1 cgd n1->nfor.args = n2;
372 1.11 jtc /*
373 1.11 jtc * Newline or semicolon here is optional (but note
374 1.11 jtc * that the original Bourne shell only allowed NL).
375 1.11 jtc */
376 1.11 jtc if (lasttoken != TNL && lasttoken != TSEMI)
377 1.11 jtc tokpushback++;
378 1.1 cgd }
379 1.1 cgd checkkwd = 2;
380 1.1 cgd if ((t = readtoken()) == TDO)
381 1.1 cgd t = TDONE;
382 1.1 cgd else if (t == TBEGIN)
383 1.1 cgd t = TEND;
384 1.1 cgd else
385 1.1 cgd synexpect(-1);
386 1.1 cgd n1->nfor.body = list(0);
387 1.1 cgd if (readtoken() != t)
388 1.1 cgd synexpect(t);
389 1.1 cgd checkkwd = 1;
390 1.1 cgd break;
391 1.1 cgd case TCASE:
392 1.1 cgd n1 = (union node *)stalloc(sizeof (struct ncase));
393 1.1 cgd n1->type = NCASE;
394 1.1 cgd if (readtoken() != TWORD)
395 1.1 cgd synexpect(TWORD);
396 1.1 cgd n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
397 1.1 cgd n2->type = NARG;
398 1.1 cgd n2->narg.text = wordtext;
399 1.1 cgd n2->narg.backquote = backquotelist;
400 1.1 cgd n2->narg.next = NULL;
401 1.1 cgd while (readtoken() == TNL);
402 1.1 cgd if (lasttoken != TWORD || ! equal(wordtext, "in"))
403 1.1 cgd synerror("expecting \"in\"");
404 1.1 cgd cpp = &n1->ncase.cases;
405 1.15 jtc checkkwd = 2, readtoken();
406 1.15 jtc do {
407 1.1 cgd *cpp = cp = (union node *)stalloc(sizeof (struct nclist));
408 1.1 cgd cp->type = NCLIST;
409 1.1 cgd app = &cp->nclist.pattern;
410 1.1 cgd for (;;) {
411 1.1 cgd *app = ap = (union node *)stalloc(sizeof (struct narg));
412 1.1 cgd ap->type = NARG;
413 1.1 cgd ap->narg.text = wordtext;
414 1.1 cgd ap->narg.backquote = backquotelist;
415 1.15 jtc if (checkkwd = 2, readtoken() != TPIPE)
416 1.1 cgd break;
417 1.1 cgd app = &ap->narg.next;
418 1.16 jtc readtoken();
419 1.1 cgd }
420 1.1 cgd ap->narg.next = NULL;
421 1.1 cgd if (lasttoken != TRP)
422 1.1 cgd synexpect(TRP);
423 1.1 cgd cp->nclist.body = list(0);
424 1.15 jtc
425 1.15 jtc checkkwd = 2;
426 1.15 jtc if ((t = readtoken()) != TESAC) {
427 1.15 jtc if (t != TENDCASE)
428 1.15 jtc synexpect(TENDCASE);
429 1.15 jtc else
430 1.15 jtc checkkwd = 2, readtoken();
431 1.15 jtc }
432 1.1 cgd cpp = &cp->nclist.next;
433 1.15 jtc } while(lasttoken != TESAC);
434 1.1 cgd *cpp = NULL;
435 1.1 cgd checkkwd = 1;
436 1.1 cgd break;
437 1.1 cgd case TLP:
438 1.1 cgd n1 = (union node *)stalloc(sizeof (struct nredir));
439 1.1 cgd n1->type = NSUBSHELL;
440 1.1 cgd n1->nredir.n = list(0);
441 1.1 cgd n1->nredir.redirect = NULL;
442 1.1 cgd if (readtoken() != TRP)
443 1.1 cgd synexpect(TRP);
444 1.1 cgd checkkwd = 1;
445 1.1 cgd break;
446 1.1 cgd case TBEGIN:
447 1.1 cgd n1 = list(0);
448 1.1 cgd if (readtoken() != TEND)
449 1.1 cgd synexpect(TEND);
450 1.1 cgd checkkwd = 1;
451 1.1 cgd break;
452 1.5 sef /* Handle an empty command like other simple commands. */
453 1.5 sef case TNL:
454 1.1 cgd case TWORD:
455 1.1 cgd tokpushback++;
456 1.5 sef return simplecmd(rpp, redir);
457 1.1 cgd default:
458 1.1 cgd synexpect(-1);
459 1.1 cgd }
460 1.1 cgd
461 1.1 cgd /* Now check for redirection which may follow command */
462 1.1 cgd while (readtoken() == TREDIR) {
463 1.1 cgd *rpp = n2 = redirnode;
464 1.1 cgd rpp = &n2->nfile.next;
465 1.1 cgd parsefname();
466 1.1 cgd }
467 1.1 cgd tokpushback++;
468 1.1 cgd *rpp = NULL;
469 1.1 cgd if (redir) {
470 1.1 cgd if (n1->type != NSUBSHELL) {
471 1.1 cgd n2 = (union node *)stalloc(sizeof (struct nredir));
472 1.1 cgd n2->type = NREDIR;
473 1.1 cgd n2->nredir.n = n1;
474 1.1 cgd n1 = n2;
475 1.1 cgd }
476 1.1 cgd n1->nredir.redirect = redir;
477 1.1 cgd }
478 1.1 cgd return n1;
479 1.1 cgd }
480 1.1 cgd
481 1.1 cgd
482 1.1 cgd STATIC union node *
483 1.11 jtc simplecmd(rpp, redir)
484 1.5 sef union node **rpp, *redir;
485 1.5 sef {
486 1.1 cgd union node *args, **app;
487 1.5 sef union node **orig_rpp = rpp;
488 1.1 cgd union node *n;
489 1.1 cgd
490 1.11 jtc /* If we don't have any redirections already, then we must reset */
491 1.11 jtc /* rpp to be the address of the local redir variable. */
492 1.5 sef if (redir == 0)
493 1.5 sef rpp = &redir;
494 1.5 sef
495 1.1 cgd args = NULL;
496 1.1 cgd app = &args;
497 1.11 jtc /*
498 1.11 jtc * We save the incoming value, because we need this for shell
499 1.11 jtc * functions. There can not be a redirect or an argument between
500 1.11 jtc * the function name and the open parenthesis.
501 1.11 jtc */
502 1.5 sef orig_rpp = rpp;
503 1.11 jtc
504 1.1 cgd for (;;) {
505 1.1 cgd if (readtoken() == TWORD) {
506 1.1 cgd n = (union node *)stalloc(sizeof (struct narg));
507 1.1 cgd n->type = NARG;
508 1.1 cgd n->narg.text = wordtext;
509 1.1 cgd n->narg.backquote = backquotelist;
510 1.1 cgd *app = n;
511 1.1 cgd app = &n->narg.next;
512 1.1 cgd } else if (lasttoken == TREDIR) {
513 1.1 cgd *rpp = n = redirnode;
514 1.1 cgd rpp = &n->nfile.next;
515 1.1 cgd parsefname(); /* read name of redirection file */
516 1.1 cgd } else if (lasttoken == TLP && app == &args->narg.next
517 1.5 sef && rpp == orig_rpp) {
518 1.1 cgd /* We have a function */
519 1.1 cgd if (readtoken() != TRP)
520 1.1 cgd synexpect(TRP);
521 1.1 cgd #ifdef notdef
522 1.1 cgd if (! goodname(n->narg.text))
523 1.1 cgd synerror("Bad function name");
524 1.1 cgd #endif
525 1.1 cgd n->type = NDEFUN;
526 1.1 cgd n->narg.next = command();
527 1.1 cgd return n;
528 1.1 cgd } else {
529 1.1 cgd tokpushback++;
530 1.1 cgd break;
531 1.1 cgd }
532 1.1 cgd }
533 1.1 cgd *app = NULL;
534 1.1 cgd *rpp = NULL;
535 1.1 cgd n = (union node *)stalloc(sizeof (struct ncmd));
536 1.1 cgd n->type = NCMD;
537 1.1 cgd n->ncmd.backgnd = 0;
538 1.1 cgd n->ncmd.args = args;
539 1.1 cgd n->ncmd.redirect = redir;
540 1.1 cgd return n;
541 1.1 cgd }
542 1.1 cgd
543 1.1 cgd
544 1.1 cgd STATIC void
545 1.1 cgd parsefname() {
546 1.1 cgd union node *n = redirnode;
547 1.1 cgd
548 1.1 cgd if (readtoken() != TWORD)
549 1.1 cgd synexpect(-1);
550 1.1 cgd if (n->type == NHERE) {
551 1.1 cgd struct heredoc *here = heredoc;
552 1.1 cgd struct heredoc *p;
553 1.1 cgd int i;
554 1.1 cgd
555 1.1 cgd if (quoteflag == 0)
556 1.1 cgd n->type = NXHERE;
557 1.1 cgd TRACE(("Here document %d\n", n->type));
558 1.1 cgd if (here->striptabs) {
559 1.1 cgd while (*wordtext == '\t')
560 1.1 cgd wordtext++;
561 1.1 cgd }
562 1.1 cgd if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
563 1.1 cgd synerror("Illegal eof marker for << redirection");
564 1.1 cgd rmescapes(wordtext);
565 1.1 cgd here->eofmark = wordtext;
566 1.1 cgd here->next = NULL;
567 1.1 cgd if (heredoclist == NULL)
568 1.1 cgd heredoclist = here;
569 1.1 cgd else {
570 1.1 cgd for (p = heredoclist ; p->next ; p = p->next);
571 1.1 cgd p->next = here;
572 1.1 cgd }
573 1.1 cgd } else if (n->type == NTOFD || n->type == NFROMFD) {
574 1.1 cgd if (is_digit(wordtext[0]))
575 1.1 cgd n->ndup.dupfd = digit_val(wordtext[0]);
576 1.1 cgd else if (wordtext[0] == '-')
577 1.1 cgd n->ndup.dupfd = -1;
578 1.1 cgd else
579 1.1 cgd goto bad;
580 1.1 cgd if (wordtext[1] != '\0') {
581 1.1 cgd bad:
582 1.1 cgd synerror("Bad fd number");
583 1.1 cgd }
584 1.1 cgd } else {
585 1.1 cgd n->nfile.fname = (union node *)stalloc(sizeof (struct narg));
586 1.1 cgd n = n->nfile.fname;
587 1.1 cgd n->type = NARG;
588 1.1 cgd n->narg.next = NULL;
589 1.1 cgd n->narg.text = wordtext;
590 1.1 cgd n->narg.backquote = backquotelist;
591 1.1 cgd }
592 1.1 cgd }
593 1.1 cgd
594 1.1 cgd
595 1.1 cgd /*
596 1.1 cgd * Input any here documents.
597 1.1 cgd */
598 1.1 cgd
599 1.1 cgd STATIC void
600 1.1 cgd parseheredoc() {
601 1.1 cgd struct heredoc *here;
602 1.1 cgd union node *n;
603 1.1 cgd
604 1.1 cgd while (heredoclist) {
605 1.1 cgd here = heredoclist;
606 1.1 cgd heredoclist = here->next;
607 1.1 cgd if (needprompt) {
608 1.11 jtc setprompt(2);
609 1.1 cgd needprompt = 0;
610 1.1 cgd }
611 1.1 cgd readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
612 1.1 cgd here->eofmark, here->striptabs);
613 1.1 cgd n = (union node *)stalloc(sizeof (struct narg));
614 1.1 cgd n->narg.type = NARG;
615 1.1 cgd n->narg.next = NULL;
616 1.1 cgd n->narg.text = wordtext;
617 1.1 cgd n->narg.backquote = backquotelist;
618 1.1 cgd here->here->nhere.doc = n;
619 1.1 cgd }
620 1.1 cgd }
621 1.1 cgd
622 1.1 cgd STATIC int
623 1.1 cgd peektoken() {
624 1.1 cgd int t;
625 1.1 cgd
626 1.1 cgd t = readtoken();
627 1.1 cgd tokpushback++;
628 1.1 cgd return (t);
629 1.1 cgd }
630 1.1 cgd
631 1.1 cgd STATIC int xxreadtoken();
632 1.1 cgd
633 1.1 cgd STATIC int
634 1.1 cgd readtoken() {
635 1.1 cgd int t;
636 1.11 jtc int savecheckkwd = checkkwd;
637 1.11 jtc struct alias *ap;
638 1.1 cgd #ifdef DEBUG
639 1.1 cgd int alreadyseen = tokpushback;
640 1.1 cgd #endif
641 1.1 cgd
642 1.11 jtc top:
643 1.1 cgd t = xxreadtoken();
644 1.1 cgd
645 1.1 cgd if (checkkwd) {
646 1.1 cgd /*
647 1.1 cgd * eat newlines
648 1.1 cgd */
649 1.1 cgd if (checkkwd == 2) {
650 1.1 cgd checkkwd = 0;
651 1.1 cgd while (t == TNL) {
652 1.1 cgd parseheredoc();
653 1.1 cgd t = xxreadtoken();
654 1.1 cgd }
655 1.1 cgd } else
656 1.1 cgd checkkwd = 0;
657 1.1 cgd /*
658 1.11 jtc * check for keywords and aliases
659 1.1 cgd */
660 1.1 cgd if (t == TWORD && !quoteflag) {
661 1.11 jtc register char * const *pp, *s;
662 1.1 cgd
663 1.11 jtc for (pp = (char **)parsekwd; *pp; pp++) {
664 1.1 cgd if (**pp == *wordtext && equal(*pp, wordtext)) {
665 1.1 cgd lasttoken = t = pp - parsekwd + KWDOFFSET;
666 1.1 cgd TRACE(("keyword %s recognized\n", tokname[t]));
667 1.11 jtc goto out;
668 1.1 cgd }
669 1.1 cgd }
670 1.11 jtc if (ap = lookupalias(wordtext, 1)) {
671 1.11 jtc pushstring(ap->val, strlen(ap->val), ap);
672 1.11 jtc checkkwd = savecheckkwd;
673 1.11 jtc goto top;
674 1.11 jtc }
675 1.1 cgd }
676 1.11 jtc out:
677 1.11 jtc checkkwd = 0;
678 1.1 cgd }
679 1.1 cgd #ifdef DEBUG
680 1.1 cgd if (!alreadyseen)
681 1.1 cgd TRACE(("token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
682 1.1 cgd else
683 1.1 cgd TRACE(("reread token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
684 1.1 cgd #endif
685 1.1 cgd return (t);
686 1.1 cgd }
687 1.1 cgd
688 1.1 cgd
689 1.1 cgd /*
690 1.1 cgd * Read the next input token.
691 1.1 cgd * If the token is a word, we set backquotelist to the list of cmds in
692 1.1 cgd * backquotes. We set quoteflag to true if any part of the word was
693 1.1 cgd * quoted.
694 1.1 cgd * If the token is TREDIR, then we set redirnode to a structure containing
695 1.1 cgd * the redirection.
696 1.1 cgd * In all cases, the variable startlinno is set to the number of the line
697 1.1 cgd * on which the token starts.
698 1.1 cgd *
699 1.1 cgd * [Change comment: here documents and internal procedures]
700 1.1 cgd * [Readtoken shouldn't have any arguments. Perhaps we should make the
701 1.1 cgd * word parsing code into a separate routine. In this case, readtoken
702 1.1 cgd * doesn't need to have any internal procedures, but parseword does.
703 1.1 cgd * We could also make parseoperator in essence the main routine, and
704 1.1 cgd * have parseword (readtoken1?) handle both words and redirection.]
705 1.1 cgd */
706 1.1 cgd
707 1.1 cgd #define RETURN(token) return lasttoken = token
708 1.1 cgd
709 1.1 cgd STATIC int
710 1.1 cgd xxreadtoken() {
711 1.1 cgd register c;
712 1.1 cgd
713 1.1 cgd if (tokpushback) {
714 1.1 cgd tokpushback = 0;
715 1.1 cgd return lasttoken;
716 1.1 cgd }
717 1.1 cgd if (needprompt) {
718 1.11 jtc setprompt(2);
719 1.1 cgd needprompt = 0;
720 1.1 cgd }
721 1.1 cgd startlinno = plinno;
722 1.1 cgd for (;;) { /* until token or start of word found */
723 1.1 cgd c = pgetc_macro();
724 1.1 cgd if (c == ' ' || c == '\t')
725 1.1 cgd continue; /* quick check for white space first */
726 1.1 cgd switch (c) {
727 1.1 cgd case ' ': case '\t':
728 1.1 cgd continue;
729 1.1 cgd case '#':
730 1.1 cgd while ((c = pgetc()) != '\n' && c != PEOF);
731 1.1 cgd pungetc();
732 1.1 cgd continue;
733 1.1 cgd case '\\':
734 1.1 cgd if (pgetc() == '\n') {
735 1.1 cgd startlinno = ++plinno;
736 1.1 cgd if (doprompt)
737 1.11 jtc setprompt(2);
738 1.11 jtc else
739 1.11 jtc setprompt(0);
740 1.1 cgd continue;
741 1.1 cgd }
742 1.1 cgd pungetc();
743 1.1 cgd goto breakloop;
744 1.1 cgd case '\n':
745 1.1 cgd plinno++;
746 1.1 cgd needprompt = doprompt;
747 1.1 cgd RETURN(TNL);
748 1.1 cgd case PEOF:
749 1.1 cgd RETURN(TEOF);
750 1.1 cgd case '&':
751 1.1 cgd if (pgetc() == '&')
752 1.1 cgd RETURN(TAND);
753 1.1 cgd pungetc();
754 1.1 cgd RETURN(TBACKGND);
755 1.1 cgd case '|':
756 1.1 cgd if (pgetc() == '|')
757 1.1 cgd RETURN(TOR);
758 1.1 cgd pungetc();
759 1.1 cgd RETURN(TPIPE);
760 1.1 cgd case ';':
761 1.1 cgd if (pgetc() == ';')
762 1.1 cgd RETURN(TENDCASE);
763 1.1 cgd pungetc();
764 1.1 cgd RETURN(TSEMI);
765 1.1 cgd case '(':
766 1.1 cgd RETURN(TLP);
767 1.1 cgd case ')':
768 1.1 cgd RETURN(TRP);
769 1.1 cgd default:
770 1.1 cgd goto breakloop;
771 1.1 cgd }
772 1.1 cgd }
773 1.1 cgd breakloop:
774 1.1 cgd return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
775 1.1 cgd #undef RETURN
776 1.1 cgd }
777 1.1 cgd
778 1.1 cgd
779 1.1 cgd
780 1.1 cgd /*
781 1.1 cgd * If eofmark is NULL, read a word or a redirection symbol. If eofmark
782 1.1 cgd * is not NULL, read a here document. In the latter case, eofmark is the
783 1.1 cgd * word which marks the end of the document and striptabs is true if
784 1.1 cgd * leading tabs should be stripped from the document. The argument firstc
785 1.1 cgd * is the first character of the input token or document.
786 1.1 cgd *
787 1.1 cgd * Because C does not have internal subroutines, I have simulated them
788 1.1 cgd * using goto's to implement the subroutine linkage. The following macros
789 1.1 cgd * will run code that appears at the end of readtoken1.
790 1.1 cgd */
791 1.1 cgd
792 1.1 cgd #define CHECKEND() {goto checkend; checkend_return:;}
793 1.1 cgd #define PARSEREDIR() {goto parseredir; parseredir_return:;}
794 1.1 cgd #define PARSESUB() {goto parsesub; parsesub_return:;}
795 1.1 cgd #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
796 1.1 cgd #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
797 1.11 jtc #define PARSEARITH() {goto parsearith; parsearith_return:;}
798 1.1 cgd
799 1.1 cgd STATIC int
800 1.1 cgd readtoken1(firstc, syntax, eofmark, striptabs)
801 1.1 cgd int firstc;
802 1.1 cgd char const *syntax;
803 1.1 cgd char *eofmark;
804 1.1 cgd int striptabs;
805 1.1 cgd {
806 1.1 cgd register c = firstc;
807 1.1 cgd register char *out;
808 1.1 cgd int len;
809 1.1 cgd char line[EOFMARKLEN + 1];
810 1.1 cgd struct nodelist *bqlist;
811 1.1 cgd int quotef;
812 1.1 cgd int dblquote;
813 1.11 jtc int varnest; /* levels of variables expansion */
814 1.11 jtc int arinest; /* levels of arithmetic expansion */
815 1.11 jtc int parenlevel; /* levels of parens in arithmetic */
816 1.1 cgd int oldstyle;
817 1.11 jtc char const *prevsyntax; /* syntax before arithmetic */
818 1.1 cgd
819 1.1 cgd startlinno = plinno;
820 1.1 cgd dblquote = 0;
821 1.1 cgd if (syntax == DQSYNTAX)
822 1.1 cgd dblquote = 1;
823 1.1 cgd quotef = 0;
824 1.1 cgd bqlist = NULL;
825 1.1 cgd varnest = 0;
826 1.11 jtc arinest = 0;
827 1.11 jtc parenlevel = 0;
828 1.11 jtc
829 1.1 cgd STARTSTACKSTR(out);
830 1.1 cgd loop: { /* for each line, until end of word */
831 1.1 cgd #if ATTY
832 1.1 cgd if (c == '\034' && doprompt
833 1.1 cgd && attyset() && ! equal(termval(), "emacs")) {
834 1.1 cgd attyline();
835 1.1 cgd if (syntax == BASESYNTAX)
836 1.1 cgd return readtoken();
837 1.1 cgd c = pgetc();
838 1.1 cgd goto loop;
839 1.1 cgd }
840 1.1 cgd #endif
841 1.1 cgd CHECKEND(); /* set c to PEOF if at end of here document */
842 1.1 cgd for (;;) { /* until end of line or end of word */
843 1.1 cgd CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */
844 1.1 cgd switch(syntax[c]) {
845 1.1 cgd case CNL: /* '\n' */
846 1.1 cgd if (syntax == BASESYNTAX)
847 1.1 cgd goto endword; /* exit outer loop */
848 1.1 cgd USTPUTC(c, out);
849 1.1 cgd plinno++;
850 1.11 jtc if (doprompt)
851 1.11 jtc setprompt(2);
852 1.11 jtc else
853 1.11 jtc setprompt(0);
854 1.1 cgd c = pgetc();
855 1.1 cgd goto loop; /* continue outer loop */
856 1.1 cgd case CWORD:
857 1.1 cgd USTPUTC(c, out);
858 1.1 cgd break;
859 1.1 cgd case CCTL:
860 1.1 cgd if (eofmark == NULL || dblquote)
861 1.1 cgd USTPUTC(CTLESC, out);
862 1.1 cgd USTPUTC(c, out);
863 1.1 cgd break;
864 1.1 cgd case CBACK: /* backslash */
865 1.1 cgd c = pgetc();
866 1.1 cgd if (c == PEOF) {
867 1.1 cgd USTPUTC('\\', out);
868 1.1 cgd pungetc();
869 1.1 cgd } else if (c == '\n') {
870 1.1 cgd if (doprompt)
871 1.11 jtc setprompt(2);
872 1.11 jtc else
873 1.11 jtc setprompt(0);
874 1.1 cgd } else {
875 1.1 cgd if (dblquote && c != '\\' && c != '`' && c != '$'
876 1.1 cgd && (c != '"' || eofmark != NULL))
877 1.1 cgd USTPUTC('\\', out);
878 1.1 cgd if (SQSYNTAX[c] == CCTL)
879 1.1 cgd USTPUTC(CTLESC, out);
880 1.1 cgd USTPUTC(c, out);
881 1.1 cgd quotef++;
882 1.1 cgd }
883 1.1 cgd break;
884 1.1 cgd case CSQUOTE:
885 1.1 cgd syntax = SQSYNTAX;
886 1.1 cgd break;
887 1.1 cgd case CDQUOTE:
888 1.1 cgd syntax = DQSYNTAX;
889 1.1 cgd dblquote = 1;
890 1.1 cgd break;
891 1.1 cgd case CENDQUOTE:
892 1.1 cgd if (eofmark) {
893 1.1 cgd USTPUTC(c, out);
894 1.1 cgd } else {
895 1.11 jtc if (arinest)
896 1.11 jtc syntax = ARISYNTAX;
897 1.11 jtc else
898 1.11 jtc syntax = BASESYNTAX;
899 1.1 cgd quotef++;
900 1.1 cgd dblquote = 0;
901 1.1 cgd }
902 1.1 cgd break;
903 1.1 cgd case CVAR: /* '$' */
904 1.1 cgd PARSESUB(); /* parse substitution */
905 1.1 cgd break;
906 1.1 cgd case CENDVAR: /* '}' */
907 1.1 cgd if (varnest > 0) {
908 1.1 cgd varnest--;
909 1.1 cgd USTPUTC(CTLENDVAR, out);
910 1.1 cgd } else {
911 1.1 cgd USTPUTC(c, out);
912 1.1 cgd }
913 1.1 cgd break;
914 1.11 jtc case CLP: /* '(' in arithmetic */
915 1.11 jtc parenlevel++;
916 1.11 jtc USTPUTC(c, out);
917 1.11 jtc break;
918 1.11 jtc case CRP: /* ')' in arithmetic */
919 1.11 jtc if (parenlevel > 0) {
920 1.11 jtc USTPUTC(c, out);
921 1.11 jtc --parenlevel;
922 1.11 jtc } else {
923 1.11 jtc if (pgetc() == ')') {
924 1.11 jtc if (--arinest == 0) {
925 1.11 jtc USTPUTC(CTLENDARI, out);
926 1.11 jtc syntax = prevsyntax;
927 1.11 jtc } else
928 1.11 jtc USTPUTC(')', out);
929 1.11 jtc } else {
930 1.11 jtc /*
931 1.11 jtc * unbalanced parens
932 1.11 jtc * (don't 2nd guess - no error)
933 1.11 jtc */
934 1.11 jtc pungetc();
935 1.11 jtc USTPUTC(')', out);
936 1.11 jtc }
937 1.11 jtc }
938 1.11 jtc break;
939 1.1 cgd case CBQUOTE: /* '`' */
940 1.1 cgd PARSEBACKQOLD();
941 1.1 cgd break;
942 1.1 cgd case CEOF:
943 1.1 cgd goto endword; /* exit outer loop */
944 1.1 cgd default:
945 1.1 cgd if (varnest == 0)
946 1.1 cgd goto endword; /* exit outer loop */
947 1.1 cgd USTPUTC(c, out);
948 1.1 cgd }
949 1.1 cgd c = pgetc_macro();
950 1.1 cgd }
951 1.1 cgd }
952 1.1 cgd endword:
953 1.11 jtc if (syntax == ARISYNTAX)
954 1.11 jtc synerror("Missing '))'");
955 1.5 sef if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
956 1.1 cgd synerror("Unterminated quoted string");
957 1.1 cgd if (varnest != 0) {
958 1.1 cgd startlinno = plinno;
959 1.1 cgd synerror("Missing '}'");
960 1.1 cgd }
961 1.1 cgd USTPUTC('\0', out);
962 1.1 cgd len = out - stackblock();
963 1.1 cgd out = stackblock();
964 1.1 cgd if (eofmark == NULL) {
965 1.1 cgd if ((c == '>' || c == '<')
966 1.1 cgd && quotef == 0
967 1.1 cgd && len <= 2
968 1.1 cgd && (*out == '\0' || is_digit(*out))) {
969 1.1 cgd PARSEREDIR();
970 1.1 cgd return lasttoken = TREDIR;
971 1.1 cgd } else {
972 1.1 cgd pungetc();
973 1.1 cgd }
974 1.1 cgd }
975 1.1 cgd quoteflag = quotef;
976 1.1 cgd backquotelist = bqlist;
977 1.1 cgd grabstackblock(len);
978 1.1 cgd wordtext = out;
979 1.1 cgd return lasttoken = TWORD;
980 1.1 cgd /* end of readtoken routine */
981 1.1 cgd
982 1.1 cgd
983 1.1 cgd
984 1.1 cgd /*
985 1.1 cgd * Check to see whether we are at the end of the here document. When this
986 1.1 cgd * is called, c is set to the first character of the next input line. If
987 1.1 cgd * we are at the end of the here document, this routine sets the c to PEOF.
988 1.1 cgd */
989 1.1 cgd
990 1.1 cgd checkend: {
991 1.1 cgd if (eofmark) {
992 1.1 cgd if (striptabs) {
993 1.1 cgd while (c == '\t')
994 1.1 cgd c = pgetc();
995 1.1 cgd }
996 1.1 cgd if (c == *eofmark) {
997 1.1 cgd if (pfgets(line, sizeof line) != NULL) {
998 1.1 cgd register char *p, *q;
999 1.1 cgd
1000 1.1 cgd p = line;
1001 1.1 cgd for (q = eofmark + 1 ; *q && *p == *q ; p++, q++);
1002 1.1 cgd if (*p == '\n' && *q == '\0') {
1003 1.1 cgd c = PEOF;
1004 1.1 cgd plinno++;
1005 1.1 cgd needprompt = doprompt;
1006 1.1 cgd } else {
1007 1.11 jtc pushstring(line, strlen(line), NULL);
1008 1.1 cgd }
1009 1.1 cgd }
1010 1.1 cgd }
1011 1.1 cgd }
1012 1.1 cgd goto checkend_return;
1013 1.1 cgd }
1014 1.1 cgd
1015 1.1 cgd
1016 1.1 cgd /*
1017 1.1 cgd * Parse a redirection operator. The variable "out" points to a string
1018 1.1 cgd * specifying the fd to be redirected. The variable "c" contains the
1019 1.1 cgd * first character of the redirection operator.
1020 1.1 cgd */
1021 1.1 cgd
1022 1.1 cgd parseredir: {
1023 1.1 cgd char fd = *out;
1024 1.1 cgd union node *np;
1025 1.1 cgd
1026 1.1 cgd np = (union node *)stalloc(sizeof (struct nfile));
1027 1.1 cgd if (c == '>') {
1028 1.1 cgd np->nfile.fd = 1;
1029 1.1 cgd c = pgetc();
1030 1.1 cgd if (c == '>')
1031 1.1 cgd np->type = NAPPEND;
1032 1.1 cgd else if (c == '&')
1033 1.1 cgd np->type = NTOFD;
1034 1.1 cgd else {
1035 1.1 cgd np->type = NTO;
1036 1.1 cgd pungetc();
1037 1.1 cgd }
1038 1.1 cgd } else { /* c == '<' */
1039 1.1 cgd np->nfile.fd = 0;
1040 1.1 cgd c = pgetc();
1041 1.1 cgd if (c == '<') {
1042 1.1 cgd if (sizeof (struct nfile) != sizeof (struct nhere)) {
1043 1.1 cgd np = (union node *)stalloc(sizeof (struct nhere));
1044 1.1 cgd np->nfile.fd = 0;
1045 1.1 cgd }
1046 1.1 cgd np->type = NHERE;
1047 1.1 cgd heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
1048 1.1 cgd heredoc->here = np;
1049 1.1 cgd if ((c = pgetc()) == '-') {
1050 1.1 cgd heredoc->striptabs = 1;
1051 1.1 cgd } else {
1052 1.1 cgd heredoc->striptabs = 0;
1053 1.1 cgd pungetc();
1054 1.1 cgd }
1055 1.1 cgd } else if (c == '&')
1056 1.1 cgd np->type = NFROMFD;
1057 1.1 cgd else {
1058 1.1 cgd np->type = NFROM;
1059 1.1 cgd pungetc();
1060 1.1 cgd }
1061 1.1 cgd }
1062 1.1 cgd if (fd != '\0')
1063 1.1 cgd np->nfile.fd = digit_val(fd);
1064 1.1 cgd redirnode = np;
1065 1.1 cgd goto parseredir_return;
1066 1.1 cgd }
1067 1.1 cgd
1068 1.1 cgd
1069 1.1 cgd /*
1070 1.1 cgd * Parse a substitution. At this point, we have read the dollar sign
1071 1.1 cgd * and nothing else.
1072 1.1 cgd */
1073 1.1 cgd
1074 1.1 cgd parsesub: {
1075 1.1 cgd int subtype;
1076 1.1 cgd int typeloc;
1077 1.1 cgd int flags;
1078 1.1 cgd char *p;
1079 1.1 cgd #ifndef GDB_HACK
1080 1.1 cgd static const char types[] = "}-+?=";
1081 1.1 cgd #endif
1082 1.1 cgd
1083 1.1 cgd c = pgetc();
1084 1.1 cgd if (c != '(' && c != '{' && !is_name(c) && !is_special(c)) {
1085 1.1 cgd USTPUTC('$', out);
1086 1.1 cgd pungetc();
1087 1.11 jtc } else if (c == '(') { /* $(command) or $((arith)) */
1088 1.11 jtc if (pgetc() == '(') {
1089 1.11 jtc PARSEARITH();
1090 1.11 jtc } else {
1091 1.11 jtc pungetc();
1092 1.11 jtc PARSEBACKQNEW();
1093 1.11 jtc }
1094 1.1 cgd } else {
1095 1.1 cgd USTPUTC(CTLVAR, out);
1096 1.1 cgd typeloc = out - stackblock();
1097 1.1 cgd USTPUTC(VSNORMAL, out);
1098 1.1 cgd subtype = VSNORMAL;
1099 1.1 cgd if (c == '{') {
1100 1.1 cgd c = pgetc();
1101 1.1 cgd subtype = 0;
1102 1.1 cgd }
1103 1.1 cgd if (is_name(c)) {
1104 1.1 cgd do {
1105 1.1 cgd STPUTC(c, out);
1106 1.1 cgd c = pgetc();
1107 1.1 cgd } while (is_in_name(c));
1108 1.1 cgd } else {
1109 1.1 cgd if (! is_special(c))
1110 1.1 cgd badsub: synerror("Bad substitution");
1111 1.1 cgd USTPUTC(c, out);
1112 1.1 cgd c = pgetc();
1113 1.1 cgd }
1114 1.1 cgd STPUTC('=', out);
1115 1.1 cgd flags = 0;
1116 1.1 cgd if (subtype == 0) {
1117 1.1 cgd if (c == ':') {
1118 1.1 cgd flags = VSNUL;
1119 1.1 cgd c = pgetc();
1120 1.1 cgd }
1121 1.1 cgd p = strchr(types, c);
1122 1.1 cgd if (p == NULL)
1123 1.1 cgd goto badsub;
1124 1.1 cgd subtype = p - types + VSNORMAL;
1125 1.1 cgd } else {
1126 1.1 cgd pungetc();
1127 1.1 cgd }
1128 1.11 jtc if (dblquote || arinest)
1129 1.1 cgd flags |= VSQUOTE;
1130 1.1 cgd *(stackblock() + typeloc) = subtype | flags;
1131 1.1 cgd if (subtype != VSNORMAL)
1132 1.1 cgd varnest++;
1133 1.1 cgd }
1134 1.1 cgd goto parsesub_return;
1135 1.1 cgd }
1136 1.1 cgd
1137 1.1 cgd
1138 1.1 cgd /*
1139 1.1 cgd * Called to parse command substitutions. Newstyle is set if the command
1140 1.1 cgd * is enclosed inside $(...); nlpp is a pointer to the head of the linked
1141 1.1 cgd * list of commands (passed by reference), and savelen is the number of
1142 1.1 cgd * characters on the top of the stack which must be preserved.
1143 1.1 cgd */
1144 1.1 cgd
1145 1.1 cgd parsebackq: {
1146 1.1 cgd struct nodelist **nlpp;
1147 1.1 cgd int savepbq;
1148 1.1 cgd union node *n;
1149 1.1 cgd char *volatile str;
1150 1.1 cgd struct jmploc jmploc;
1151 1.1 cgd struct jmploc *volatile savehandler;
1152 1.1 cgd int savelen;
1153 1.1 cgd
1154 1.1 cgd savepbq = parsebackquote;
1155 1.1 cgd if (setjmp(jmploc.loc)) {
1156 1.1 cgd if (str)
1157 1.1 cgd ckfree(str);
1158 1.1 cgd parsebackquote = 0;
1159 1.1 cgd handler = savehandler;
1160 1.4 dpassage longjmp(handler->loc, 1);
1161 1.1 cgd }
1162 1.1 cgd INTOFF;
1163 1.1 cgd str = NULL;
1164 1.1 cgd savelen = out - stackblock();
1165 1.1 cgd if (savelen > 0) {
1166 1.1 cgd str = ckmalloc(savelen);
1167 1.1 cgd bcopy(stackblock(), str, savelen);
1168 1.1 cgd }
1169 1.1 cgd savehandler = handler;
1170 1.1 cgd handler = &jmploc;
1171 1.1 cgd INTON;
1172 1.11 jtc if (oldstyle) {
1173 1.11 jtc /* We must read until the closing backquote, giving special
1174 1.11 jtc treatment to some slashes, and then push the string and
1175 1.11 jtc reread it as input, interpreting it normally. */
1176 1.11 jtc register char *out;
1177 1.11 jtc register c;
1178 1.11 jtc int savelen;
1179 1.11 jtc char *str;
1180 1.11 jtc
1181 1.11 jtc STARTSTACKSTR(out);
1182 1.11 jtc while ((c = pgetc ()) != '`') {
1183 1.11 jtc if (c == '\\') {
1184 1.11 jtc c = pgetc ();
1185 1.11 jtc if (c != '\\' && c != '`' && c != '$'
1186 1.11 jtc && (!dblquote || c != '"'))
1187 1.11 jtc STPUTC('\\', out);
1188 1.11 jtc }
1189 1.11 jtc STPUTC(c, out);
1190 1.11 jtc }
1191 1.11 jtc STPUTC('\0', out);
1192 1.11 jtc savelen = out - stackblock();
1193 1.11 jtc if (savelen > 0) {
1194 1.11 jtc str = ckmalloc(savelen);
1195 1.11 jtc bcopy(stackblock(), str, savelen);
1196 1.11 jtc }
1197 1.11 jtc setinputstring(str, 1);
1198 1.11 jtc }
1199 1.1 cgd nlpp = &bqlist;
1200 1.1 cgd while (*nlpp)
1201 1.1 cgd nlpp = &(*nlpp)->next;
1202 1.1 cgd *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
1203 1.1 cgd (*nlpp)->next = NULL;
1204 1.1 cgd parsebackquote = oldstyle;
1205 1.1 cgd n = list(0);
1206 1.11 jtc if (!oldstyle && (readtoken() != TRP))
1207 1.11 jtc synexpect(TRP);
1208 1.1 cgd (*nlpp)->n = n;
1209 1.11 jtc /* Start reading from old file again. */
1210 1.11 jtc if (oldstyle)
1211 1.11 jtc popfile();
1212 1.1 cgd while (stackblocksize() <= savelen)
1213 1.1 cgd growstackblock();
1214 1.1 cgd STARTSTACKSTR(out);
1215 1.1 cgd if (str) {
1216 1.1 cgd bcopy(str, out, savelen);
1217 1.1 cgd STADJUST(savelen, out);
1218 1.1 cgd INTOFF;
1219 1.1 cgd ckfree(str);
1220 1.1 cgd str = NULL;
1221 1.1 cgd INTON;
1222 1.1 cgd }
1223 1.1 cgd parsebackquote = savepbq;
1224 1.1 cgd handler = savehandler;
1225 1.11 jtc if (arinest || dblquote)
1226 1.11 jtc USTPUTC(CTLBACKQ | CTLQUOTE, out);
1227 1.11 jtc else
1228 1.11 jtc USTPUTC(CTLBACKQ, out);
1229 1.1 cgd if (oldstyle)
1230 1.1 cgd goto parsebackq_oldreturn;
1231 1.1 cgd else
1232 1.1 cgd goto parsebackq_newreturn;
1233 1.1 cgd }
1234 1.1 cgd
1235 1.1 cgd /*
1236 1.11 jtc * Parse an arithmetic expansion (indicate start of one and set state)
1237 1.1 cgd */
1238 1.11 jtc parsearith: {
1239 1.1 cgd
1240 1.11 jtc if (++arinest == 1) {
1241 1.11 jtc prevsyntax = syntax;
1242 1.11 jtc syntax = ARISYNTAX;
1243 1.11 jtc USTPUTC(CTLARI, out);
1244 1.11 jtc } else {
1245 1.11 jtc /*
1246 1.11 jtc * we collapse embedded arithmetic expansion to
1247 1.11 jtc * parenthesis, which should be equivalent
1248 1.11 jtc */
1249 1.11 jtc USTPUTC('(', out);
1250 1.1 cgd }
1251 1.11 jtc goto parsearith_return;
1252 1.1 cgd }
1253 1.1 cgd
1254 1.11 jtc } /* end of readtoken */
1255 1.1 cgd
1256 1.1 cgd
1257 1.1 cgd
1258 1.11 jtc #ifdef mkinit
1259 1.11 jtc RESET {
1260 1.11 jtc tokpushback = 0;
1261 1.11 jtc checkkwd = 0;
1262 1.1 cgd }
1263 1.1 cgd #endif
1264 1.1 cgd
1265 1.1 cgd /*
1266 1.1 cgd * Returns true if the text contains nothing to expand (no dollar signs
1267 1.1 cgd * or backquotes).
1268 1.1 cgd */
1269 1.1 cgd
1270 1.1 cgd STATIC int
1271 1.1 cgd noexpand(text)
1272 1.1 cgd char *text;
1273 1.1 cgd {
1274 1.1 cgd register char *p;
1275 1.1 cgd register char c;
1276 1.1 cgd
1277 1.1 cgd p = text;
1278 1.1 cgd while ((c = *p++) != '\0') {
1279 1.1 cgd if (c == CTLESC)
1280 1.1 cgd p++;
1281 1.1 cgd else if (BASESYNTAX[c] == CCTL)
1282 1.1 cgd return 0;
1283 1.1 cgd }
1284 1.1 cgd return 1;
1285 1.1 cgd }
1286 1.1 cgd
1287 1.1 cgd
1288 1.1 cgd /*
1289 1.1 cgd * Return true if the argument is a legal variable name (a letter or
1290 1.1 cgd * underscore followed by zero or more letters, underscores, and digits).
1291 1.1 cgd */
1292 1.1 cgd
1293 1.1 cgd int
1294 1.1 cgd goodname(name)
1295 1.1 cgd char *name;
1296 1.1 cgd {
1297 1.1 cgd register char *p;
1298 1.1 cgd
1299 1.1 cgd p = name;
1300 1.1 cgd if (! is_name(*p))
1301 1.1 cgd return 0;
1302 1.1 cgd while (*++p) {
1303 1.1 cgd if (! is_in_name(*p))
1304 1.1 cgd return 0;
1305 1.1 cgd }
1306 1.1 cgd return 1;
1307 1.1 cgd }
1308 1.1 cgd
1309 1.1 cgd
1310 1.1 cgd /*
1311 1.1 cgd * Called when an unexpected token is read during the parse. The argument
1312 1.1 cgd * is the token that is expected, or -1 if more than one type of token can
1313 1.1 cgd * occur at this point.
1314 1.1 cgd */
1315 1.1 cgd
1316 1.1 cgd STATIC void
1317 1.1 cgd synexpect(token) {
1318 1.1 cgd char msg[64];
1319 1.1 cgd
1320 1.1 cgd if (token >= 0) {
1321 1.1 cgd fmtstr(msg, 64, "%s unexpected (expecting %s)",
1322 1.1 cgd tokname[lasttoken], tokname[token]);
1323 1.1 cgd } else {
1324 1.1 cgd fmtstr(msg, 64, "%s unexpected", tokname[lasttoken]);
1325 1.1 cgd }
1326 1.1 cgd synerror(msg);
1327 1.1 cgd }
1328 1.1 cgd
1329 1.1 cgd
1330 1.1 cgd STATIC void
1331 1.1 cgd synerror(msg)
1332 1.1 cgd char *msg;
1333 1.1 cgd {
1334 1.1 cgd if (commandname)
1335 1.1 cgd outfmt(&errout, "%s: %d: ", commandname, startlinno);
1336 1.1 cgd outfmt(&errout, "Syntax error: %s\n", msg);
1337 1.1 cgd error((char *)NULL);
1338 1.11 jtc }
1339 1.11 jtc
1340 1.11 jtc STATIC void
1341 1.11 jtc setprompt(which)
1342 1.11 jtc int which;
1343 1.11 jtc {
1344 1.11 jtc whichprompt = which;
1345 1.11 jtc
1346 1.14 cgd #ifndef NO_HISTORY
1347 1.11 jtc if (!el)
1348 1.14 cgd #endif
1349 1.11 jtc out2str(getprompt(NULL));
1350 1.11 jtc }
1351 1.11 jtc
1352 1.11 jtc /*
1353 1.11 jtc * called by editline -- any expansions to the prompt
1354 1.11 jtc * should be added here.
1355 1.11 jtc */
1356 1.11 jtc char *
1357 1.11 jtc getprompt(unused)
1358 1.11 jtc void *unused;
1359 1.11 jtc {
1360 1.11 jtc switch (whichprompt) {
1361 1.11 jtc case 0:
1362 1.11 jtc return "";
1363 1.11 jtc case 1:
1364 1.11 jtc return ps1val();
1365 1.11 jtc case 2:
1366 1.11 jtc return ps2val();
1367 1.11 jtc default:
1368 1.11 jtc return "<internal prompt error>";
1369 1.11 jtc }
1370 1.1 cgd }
1371