parser.c revision 1.119 1 1.119 kre /* $NetBSD: parser.c,v 1.119 2016/05/09 20:36:07 kre Exp $ */
2 1.24 cgd
3 1.1 cgd /*-
4 1.11 jtc * Copyright (c) 1991, 1993
5 1.11 jtc * The Regents of the University of California. All rights reserved.
6 1.1 cgd *
7 1.1 cgd * This code is derived from software contributed to Berkeley by
8 1.1 cgd * Kenneth Almquist.
9 1.1 cgd *
10 1.1 cgd * Redistribution and use in source and binary forms, with or without
11 1.1 cgd * modification, are permitted provided that the following conditions
12 1.1 cgd * are met:
13 1.1 cgd * 1. Redistributions of source code must retain the above copyright
14 1.1 cgd * notice, this list of conditions and the following disclaimer.
15 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
16 1.1 cgd * notice, this list of conditions and the following disclaimer in the
17 1.1 cgd * documentation and/or other materials provided with the distribution.
18 1.55 agc * 3. Neither the name of the University nor the names of its contributors
19 1.1 cgd * may be used to endorse or promote products derived from this software
20 1.1 cgd * without specific prior written permission.
21 1.1 cgd *
22 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.1 cgd * SUCH DAMAGE.
33 1.1 cgd */
34 1.1 cgd
35 1.36 christos #include <sys/cdefs.h>
36 1.1 cgd #ifndef lint
37 1.24 cgd #if 0
38 1.26 christos static char sccsid[] = "@(#)parser.c 8.7 (Berkeley) 5/16/95";
39 1.24 cgd #else
40 1.119 kre __RCSID("$NetBSD: parser.c,v 1.119 2016/05/09 20:36:07 kre Exp $");
41 1.24 cgd #endif
42 1.1 cgd #endif /* not lint */
43 1.1 cgd
44 1.85 christos #include <stdio.h>
45 1.25 christos #include <stdlib.h>
46 1.82 christos #include <limits.h>
47 1.25 christos
48 1.1 cgd #include "shell.h"
49 1.1 cgd #include "parser.h"
50 1.1 cgd #include "nodes.h"
51 1.1 cgd #include "expand.h" /* defines rmescapes() */
52 1.46 christos #include "eval.h" /* defines commandname */
53 1.1 cgd #include "syntax.h"
54 1.1 cgd #include "options.h"
55 1.1 cgd #include "input.h"
56 1.1 cgd #include "output.h"
57 1.1 cgd #include "var.h"
58 1.1 cgd #include "error.h"
59 1.1 cgd #include "memalloc.h"
60 1.1 cgd #include "mystring.h"
61 1.11 jtc #include "alias.h"
62 1.25 christos #include "show.h"
63 1.35 christos #ifndef SMALL
64 1.11 jtc #include "myhistedit.h"
65 1.14 cgd #endif
66 1.1 cgd
67 1.1 cgd /*
68 1.1 cgd * Shell command parser.
69 1.1 cgd */
70 1.1 cgd
71 1.1 cgd /* values returned by readtoken */
72 1.30 christos #include "token.h"
73 1.1 cgd
74 1.51 christos #define OPENBRACE '{'
75 1.51 christos #define CLOSEBRACE '}'
76 1.1 cgd
77 1.1 cgd
78 1.1 cgd struct heredoc {
79 1.1 cgd struct heredoc *next; /* next here document in list */
80 1.1 cgd union node *here; /* redirection node */
81 1.1 cgd char *eofmark; /* string indicating end of input */
82 1.1 cgd int striptabs; /* if set, strip leading tabs */
83 1.116 christos int startline; /* line number where << seen */
84 1.1 cgd };
85 1.1 cgd
86 1.1 cgd
87 1.1 cgd
88 1.48 christos static int noalias = 0; /* when set, don't handle aliases */
89 1.1 cgd struct heredoc *heredoclist; /* list of here documents to read */
90 1.1 cgd int parsebackquote; /* nonzero if we are inside backquotes */
91 1.1 cgd int doprompt; /* if set, prompt the user */
92 1.1 cgd int needprompt; /* true if interactive and at start of line */
93 1.1 cgd int lasttoken; /* last token read */
94 1.1 cgd MKINIT int tokpushback; /* last token pushed back */
95 1.1 cgd char *wordtext; /* text of last word returned by readtoken */
96 1.67 dsl MKINIT int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
97 1.1 cgd struct nodelist *backquotelist;
98 1.1 cgd union node *redirnode;
99 1.1 cgd struct heredoc *heredoc;
100 1.1 cgd int quoteflag; /* set if (part of) last token was quoted */
101 1.1 cgd int startlinno; /* line # where last token started */
102 1.84 christos int funclinno; /* line # where the current function started */
103 1.1 cgd
104 1.1 cgd
105 1.73 christos STATIC union node *list(int, int);
106 1.54 christos STATIC union node *andor(void);
107 1.54 christos STATIC union node *pipeline(void);
108 1.54 christos STATIC union node *command(void);
109 1.54 christos STATIC union node *simplecmd(union node **, union node *);
110 1.54 christos STATIC union node *makename(void);
111 1.54 christos STATIC void parsefname(void);
112 1.115 christos STATIC void slurp_heredoc(char *const, const int, const int);
113 1.111 christos STATIC void readheredocs(void);
114 1.54 christos STATIC int peektoken(void);
115 1.54 christos STATIC int readtoken(void);
116 1.54 christos STATIC int xxreadtoken(void);
117 1.111 christos STATIC int readtoken1(int, char const *, int);
118 1.54 christos STATIC int noexpand(char *);
119 1.108 christos STATIC void synexpect(int, const char *) __dead;
120 1.66 perry STATIC void synerror(const char *) __dead;
121 1.54 christos STATIC void setprompt(int);
122 1.1 cgd
123 1.22 cgd
124 1.102 christos static const char EOFhere[] = "EOF reading here (<<) document";
125 1.102 christos
126 1.108 christos
127 1.1 cgd /*
128 1.1 cgd * Read and parse a command. Returns NEOF on end of file. (NULL is a
129 1.1 cgd * valid parse tree indicating a blank line.)
130 1.1 cgd */
131 1.1 cgd
132 1.1 cgd union node *
133 1.45 cgd parsecmd(int interact)
134 1.22 cgd {
135 1.1 cgd int t;
136 1.116 christos union node *n;
137 1.1 cgd
138 1.47 christos tokpushback = 0;
139 1.1 cgd doprompt = interact;
140 1.1 cgd if (doprompt)
141 1.11 jtc setprompt(1);
142 1.11 jtc else
143 1.11 jtc setprompt(0);
144 1.1 cgd needprompt = 0;
145 1.11 jtc t = readtoken();
146 1.11 jtc if (t == TEOF)
147 1.1 cgd return NEOF;
148 1.1 cgd if (t == TNL)
149 1.1 cgd return NULL;
150 1.1 cgd tokpushback++;
151 1.116 christos n = list(1, 0);
152 1.116 christos if (heredoclist)
153 1.116 christos error("%d: Here document (<<%s) expected but not present",
154 1.116 christos heredoclist->startline, heredoclist->eofmark);
155 1.116 christos return n;
156 1.1 cgd }
157 1.1 cgd
158 1.1 cgd
159 1.1 cgd STATIC union node *
160 1.73 christos list(int nlflag, int erflag)
161 1.22 cgd {
162 1.1 cgd union node *n1, *n2, *n3;
163 1.12 jtc int tok;
164 1.108 christos TRACE(("list(%d,%d): entered\n", nlflag, erflag));
165 1.1 cgd
166 1.1 cgd checkkwd = 2;
167 1.1 cgd if (nlflag == 0 && tokendlist[peektoken()])
168 1.1 cgd return NULL;
169 1.12 jtc n1 = NULL;
170 1.1 cgd for (;;) {
171 1.12 jtc n2 = andor();
172 1.12 jtc tok = readtoken();
173 1.12 jtc if (tok == TBACKGND) {
174 1.12 jtc if (n2->type == NCMD || n2->type == NPIPE) {
175 1.12 jtc n2->ncmd.backgnd = 1;
176 1.12 jtc } else if (n2->type == NREDIR) {
177 1.12 jtc n2->type = NBACKGND;
178 1.1 cgd } else {
179 1.101 christos n3 = stalloc(sizeof(struct nredir));
180 1.1 cgd n3->type = NBACKGND;
181 1.12 jtc n3->nredir.n = n2;
182 1.1 cgd n3->nredir.redirect = NULL;
183 1.12 jtc n2 = n3;
184 1.1 cgd }
185 1.12 jtc }
186 1.12 jtc if (n1 == NULL) {
187 1.12 jtc n1 = n2;
188 1.12 jtc }
189 1.12 jtc else {
190 1.101 christos n3 = stalloc(sizeof(struct nbinary));
191 1.12 jtc n3->type = NSEMI;
192 1.12 jtc n3->nbinary.ch1 = n1;
193 1.12 jtc n3->nbinary.ch2 = n2;
194 1.12 jtc n1 = n3;
195 1.12 jtc }
196 1.12 jtc switch (tok) {
197 1.12 jtc case TBACKGND:
198 1.12 jtc case TSEMI:
199 1.12 jtc tok = readtoken();
200 1.108 christos /* FALLTHROUGH */
201 1.1 cgd case TNL:
202 1.12 jtc if (tok == TNL) {
203 1.111 christos readheredocs();
204 1.1 cgd if (nlflag)
205 1.1 cgd return n1;
206 1.1 cgd } else {
207 1.1 cgd tokpushback++;
208 1.1 cgd }
209 1.1 cgd checkkwd = 2;
210 1.1 cgd if (tokendlist[peektoken()])
211 1.1 cgd return n1;
212 1.1 cgd break;
213 1.1 cgd case TEOF:
214 1.116 christos pungetc(); /* push back EOF on input */
215 1.1 cgd return n1;
216 1.1 cgd default:
217 1.73 christos if (nlflag || erflag)
218 1.108 christos synexpect(-1, 0);
219 1.1 cgd tokpushback++;
220 1.1 cgd return n1;
221 1.1 cgd }
222 1.1 cgd }
223 1.1 cgd }
224 1.1 cgd
225 1.1 cgd STATIC union node *
226 1.54 christos andor(void)
227 1.54 christos {
228 1.1 cgd union node *n1, *n2, *n3;
229 1.1 cgd int t;
230 1.1 cgd
231 1.65 dsl TRACE(("andor: entered\n"));
232 1.1 cgd n1 = pipeline();
233 1.1 cgd for (;;) {
234 1.1 cgd if ((t = readtoken()) == TAND) {
235 1.1 cgd t = NAND;
236 1.1 cgd } else if (t == TOR) {
237 1.1 cgd t = NOR;
238 1.1 cgd } else {
239 1.1 cgd tokpushback++;
240 1.1 cgd return n1;
241 1.1 cgd }
242 1.1 cgd n2 = pipeline();
243 1.101 christos n3 = stalloc(sizeof(struct nbinary));
244 1.1 cgd n3->type = t;
245 1.1 cgd n3->nbinary.ch1 = n1;
246 1.1 cgd n3->nbinary.ch2 = n2;
247 1.1 cgd n1 = n3;
248 1.1 cgd }
249 1.1 cgd }
250 1.1 cgd
251 1.1 cgd STATIC union node *
252 1.54 christos pipeline(void)
253 1.54 christos {
254 1.44 christos union node *n1, *n2, *pipenode;
255 1.1 cgd struct nodelist *lp, *prev;
256 1.44 christos int negate;
257 1.1 cgd
258 1.65 dsl TRACE(("pipeline: entered\n"));
259 1.65 dsl
260 1.44 christos negate = 0;
261 1.65 dsl checkkwd = 2;
262 1.65 dsl while (readtoken() == TNOT) {
263 1.65 dsl TRACE(("pipeline: TNOT recognized\n"));
264 1.44 christos negate = !negate;
265 1.65 dsl }
266 1.44 christos tokpushback++;
267 1.1 cgd n1 = command();
268 1.1 cgd if (readtoken() == TPIPE) {
269 1.101 christos pipenode = stalloc(sizeof(struct npipe));
270 1.1 cgd pipenode->type = NPIPE;
271 1.1 cgd pipenode->npipe.backgnd = 0;
272 1.101 christos lp = stalloc(sizeof(struct nodelist));
273 1.1 cgd pipenode->npipe.cmdlist = lp;
274 1.1 cgd lp->n = n1;
275 1.1 cgd do {
276 1.1 cgd prev = lp;
277 1.101 christos lp = stalloc(sizeof(struct nodelist));
278 1.1 cgd lp->n = command();
279 1.1 cgd prev->next = lp;
280 1.1 cgd } while (readtoken() == TPIPE);
281 1.1 cgd lp->next = NULL;
282 1.1 cgd n1 = pipenode;
283 1.1 cgd }
284 1.1 cgd tokpushback++;
285 1.44 christos if (negate) {
286 1.65 dsl TRACE(("negate pipeline\n"));
287 1.101 christos n2 = stalloc(sizeof(struct nnot));
288 1.44 christos n2->type = NNOT;
289 1.44 christos n2->nnot.com = n1;
290 1.44 christos return n2;
291 1.44 christos } else
292 1.44 christos return n1;
293 1.1 cgd }
294 1.1 cgd
295 1.1 cgd
296 1.1 cgd
297 1.1 cgd STATIC union node *
298 1.54 christos command(void)
299 1.54 christos {
300 1.1 cgd union node *n1, *n2;
301 1.1 cgd union node *ap, **app;
302 1.1 cgd union node *cp, **cpp;
303 1.1 cgd union node *redir, **rpp;
304 1.31 christos int t, negate = 0;
305 1.1 cgd
306 1.65 dsl TRACE(("command: entered\n"));
307 1.65 dsl
308 1.1 cgd checkkwd = 2;
309 1.25 christos redir = NULL;
310 1.25 christos n1 = NULL;
311 1.5 sef rpp = &redir;
312 1.31 christos
313 1.5 sef /* Check for redirection which may precede command */
314 1.5 sef while (readtoken() == TREDIR) {
315 1.5 sef *rpp = n2 = redirnode;
316 1.5 sef rpp = &n2->nfile.next;
317 1.5 sef parsefname();
318 1.5 sef }
319 1.5 sef tokpushback++;
320 1.5 sef
321 1.31 christos while (readtoken() == TNOT) {
322 1.31 christos TRACE(("command: TNOT recognized\n"));
323 1.31 christos negate = !negate;
324 1.31 christos }
325 1.31 christos tokpushback++;
326 1.31 christos
327 1.1 cgd switch (readtoken()) {
328 1.1 cgd case TIF:
329 1.101 christos n1 = stalloc(sizeof(struct nif));
330 1.1 cgd n1->type = NIF;
331 1.73 christos n1->nif.test = list(0, 0);
332 1.1 cgd if (readtoken() != TTHEN)
333 1.108 christos synexpect(TTHEN, 0);
334 1.73 christos n1->nif.ifpart = list(0, 0);
335 1.1 cgd n2 = n1;
336 1.1 cgd while (readtoken() == TELIF) {
337 1.101 christos n2->nif.elsepart = stalloc(sizeof(struct nif));
338 1.1 cgd n2 = n2->nif.elsepart;
339 1.1 cgd n2->type = NIF;
340 1.73 christos n2->nif.test = list(0, 0);
341 1.1 cgd if (readtoken() != TTHEN)
342 1.108 christos synexpect(TTHEN, 0);
343 1.73 christos n2->nif.ifpart = list(0, 0);
344 1.1 cgd }
345 1.1 cgd if (lasttoken == TELSE)
346 1.73 christos n2->nif.elsepart = list(0, 0);
347 1.1 cgd else {
348 1.1 cgd n2->nif.elsepart = NULL;
349 1.1 cgd tokpushback++;
350 1.1 cgd }
351 1.1 cgd if (readtoken() != TFI)
352 1.108 christos synexpect(TFI, 0);
353 1.1 cgd checkkwd = 1;
354 1.1 cgd break;
355 1.1 cgd case TWHILE:
356 1.1 cgd case TUNTIL: {
357 1.1 cgd int got;
358 1.101 christos n1 = stalloc(sizeof(struct nbinary));
359 1.1 cgd n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
360 1.73 christos n1->nbinary.ch1 = list(0, 0);
361 1.1 cgd if ((got=readtoken()) != TDO) {
362 1.1 cgd TRACE(("expecting DO got %s %s\n", tokname[got], got == TWORD ? wordtext : ""));
363 1.108 christos synexpect(TDO, 0);
364 1.1 cgd }
365 1.73 christos n1->nbinary.ch2 = list(0, 0);
366 1.1 cgd if (readtoken() != TDONE)
367 1.108 christos synexpect(TDONE, 0);
368 1.1 cgd checkkwd = 1;
369 1.1 cgd break;
370 1.1 cgd }
371 1.1 cgd case TFOR:
372 1.1 cgd if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
373 1.1 cgd synerror("Bad for loop variable");
374 1.101 christos n1 = stalloc(sizeof(struct nfor));
375 1.1 cgd n1->type = NFOR;
376 1.1 cgd n1->nfor.var = wordtext;
377 1.1 cgd if (readtoken() == TWORD && ! quoteflag && equal(wordtext, "in")) {
378 1.1 cgd app = ≈
379 1.1 cgd while (readtoken() == TWORD) {
380 1.101 christos n2 = stalloc(sizeof(struct narg));
381 1.1 cgd n2->type = NARG;
382 1.1 cgd n2->narg.text = wordtext;
383 1.1 cgd n2->narg.backquote = backquotelist;
384 1.1 cgd *app = n2;
385 1.1 cgd app = &n2->narg.next;
386 1.1 cgd }
387 1.1 cgd *app = NULL;
388 1.1 cgd n1->nfor.args = ap;
389 1.5 sef if (lasttoken != TNL && lasttoken != TSEMI)
390 1.108 christos synexpect(-1, 0);
391 1.1 cgd } else {
392 1.95 christos static char argvars[5] = {
393 1.95 christos CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'
394 1.95 christos };
395 1.101 christos n2 = stalloc(sizeof(struct narg));
396 1.1 cgd n2->type = NARG;
397 1.43 christos n2->narg.text = argvars;
398 1.1 cgd n2->narg.backquote = NULL;
399 1.1 cgd n2->narg.next = NULL;
400 1.1 cgd n1->nfor.args = n2;
401 1.11 jtc /*
402 1.11 jtc * Newline or semicolon here is optional (but note
403 1.11 jtc * that the original Bourne shell only allowed NL).
404 1.11 jtc */
405 1.11 jtc if (lasttoken != TNL && lasttoken != TSEMI)
406 1.11 jtc tokpushback++;
407 1.1 cgd }
408 1.1 cgd checkkwd = 2;
409 1.1 cgd if ((t = readtoken()) == TDO)
410 1.1 cgd t = TDONE;
411 1.1 cgd else if (t == TBEGIN)
412 1.1 cgd t = TEND;
413 1.1 cgd else
414 1.108 christos synexpect(-1, 0);
415 1.73 christos n1->nfor.body = list(0, 0);
416 1.1 cgd if (readtoken() != t)
417 1.108 christos synexpect(t, 0);
418 1.1 cgd checkkwd = 1;
419 1.1 cgd break;
420 1.1 cgd case TCASE:
421 1.101 christos n1 = stalloc(sizeof(struct ncase));
422 1.1 cgd n1->type = NCASE;
423 1.1 cgd if (readtoken() != TWORD)
424 1.108 christos synexpect(TWORD, 0);
425 1.101 christos n1->ncase.expr = n2 = stalloc(sizeof(struct narg));
426 1.1 cgd n2->type = NARG;
427 1.1 cgd n2->narg.text = wordtext;
428 1.1 cgd n2->narg.backquote = backquotelist;
429 1.1 cgd n2->narg.next = NULL;
430 1.1 cgd while (readtoken() == TNL);
431 1.1 cgd if (lasttoken != TWORD || ! equal(wordtext, "in"))
432 1.108 christos synexpect(-1, "in");
433 1.1 cgd cpp = &n1->ncase.cases;
434 1.48 christos noalias = 1;
435 1.15 jtc checkkwd = 2, readtoken();
436 1.87 christos /*
437 1.88 christos * Both ksh and bash accept 'case x in esac'
438 1.87 christos * so configure scripts started taking advantage of this.
439 1.88 christos * The page: http://pubs.opengroup.org/onlinepubs/\
440 1.88 christos * 009695399/utilities/xcu_chap02.html contradicts itself,
441 1.88 christos * as to if this is legal; the "Case Conditional Format"
442 1.88 christos * paragraph shows one case is required, but the "Grammar"
443 1.88 christos * section shows a grammar that explicitly allows the no
444 1.88 christos * case option.
445 1.87 christos */
446 1.87 christos while (lasttoken != TESAC) {
447 1.101 christos *cpp = cp = stalloc(sizeof(struct nclist));
448 1.61 christos if (lasttoken == TLP)
449 1.61 christos readtoken();
450 1.1 cgd cp->type = NCLIST;
451 1.1 cgd app = &cp->nclist.pattern;
452 1.1 cgd for (;;) {
453 1.101 christos *app = ap = stalloc(sizeof(struct narg));
454 1.1 cgd ap->type = NARG;
455 1.1 cgd ap->narg.text = wordtext;
456 1.1 cgd ap->narg.backquote = backquotelist;
457 1.15 jtc if (checkkwd = 2, readtoken() != TPIPE)
458 1.1 cgd break;
459 1.1 cgd app = &ap->narg.next;
460 1.16 jtc readtoken();
461 1.1 cgd }
462 1.1 cgd ap->narg.next = NULL;
463 1.48 christos noalias = 0;
464 1.48 christos if (lasttoken != TRP) {
465 1.108 christos synexpect(TRP, 0);
466 1.48 christos }
467 1.73 christos cp->nclist.body = list(0, 0);
468 1.15 jtc
469 1.15 jtc checkkwd = 2;
470 1.15 jtc if ((t = readtoken()) != TESAC) {
471 1.48 christos if (t != TENDCASE) {
472 1.48 christos noalias = 0;
473 1.108 christos synexpect(TENDCASE, 0);
474 1.48 christos } else {
475 1.48 christos noalias = 1;
476 1.48 christos checkkwd = 2;
477 1.48 christos readtoken();
478 1.48 christos }
479 1.15 jtc }
480 1.1 cgd cpp = &cp->nclist.next;
481 1.86 christos }
482 1.48 christos noalias = 0;
483 1.1 cgd *cpp = NULL;
484 1.1 cgd checkkwd = 1;
485 1.1 cgd break;
486 1.1 cgd case TLP:
487 1.101 christos n1 = stalloc(sizeof(struct nredir));
488 1.1 cgd n1->type = NSUBSHELL;
489 1.73 christos n1->nredir.n = list(0, 0);
490 1.1 cgd n1->nredir.redirect = NULL;
491 1.1 cgd if (readtoken() != TRP)
492 1.108 christos synexpect(TRP, 0);
493 1.1 cgd checkkwd = 1;
494 1.1 cgd break;
495 1.1 cgd case TBEGIN:
496 1.73 christos n1 = list(0, 0);
497 1.1 cgd if (readtoken() != TEND)
498 1.108 christos synexpect(TEND, 0);
499 1.1 cgd checkkwd = 1;
500 1.1 cgd break;
501 1.119 kre
502 1.19 mycroft case TSEMI:
503 1.119 kre case TAND:
504 1.119 kre case TOR:
505 1.119 kre case TPIPE:
506 1.119 kre case TNL:
507 1.119 kre case TEOF:
508 1.119 kre case TRP:
509 1.19 mycroft /*
510 1.119 kre * simple commands must have something in them,
511 1.119 kre * either a word (which at this point includes a=b)
512 1.119 kre * or a redirection. If we reached the end of the
513 1.119 kre * command (which one of these tokens indicates)
514 1.119 kre * when we are just starting, and have not had a
515 1.119 kre * redirect, then ...
516 1.119 kre *
517 1.119 kre * nb: it is still possible to end up with empty
518 1.119 kre * simple commands, if the "command" is a var
519 1.119 kre * expansion that produces nothing
520 1.119 kre * X= ; $X && $X
521 1.119 kre * --> &&
522 1.119 kre * I am not sure if this is intended to be legal or not.
523 1.19 mycroft */
524 1.19 mycroft if (!redir)
525 1.108 christos synexpect(-1, 0);
526 1.1 cgd case TWORD:
527 1.1 cgd tokpushback++;
528 1.31 christos n1 = simplecmd(rpp, redir);
529 1.31 christos goto checkneg;
530 1.97 christos case TENDCASE:
531 1.97 christos if (redir) {
532 1.97 christos tokpushback++;
533 1.97 christos goto checkneg;
534 1.97 christos }
535 1.97 christos /* FALLTHROUGH */
536 1.1 cgd default:
537 1.108 christos synexpect(-1, 0);
538 1.39 mycroft /* NOTREACHED */
539 1.1 cgd }
540 1.1 cgd
541 1.1 cgd /* Now check for redirection which may follow command */
542 1.1 cgd while (readtoken() == TREDIR) {
543 1.1 cgd *rpp = n2 = redirnode;
544 1.1 cgd rpp = &n2->nfile.next;
545 1.1 cgd parsefname();
546 1.1 cgd }
547 1.1 cgd tokpushback++;
548 1.1 cgd *rpp = NULL;
549 1.1 cgd if (redir) {
550 1.1 cgd if (n1->type != NSUBSHELL) {
551 1.101 christos n2 = stalloc(sizeof(struct nredir));
552 1.1 cgd n2->type = NREDIR;
553 1.1 cgd n2->nredir.n = n1;
554 1.1 cgd n1 = n2;
555 1.1 cgd }
556 1.1 cgd n1->nredir.redirect = redir;
557 1.1 cgd }
558 1.31 christos
559 1.31 christos checkneg:
560 1.31 christos if (negate) {
561 1.65 dsl TRACE(("negate command\n"));
562 1.101 christos n2 = stalloc(sizeof(struct nnot));
563 1.31 christos n2->type = NNOT;
564 1.31 christos n2->nnot.com = n1;
565 1.31 christos return n2;
566 1.31 christos }
567 1.31 christos else
568 1.31 christos return n1;
569 1.1 cgd }
570 1.1 cgd
571 1.1 cgd
572 1.1 cgd STATIC union node *
573 1.54 christos simplecmd(union node **rpp, union node *redir)
574 1.54 christos {
575 1.1 cgd union node *args, **app;
576 1.31 christos union node *n = NULL, *n2;
577 1.31 christos int negate = 0;
578 1.1 cgd
579 1.11 jtc /* If we don't have any redirections already, then we must reset */
580 1.11 jtc /* rpp to be the address of the local redir variable. */
581 1.5 sef if (redir == 0)
582 1.5 sef rpp = &redir;
583 1.5 sef
584 1.1 cgd args = NULL;
585 1.1 cgd app = &args;
586 1.11 jtc
587 1.31 christos while (readtoken() == TNOT) {
588 1.65 dsl TRACE(("simplcmd: TNOT recognized\n"));
589 1.31 christos negate = !negate;
590 1.31 christos }
591 1.31 christos tokpushback++;
592 1.31 christos
593 1.1 cgd for (;;) {
594 1.1 cgd if (readtoken() == TWORD) {
595 1.101 christos n = stalloc(sizeof(struct narg));
596 1.1 cgd n->type = NARG;
597 1.1 cgd n->narg.text = wordtext;
598 1.1 cgd n->narg.backquote = backquotelist;
599 1.1 cgd *app = n;
600 1.1 cgd app = &n->narg.next;
601 1.1 cgd } else if (lasttoken == TREDIR) {
602 1.1 cgd *rpp = n = redirnode;
603 1.1 cgd rpp = &n->nfile.next;
604 1.1 cgd parsefname(); /* read name of redirection file */
605 1.1 cgd } else if (lasttoken == TLP && app == &args->narg.next
606 1.110 christos && redir == 0) {
607 1.1 cgd /* We have a function */
608 1.1 cgd if (readtoken() != TRP)
609 1.108 christos synexpect(TRP, 0);
610 1.84 christos funclinno = plinno;
611 1.64 christos rmescapes(n->narg.text);
612 1.118 kre if (strchr(n->narg.text, '/'))
613 1.1 cgd synerror("Bad function name");
614 1.1 cgd n->type = NDEFUN;
615 1.1 cgd n->narg.next = command();
616 1.84 christos funclinno = 0;
617 1.31 christos goto checkneg;
618 1.1 cgd } else {
619 1.1 cgd tokpushback++;
620 1.1 cgd break;
621 1.1 cgd }
622 1.1 cgd }
623 1.1 cgd *app = NULL;
624 1.1 cgd *rpp = NULL;
625 1.101 christos n = stalloc(sizeof(struct ncmd));
626 1.1 cgd n->type = NCMD;
627 1.1 cgd n->ncmd.backgnd = 0;
628 1.1 cgd n->ncmd.args = args;
629 1.1 cgd n->ncmd.redirect = redir;
630 1.31 christos
631 1.31 christos checkneg:
632 1.31 christos if (negate) {
633 1.65 dsl TRACE(("negate simplecmd\n"));
634 1.101 christos n2 = stalloc(sizeof(struct nnot));
635 1.31 christos n2->type = NNOT;
636 1.31 christos n2->nnot.com = n;
637 1.31 christos return n2;
638 1.31 christos }
639 1.31 christos else
640 1.31 christos return n;
641 1.1 cgd }
642 1.1 cgd
643 1.18 jtc STATIC union node *
644 1.54 christos makename(void)
645 1.54 christos {
646 1.18 jtc union node *n;
647 1.18 jtc
648 1.101 christos n = stalloc(sizeof(struct narg));
649 1.18 jtc n->type = NARG;
650 1.18 jtc n->narg.next = NULL;
651 1.18 jtc n->narg.text = wordtext;
652 1.18 jtc n->narg.backquote = backquotelist;
653 1.18 jtc return n;
654 1.18 jtc }
655 1.18 jtc
656 1.95 christos void
657 1.95 christos fixredir(union node *n, const char *text, int err)
658 1.95 christos {
659 1.18 jtc TRACE(("Fix redir %s %d\n", text, err));
660 1.18 jtc if (!err)
661 1.18 jtc n->ndup.vname = NULL;
662 1.18 jtc
663 1.91 christos if (is_number(text))
664 1.91 christos n->ndup.dupfd = number(text);
665 1.18 jtc else if (text[0] == '-' && text[1] == '\0')
666 1.18 jtc n->ndup.dupfd = -1;
667 1.18 jtc else {
668 1.30 christos
669 1.18 jtc if (err)
670 1.18 jtc synerror("Bad fd number");
671 1.18 jtc else
672 1.18 jtc n->ndup.vname = makename();
673 1.18 jtc }
674 1.18 jtc }
675 1.18 jtc
676 1.1 cgd
677 1.1 cgd STATIC void
678 1.54 christos parsefname(void)
679 1.54 christos {
680 1.1 cgd union node *n = redirnode;
681 1.1 cgd
682 1.1 cgd if (readtoken() != TWORD)
683 1.108 christos synexpect(-1, 0);
684 1.1 cgd if (n->type == NHERE) {
685 1.1 cgd struct heredoc *here = heredoc;
686 1.1 cgd struct heredoc *p;
687 1.1 cgd
688 1.1 cgd if (quoteflag == 0)
689 1.1 cgd n->type = NXHERE;
690 1.1 cgd TRACE(("Here document %d\n", n->type));
691 1.1 cgd if (here->striptabs) {
692 1.1 cgd while (*wordtext == '\t')
693 1.1 cgd wordtext++;
694 1.1 cgd }
695 1.111 christos
696 1.111 christos /*
697 1.111 christos * this test is not really necessary, we are not
698 1.111 christos * required to expand wordtext, but there's no reason
699 1.111 christos * it cannot be $$ or something like that - that would
700 1.111 christos * not mean the pid, but literally two '$' characters.
701 1.111 christos * There is no need for limits on what the word can be.
702 1.111 christos * However, it needs to stay literal as entered, not
703 1.111 christos * have $ converted to CTLVAR or something, which as
704 1.111 christos * the parser is, at the minute, is impossible to prevent.
705 1.111 christos * So, leave it like this until the rest of the parser is fixed.
706 1.111 christos */
707 1.111 christos if (! noexpand(wordtext))
708 1.1 cgd synerror("Illegal eof marker for << redirection");
709 1.111 christos
710 1.1 cgd rmescapes(wordtext);
711 1.1 cgd here->eofmark = wordtext;
712 1.1 cgd here->next = NULL;
713 1.1 cgd if (heredoclist == NULL)
714 1.1 cgd heredoclist = here;
715 1.1 cgd else {
716 1.90 christos for (p = heredoclist ; p->next ; p = p->next)
717 1.90 christos continue;
718 1.1 cgd p->next = here;
719 1.1 cgd }
720 1.1 cgd } else if (n->type == NTOFD || n->type == NFROMFD) {
721 1.18 jtc fixredir(n, wordtext, 0);
722 1.1 cgd } else {
723 1.18 jtc n->nfile.fname = makename();
724 1.1 cgd }
725 1.1 cgd }
726 1.1 cgd
727 1.111 christos /*
728 1.111 christos * Check to see whether we are at the end of the here document. When this
729 1.111 christos * is called, c is set to the first character of the next input line. If
730 1.111 christos * we are at the end of the here document, this routine sets the c to PEOF.
731 1.111 christos * The new value of c is returned.
732 1.111 christos */
733 1.111 christos
734 1.111 christos static int
735 1.111 christos checkend(int c, char * const eofmark, const int striptabs)
736 1.111 christos {
737 1.111 christos if (striptabs) {
738 1.111 christos while (c == '\t')
739 1.111 christos c = pgetc();
740 1.111 christos }
741 1.111 christos if (c == PEOF) {
742 1.111 christos if (*eofmark == '\0')
743 1.111 christos return (c);
744 1.111 christos synerror(EOFhere);
745 1.111 christos }
746 1.111 christos if (c == *eofmark) {
747 1.111 christos int c2;
748 1.111 christos char *q;
749 1.111 christos
750 1.111 christos for (q = eofmark + 1; c2 = pgetc(), *q != '\0' && c2 == *q; q++)
751 1.111 christos ;
752 1.111 christos if ((c2 == PEOF || c2 == '\n') && *q == '\0') {
753 1.111 christos c = PEOF;
754 1.111 christos if (c2 == '\n') {
755 1.111 christos plinno++;
756 1.111 christos needprompt = doprompt;
757 1.111 christos }
758 1.111 christos } else {
759 1.111 christos pungetc();
760 1.111 christos pushstring(eofmark + 1, q - (eofmark + 1), NULL);
761 1.111 christos }
762 1.111 christos } else if (c == '\n' && *eofmark == '\0') {
763 1.111 christos c = PEOF;
764 1.111 christos plinno++;
765 1.111 christos needprompt = doprompt;
766 1.111 christos }
767 1.111 christos return (c);
768 1.111 christos }
769 1.111 christos
770 1.1 cgd
771 1.1 cgd /*
772 1.1 cgd * Input any here documents.
773 1.1 cgd */
774 1.1 cgd
775 1.1 cgd STATIC void
776 1.115 christos slurp_heredoc(char *const eofmark, const int striptabs, const int sq)
777 1.111 christos {
778 1.111 christos int c;
779 1.111 christos char *out;
780 1.111 christos
781 1.111 christos c = pgetc();
782 1.111 christos
783 1.111 christos /*
784 1.111 christos * If we hit EOF on the input, and the eofmark is a null string ('')
785 1.111 christos * we consider this empty line to be the eofmark, and exit without err.
786 1.111 christos */
787 1.111 christos if (c == PEOF && *eofmark != '\0')
788 1.111 christos synerror(EOFhere);
789 1.111 christos
790 1.111 christos STARTSTACKSTR(out);
791 1.111 christos
792 1.111 christos while ((c = checkend(c, eofmark, striptabs)) != PEOF) {
793 1.111 christos do {
794 1.111 christos if (sq) {
795 1.111 christos /*
796 1.111 christos * in single quoted mode (eofmark quoted)
797 1.111 christos * all we look for is \n so we can check
798 1.111 christos * for the epfmark - everything saved literally.
799 1.111 christos */
800 1.111 christos STPUTC(c, out);
801 1.111 christos if (c == '\n')
802 1.111 christos break;
803 1.111 christos continue;
804 1.111 christos }
805 1.111 christos /*
806 1.111 christos * In double quoted (non-quoted eofmark)
807 1.111 christos * we must handle \ followed by \n here
808 1.111 christos * otherwise we can mismatch the end mark.
809 1.111 christos * All other uses of \ will be handled later
810 1.111 christos * when the here doc is expanded.
811 1.111 christos *
812 1.111 christos * This also makes sure \\ followed by \n does
813 1.111 christos * not suppress the newline (the \ quotes itself)
814 1.111 christos */
815 1.111 christos if (c == '\\') { /* A backslash */
816 1.111 christos c = pgetc(); /* followed by */
817 1.111 christos if (c == '\n') /* a newline? */
818 1.111 christos continue; /* y:drop both */
819 1.111 christos STPUTC('\\', out); /* else keep \ */
820 1.111 christos }
821 1.111 christos STPUTC(c, out); /* keep the char */
822 1.111 christos if (c == '\n') /* at end of line */
823 1.111 christos break; /* look for eofmark */
824 1.111 christos
825 1.111 christos } while ((c = pgetc()) != PEOF);
826 1.111 christos
827 1.111 christos /*
828 1.111 christos * If we have read a line, and reached EOF, without
829 1.111 christos * finding the eofmark, whether the EOF comes before
830 1.111 christos * or immediately after the \n, that is an error.
831 1.111 christos */
832 1.111 christos if (c == PEOF || (c = pgetc()) == PEOF)
833 1.111 christos synerror(EOFhere);
834 1.111 christos }
835 1.111 christos STPUTC('\0', out);
836 1.111 christos
837 1.111 christos c = out - stackblock();
838 1.111 christos out = stackblock();
839 1.111 christos grabstackblock(c);
840 1.111 christos wordtext = out;
841 1.111 christos
842 1.111 christos TRACE(("Slurped a heredoc (to '%s')%s: len %d, \"%.16s\"...\n",
843 1.111 christos eofmark, striptabs ? " tab stripped" : "", c, wordtext));
844 1.111 christos }
845 1.111 christos
846 1.111 christos STATIC void
847 1.111 christos readheredocs(void)
848 1.54 christos {
849 1.1 cgd struct heredoc *here;
850 1.1 cgd union node *n;
851 1.1 cgd
852 1.1 cgd while (heredoclist) {
853 1.1 cgd here = heredoclist;
854 1.1 cgd heredoclist = here->next;
855 1.1 cgd if (needprompt) {
856 1.11 jtc setprompt(2);
857 1.1 cgd needprompt = 0;
858 1.1 cgd }
859 1.111 christos
860 1.111 christos slurp_heredoc(here->eofmark, here->striptabs,
861 1.111 christos here->here->nhere.type == NHERE);
862 1.111 christos
863 1.101 christos n = stalloc(sizeof(struct narg));
864 1.1 cgd n->narg.type = NARG;
865 1.1 cgd n->narg.next = NULL;
866 1.1 cgd n->narg.text = wordtext;
867 1.1 cgd n->narg.backquote = backquotelist;
868 1.1 cgd here->here->nhere.doc = n;
869 1.1 cgd
870 1.115 christos if (here->here->nhere.type == NHERE)
871 1.115 christos continue;
872 1.111 christos
873 1.115 christos /*
874 1.115 christos * Now "parse" here docs that have unquoted eofmarkers.
875 1.115 christos */
876 1.115 christos setinputstring(wordtext, 1);
877 1.115 christos readtoken1(pgetc(), DQSYNTAX, 1);
878 1.115 christos n->narg.text = wordtext;
879 1.115 christos n->narg.backquote = backquotelist;
880 1.115 christos popfile();
881 1.115 christos }
882 1.111 christos }
883 1.111 christos
884 1.1 cgd STATIC int
885 1.54 christos peektoken(void)
886 1.54 christos {
887 1.1 cgd int t;
888 1.1 cgd
889 1.1 cgd t = readtoken();
890 1.1 cgd tokpushback++;
891 1.1 cgd return (t);
892 1.1 cgd }
893 1.1 cgd
894 1.1 cgd STATIC int
895 1.54 christos readtoken(void)
896 1.54 christos {
897 1.1 cgd int t;
898 1.11 jtc int savecheckkwd = checkkwd;
899 1.1 cgd #ifdef DEBUG
900 1.1 cgd int alreadyseen = tokpushback;
901 1.1 cgd #endif
902 1.48 christos struct alias *ap;
903 1.30 christos
904 1.11 jtc top:
905 1.1 cgd t = xxreadtoken();
906 1.1 cgd
907 1.1 cgd if (checkkwd) {
908 1.1 cgd /*
909 1.1 cgd * eat newlines
910 1.1 cgd */
911 1.1 cgd if (checkkwd == 2) {
912 1.1 cgd checkkwd = 0;
913 1.1 cgd while (t == TNL) {
914 1.111 christos readheredocs();
915 1.1 cgd t = xxreadtoken();
916 1.1 cgd }
917 1.1 cgd } else
918 1.1 cgd checkkwd = 0;
919 1.1 cgd /*
920 1.11 jtc * check for keywords and aliases
921 1.1 cgd */
922 1.95 christos if (t == TWORD && !quoteflag) {
923 1.43 christos const char *const *pp;
924 1.1 cgd
925 1.43 christos for (pp = parsekwd; *pp; pp++) {
926 1.95 christos if (**pp == *wordtext && equal(*pp, wordtext)) {
927 1.90 christos lasttoken = t = pp -
928 1.43 christos parsekwd + KWDOFFSET;
929 1.1 cgd TRACE(("keyword %s recognized\n", tokname[t]));
930 1.11 jtc goto out;
931 1.1 cgd }
932 1.1 cgd }
933 1.90 christos if (!noalias &&
934 1.48 christos (ap = lookupalias(wordtext, 1)) != NULL) {
935 1.11 jtc pushstring(ap->val, strlen(ap->val), ap);
936 1.11 jtc checkkwd = savecheckkwd;
937 1.11 jtc goto top;
938 1.11 jtc }
939 1.1 cgd }
940 1.11 jtc out:
941 1.31 christos checkkwd = (t == TNOT) ? savecheckkwd : 0;
942 1.1 cgd }
943 1.65 dsl TRACE(("%stoken %s %s\n", alreadyseen ? "reread " : "", tokname[t], t == TWORD ? wordtext : ""));
944 1.1 cgd return (t);
945 1.1 cgd }
946 1.1 cgd
947 1.1 cgd
948 1.1 cgd /*
949 1.1 cgd * Read the next input token.
950 1.1 cgd * If the token is a word, we set backquotelist to the list of cmds in
951 1.1 cgd * backquotes. We set quoteflag to true if any part of the word was
952 1.1 cgd * quoted.
953 1.1 cgd * If the token is TREDIR, then we set redirnode to a structure containing
954 1.1 cgd * the redirection.
955 1.1 cgd * In all cases, the variable startlinno is set to the number of the line
956 1.1 cgd * on which the token starts.
957 1.1 cgd *
958 1.1 cgd * [Change comment: here documents and internal procedures]
959 1.1 cgd * [Readtoken shouldn't have any arguments. Perhaps we should make the
960 1.1 cgd * word parsing code into a separate routine. In this case, readtoken
961 1.1 cgd * doesn't need to have any internal procedures, but parseword does.
962 1.1 cgd * We could also make parseoperator in essence the main routine, and
963 1.1 cgd * have parseword (readtoken1?) handle both words and redirection.]
964 1.1 cgd */
965 1.1 cgd
966 1.1 cgd #define RETURN(token) return lasttoken = token
967 1.1 cgd
968 1.1 cgd STATIC int
969 1.54 christos xxreadtoken(void)
970 1.54 christos {
971 1.32 tls int c;
972 1.1 cgd
973 1.1 cgd if (tokpushback) {
974 1.1 cgd tokpushback = 0;
975 1.1 cgd return lasttoken;
976 1.1 cgd }
977 1.1 cgd if (needprompt) {
978 1.11 jtc setprompt(2);
979 1.1 cgd needprompt = 0;
980 1.1 cgd }
981 1.1 cgd startlinno = plinno;
982 1.1 cgd for (;;) { /* until token or start of word found */
983 1.1 cgd c = pgetc_macro();
984 1.1 cgd switch (c) {
985 1.1 cgd case ' ': case '\t':
986 1.1 cgd continue;
987 1.1 cgd case '#':
988 1.90 christos while ((c = pgetc()) != '\n' && c != PEOF)
989 1.90 christos continue;
990 1.1 cgd pungetc();
991 1.1 cgd continue;
992 1.108 christos
993 1.1 cgd case '\n':
994 1.1 cgd plinno++;
995 1.1 cgd needprompt = doprompt;
996 1.1 cgd RETURN(TNL);
997 1.1 cgd case PEOF:
998 1.1 cgd RETURN(TEOF);
999 1.108 christos
1000 1.1 cgd case '&':
1001 1.1 cgd if (pgetc() == '&')
1002 1.1 cgd RETURN(TAND);
1003 1.1 cgd pungetc();
1004 1.1 cgd RETURN(TBACKGND);
1005 1.1 cgd case '|':
1006 1.1 cgd if (pgetc() == '|')
1007 1.1 cgd RETURN(TOR);
1008 1.1 cgd pungetc();
1009 1.1 cgd RETURN(TPIPE);
1010 1.1 cgd case ';':
1011 1.1 cgd if (pgetc() == ';')
1012 1.1 cgd RETURN(TENDCASE);
1013 1.1 cgd pungetc();
1014 1.1 cgd RETURN(TSEMI);
1015 1.1 cgd case '(':
1016 1.1 cgd RETURN(TLP);
1017 1.1 cgd case ')':
1018 1.1 cgd RETURN(TRP);
1019 1.108 christos
1020 1.108 christos case '\\':
1021 1.108 christos switch (pgetc()) {
1022 1.108 christos case '\n':
1023 1.108 christos startlinno = ++plinno;
1024 1.108 christos if (doprompt)
1025 1.108 christos setprompt(2);
1026 1.108 christos else
1027 1.108 christos setprompt(0);
1028 1.108 christos continue;
1029 1.108 christos case PEOF:
1030 1.108 christos RETURN(TEOF);
1031 1.108 christos default:
1032 1.108 christos pungetc();
1033 1.108 christos break;
1034 1.108 christos }
1035 1.108 christos /* FALLTHROUGH */
1036 1.1 cgd default:
1037 1.111 christos return readtoken1(c, BASESYNTAX, 0);
1038 1.1 cgd }
1039 1.1 cgd }
1040 1.1 cgd #undef RETURN
1041 1.1 cgd }
1042 1.1 cgd
1043 1.1 cgd
1044 1.1 cgd
1045 1.1 cgd /*
1046 1.1 cgd * If eofmark is NULL, read a word or a redirection symbol. If eofmark
1047 1.1 cgd * is not NULL, read a here document. In the latter case, eofmark is the
1048 1.1 cgd * word which marks the end of the document and striptabs is true if
1049 1.1 cgd * leading tabs should be stripped from the document. The argument firstc
1050 1.1 cgd * is the first character of the input token or document.
1051 1.1 cgd *
1052 1.1 cgd * Because C does not have internal subroutines, I have simulated them
1053 1.1 cgd * using goto's to implement the subroutine linkage. The following macros
1054 1.1 cgd * will run code that appears at the end of readtoken1.
1055 1.1 cgd */
1056 1.1 cgd
1057 1.96 christos /*
1058 1.96 christos * We used to remember only the current syntax, variable nesting level,
1059 1.102 christos * double quote state for each var nesting level, and arith nesting
1060 1.96 christos * level (unrelated to var nesting) and one prev syntax when in arith
1061 1.96 christos * syntax. This worked for simple cases, but can't handle arith inside
1062 1.96 christos * var expansion inside arith inside var with some quoted and some not.
1063 1.96 christos *
1064 1.96 christos * Inspired by FreeBSD's implementation (though it was the obvious way)
1065 1.96 christos * though implemented differently, we now have a stack that keeps track
1066 1.96 christos * of what we are doing now, and what we were doing previously.
1067 1.96 christos * Every time something changes, which will eventually end and should
1068 1.96 christos * revert to the previous state, we push this stack, and then pop it
1069 1.96 christos * again later (that is every ${} with an operator (to parse the word
1070 1.102 christos * or pattern that follows) ${x} and $x are too simple to need it)
1071 1.96 christos * $(( )) $( ) and "...". Always. Really, always!
1072 1.96 christos *
1073 1.96 christos * The stack is implemented as one static (on the C stack) base block
1074 1.96 christos * containing LEVELS_PER_BLOCK (8) stack entries, which should be
1075 1.96 christos * enough for the vast majority of cases. For torture tests, we
1076 1.96 christos * malloc more blocks as needed. All accesses through the inline
1077 1.96 christos * functions below.
1078 1.96 christos */
1079 1.96 christos
1080 1.96 christos /*
1081 1.96 christos * varnest & arinest will typically be 0 or 1
1082 1.96 christos * (varnest can increment in usages like ${x=${y}} but probably
1083 1.96 christos * does not really need to)
1084 1.96 christos * parenlevel allows balancing parens inside a $(( )), it is reset
1085 1.96 christos * at each new nesting level ( $(( ( x + 3 ${unset-)} )) does not work.
1086 1.96 christos * quoted is special - we need to know 2 things ... are we inside "..."
1087 1.96 christos * (even if inherited from some previous nesting level) and was there
1088 1.96 christos * an opening '"' at this level (so the next will be closing).
1089 1.106 christos * "..." can span nesting levels, but cannot be opened in one and
1090 1.96 christos * closed in a different one.
1091 1.96 christos * To handle this, "quoted" has two fields, the bottom 4 (really 2)
1092 1.96 christos * bits are 0, 1, or 2, for un, single, and double quoted (single quoted
1093 1.96 christos * is really so special that this setting is not very important)
1094 1.96 christos * and 0x10 that indicates that an opening quote has been seen.
1095 1.96 christos * The bottom 4 bits are inherited, the 0x10 bit is not.
1096 1.96 christos */
1097 1.96 christos struct tokenstate {
1098 1.96 christos const char *ts_syntax;
1099 1.96 christos unsigned short ts_parenlevel; /* counters */
1100 1.96 christos unsigned short ts_varnest; /* 64000 levels should be enough! */
1101 1.96 christos unsigned short ts_arinest;
1102 1.96 christos unsigned short ts_quoted; /* 1 -> single, 2 -> double */
1103 1.96 christos };
1104 1.96 christos
1105 1.106 christos #define NQ 0x00 /* Unquoted */
1106 1.106 christos #define SQ 0x01 /* Single Quotes */
1107 1.106 christos #define DQ 0x02 /* Double Quotes (or equivalent) */
1108 1.106 christos #define QF 0x0F /* Mask to extract previous values */
1109 1.106 christos #define QS 0x10 /* Quoting started at this level in stack */
1110 1.96 christos
1111 1.96 christos #define LEVELS_PER_BLOCK 8
1112 1.103 christos #define VSS struct statestack
1113 1.96 christos
1114 1.96 christos struct statestack {
1115 1.96 christos VSS *prev; /* previous block in list */
1116 1.96 christos int cur; /* which of our tokenstates is current */
1117 1.96 christos struct tokenstate tokenstate[LEVELS_PER_BLOCK];
1118 1.96 christos };
1119 1.96 christos
1120 1.103 christos static inline struct tokenstate *
1121 1.96 christos currentstate(VSS *stack)
1122 1.96 christos {
1123 1.96 christos return &stack->tokenstate[stack->cur];
1124 1.96 christos }
1125 1.96 christos
1126 1.103 christos static inline struct tokenstate *
1127 1.96 christos prevstate(VSS *stack)
1128 1.96 christos {
1129 1.96 christos if (stack->cur != 0)
1130 1.96 christos return &stack->tokenstate[stack->cur - 1];
1131 1.96 christos if (stack->prev == NULL) /* cannot drop below base */
1132 1.96 christos return &stack->tokenstate[0];
1133 1.96 christos return &stack->prev->tokenstate[LEVELS_PER_BLOCK - 1];
1134 1.96 christos }
1135 1.96 christos
1136 1.96 christos static inline VSS *
1137 1.96 christos bump_state_level(VSS *stack)
1138 1.96 christos {
1139 1.103 christos struct tokenstate *os, *ts;
1140 1.96 christos
1141 1.96 christos os = currentstate(stack);
1142 1.96 christos
1143 1.96 christos if (++stack->cur >= LEVELS_PER_BLOCK) {
1144 1.96 christos VSS *ss;
1145 1.96 christos
1146 1.96 christos ss = (VSS *)ckmalloc(sizeof (struct statestack));
1147 1.96 christos ss->cur = 0;
1148 1.96 christos ss->prev = stack;
1149 1.96 christos stack = ss;
1150 1.96 christos }
1151 1.96 christos
1152 1.96 christos ts = currentstate(stack);
1153 1.96 christos
1154 1.96 christos ts->ts_parenlevel = 0; /* parens inside never match outside */
1155 1.96 christos
1156 1.96 christos ts->ts_quoted = os->ts_quoted & QF; /* these are default settings */
1157 1.96 christos ts->ts_varnest = os->ts_varnest;
1158 1.96 christos ts->ts_arinest = os->ts_arinest; /* when appropriate */
1159 1.96 christos ts->ts_syntax = os->ts_syntax; /* they will be altered */
1160 1.96 christos
1161 1.96 christos return stack;
1162 1.96 christos }
1163 1.96 christos
1164 1.96 christos static inline VSS *
1165 1.96 christos drop_state_level(VSS *stack)
1166 1.96 christos {
1167 1.96 christos if (stack->cur == 0) {
1168 1.96 christos VSS *ss;
1169 1.96 christos
1170 1.96 christos ss = stack;
1171 1.96 christos stack = ss->prev;
1172 1.96 christos if (stack == NULL)
1173 1.96 christos return ss;
1174 1.106 christos ckfree(ss);
1175 1.96 christos }
1176 1.96 christos --stack->cur;
1177 1.96 christos return stack;
1178 1.96 christos }
1179 1.96 christos
1180 1.96 christos static inline void
1181 1.96 christos cleanup_state_stack(VSS *stack)
1182 1.96 christos {
1183 1.96 christos while (stack->prev != NULL) {
1184 1.96 christos stack->cur = 0;
1185 1.96 christos stack = drop_state_level(stack);
1186 1.96 christos }
1187 1.96 christos }
1188 1.96 christos
1189 1.95 christos #define PARSESUB() {goto parsesub; parsesub_return:;}
1190 1.11 jtc #define PARSEARITH() {goto parsearith; parsearith_return:;}
1191 1.1 cgd
1192 1.52 christos /*
1193 1.96 christos * The following macros all assume the existance of a local var "stack"
1194 1.96 christos * which contains a pointer to the current struct stackstate
1195 1.52 christos */
1196 1.51 christos
1197 1.96 christos /*
1198 1.96 christos * These are macros rather than inline funcs to avoid code churn as much
1199 1.96 christos * as possible - they replace macros of the same name used previously.
1200 1.96 christos */
1201 1.96 christos #define ISDBLQUOTE() (currentstate(stack)->ts_quoted & QS)
1202 1.96 christos #define SETDBLQUOTE() (currentstate(stack)->ts_quoted = QS | DQ)
1203 1.96 christos #define CLRDBLQUOTE() (currentstate(stack)->ts_quoted = \
1204 1.96 christos stack->cur != 0 || stack->prev ? \
1205 1.96 christos prevstate(stack)->ts_quoted & QF : 0)
1206 1.96 christos
1207 1.96 christos /*
1208 1.96 christos * This set are just to avoid excess typing and line lengths...
1209 1.96 christos * The ones that "look like" var names must be implemented to be lvalues
1210 1.96 christos */
1211 1.96 christos #define syntax (currentstate(stack)->ts_syntax)
1212 1.96 christos #define parenlevel (currentstate(stack)->ts_parenlevel)
1213 1.96 christos #define varnest (currentstate(stack)->ts_varnest)
1214 1.96 christos #define arinest (currentstate(stack)->ts_arinest)
1215 1.96 christos #define quoted (currentstate(stack)->ts_quoted)
1216 1.106 christos #define TS_PUSH() (stack = bump_state_level(stack))
1217 1.106 christos #define TS_POP() (stack = drop_state_level(stack))
1218 1.106 christos
1219 1.106 christos /*
1220 1.106 christos * Called to parse command substitutions. oldstyle is true if the command
1221 1.106 christos * is enclosed inside `` (otherwise it was enclosed in "$( )")
1222 1.106 christos *
1223 1.106 christos * Internally nlpp is a pointer to the head of the linked
1224 1.106 christos * list of commands (passed by reference), and savelen is the number of
1225 1.106 christos * characters on the top of the stack which must be preserved.
1226 1.106 christos */
1227 1.106 christos static char *
1228 1.107 christos parsebackq(VSS *const stack, char * const in,
1229 1.106 christos struct nodelist **const pbqlist, const int oldstyle)
1230 1.106 christos {
1231 1.106 christos struct nodelist **nlpp;
1232 1.109 christos const int savepbq = parsebackquote;
1233 1.106 christos union node *n;
1234 1.107 christos char *out;
1235 1.106 christos char *str = NULL;
1236 1.106 christos char *volatile sstr = str;
1237 1.106 christos struct jmploc jmploc;
1238 1.106 christos struct jmploc *const savehandler = handler;
1239 1.109 christos const int savelen = in - stackblock();
1240 1.106 christos int saveprompt;
1241 1.106 christos
1242 1.106 christos if (setjmp(jmploc.loc)) {
1243 1.106 christos if (sstr)
1244 1.106 christos ckfree(__UNVOLATILE(sstr));
1245 1.106 christos cleanup_state_stack(stack);
1246 1.106 christos parsebackquote = 0;
1247 1.106 christos handler = savehandler;
1248 1.106 christos longjmp(handler->loc, 1);
1249 1.106 christos }
1250 1.106 christos INTOFF;
1251 1.106 christos sstr = str = NULL;
1252 1.106 christos if (savelen > 0) {
1253 1.106 christos sstr = str = ckmalloc(savelen);
1254 1.106 christos memcpy(str, stackblock(), savelen);
1255 1.106 christos }
1256 1.106 christos handler = &jmploc;
1257 1.106 christos INTON;
1258 1.106 christos if (oldstyle) {
1259 1.106 christos /* We must read until the closing backquote, giving special
1260 1.106 christos treatment to some slashes, and then push the string and
1261 1.106 christos reread it as input, interpreting it normally. */
1262 1.106 christos int pc;
1263 1.106 christos int psavelen;
1264 1.106 christos char *pstr;
1265 1.106 christos
1266 1.106 christos /*
1267 1.106 christos * Because the entire `...` is read here, we don't
1268 1.106 christos * need to bother the state stack. That will be used
1269 1.106 christos * (as appropriate) when the processed string is re-read.
1270 1.106 christos */
1271 1.109 christos STARTSTACKSTR(out);
1272 1.106 christos for (;;) {
1273 1.106 christos if (needprompt) {
1274 1.106 christos setprompt(2);
1275 1.106 christos needprompt = 0;
1276 1.106 christos }
1277 1.106 christos switch (pc = pgetc()) {
1278 1.106 christos case '`':
1279 1.106 christos goto done;
1280 1.106 christos
1281 1.106 christos case '\\':
1282 1.106 christos if ((pc = pgetc()) == '\n') {
1283 1.106 christos plinno++;
1284 1.106 christos if (doprompt)
1285 1.106 christos setprompt(2);
1286 1.106 christos else
1287 1.106 christos setprompt(0);
1288 1.106 christos /*
1289 1.106 christos * If eating a newline, avoid putting
1290 1.106 christos * the newline into the new character
1291 1.106 christos * stream (via the STPUTC after the
1292 1.106 christos * switch).
1293 1.106 christos */
1294 1.106 christos continue;
1295 1.106 christos }
1296 1.106 christos if (pc != '\\' && pc != '`' && pc != '$'
1297 1.106 christos && (!ISDBLQUOTE() || pc != '"'))
1298 1.109 christos STPUTC('\\', out);
1299 1.106 christos break;
1300 1.106 christos
1301 1.106 christos case '\n':
1302 1.106 christos plinno++;
1303 1.106 christos needprompt = doprompt;
1304 1.106 christos break;
1305 1.106 christos
1306 1.106 christos case PEOF:
1307 1.106 christos startlinno = plinno;
1308 1.106 christos synerror("EOF in backquote substitution");
1309 1.106 christos break;
1310 1.106 christos
1311 1.106 christos default:
1312 1.106 christos break;
1313 1.106 christos }
1314 1.109 christos STPUTC(pc, out);
1315 1.106 christos }
1316 1.106 christos done:
1317 1.109 christos STPUTC('\0', out);
1318 1.109 christos psavelen = out - stackblock();
1319 1.106 christos if (psavelen > 0) {
1320 1.109 christos pstr = grabstackstr(out);
1321 1.106 christos setinputstring(pstr, 1);
1322 1.106 christos }
1323 1.106 christos }
1324 1.106 christos nlpp = pbqlist;
1325 1.106 christos while (*nlpp)
1326 1.106 christos nlpp = &(*nlpp)->next;
1327 1.106 christos *nlpp = stalloc(sizeof(struct nodelist));
1328 1.106 christos (*nlpp)->next = NULL;
1329 1.106 christos parsebackquote = oldstyle;
1330 1.106 christos
1331 1.106 christos if (oldstyle) {
1332 1.106 christos saveprompt = doprompt;
1333 1.106 christos doprompt = 0;
1334 1.106 christos } else
1335 1.106 christos saveprompt = 0;
1336 1.106 christos
1337 1.106 christos n = list(0, oldstyle);
1338 1.106 christos
1339 1.106 christos if (oldstyle)
1340 1.106 christos doprompt = saveprompt;
1341 1.106 christos else {
1342 1.106 christos if (readtoken() != TRP) {
1343 1.106 christos cleanup_state_stack(stack);
1344 1.108 christos synexpect(TRP, 0);
1345 1.106 christos }
1346 1.106 christos }
1347 1.106 christos
1348 1.106 christos (*nlpp)->n = n;
1349 1.106 christos if (oldstyle) {
1350 1.106 christos /*
1351 1.106 christos * Start reading from old file again, ignoring any pushed back
1352 1.106 christos * tokens left from the backquote parsing
1353 1.106 christos */
1354 1.106 christos popfile();
1355 1.106 christos tokpushback = 0;
1356 1.106 christos }
1357 1.109 christos
1358 1.106 christos while (stackblocksize() <= savelen)
1359 1.106 christos growstackblock();
1360 1.109 christos STARTSTACKSTR(out);
1361 1.106 christos if (str) {
1362 1.109 christos memcpy(out, str, savelen);
1363 1.109 christos STADJUST(savelen, out);
1364 1.106 christos INTOFF;
1365 1.106 christos ckfree(str);
1366 1.106 christos sstr = str = NULL;
1367 1.106 christos INTON;
1368 1.106 christos }
1369 1.106 christos parsebackquote = savepbq;
1370 1.106 christos handler = savehandler;
1371 1.106 christos if (arinest || ISDBLQUOTE())
1372 1.109 christos USTPUTC(CTLBACKQ | CTLQUOTE, out);
1373 1.106 christos else
1374 1.109 christos USTPUTC(CTLBACKQ, out);
1375 1.106 christos
1376 1.109 christos return out;
1377 1.106 christos }
1378 1.94 christos
1379 1.112 christos /*
1380 1.112 christos * Parse a redirection operator. The parameter "out" points to a string
1381 1.112 christos * specifying the fd to be redirected. It is guaranteed to be either ""
1382 1.112 christos * or a numeric string (for now anyway). The parameter "c" contains the
1383 1.112 christos * first character of the redirection operator.
1384 1.112 christos *
1385 1.112 christos * Note the string "out" is on the stack, which we are about to clobber,
1386 1.112 christos * so process it first...
1387 1.112 christos */
1388 1.112 christos
1389 1.112 christos static void
1390 1.112 christos parseredir(const char *out, int c)
1391 1.112 christos {
1392 1.112 christos union node *np;
1393 1.112 christos int fd;
1394 1.112 christos
1395 1.112 christos fd = (*out == '\0') ? -1 : atoi(out);
1396 1.112 christos
1397 1.112 christos np = stalloc(sizeof(struct nfile));
1398 1.112 christos if (c == '>') {
1399 1.112 christos if (fd < 0)
1400 1.112 christos fd = 1;
1401 1.112 christos c = pgetc();
1402 1.112 christos if (c == '>')
1403 1.112 christos np->type = NAPPEND;
1404 1.112 christos else if (c == '|')
1405 1.112 christos np->type = NCLOBBER;
1406 1.112 christos else if (c == '&')
1407 1.112 christos np->type = NTOFD;
1408 1.112 christos else {
1409 1.112 christos np->type = NTO;
1410 1.112 christos pungetc();
1411 1.112 christos }
1412 1.112 christos } else { /* c == '<' */
1413 1.112 christos if (fd < 0)
1414 1.112 christos fd = 0;
1415 1.112 christos switch (c = pgetc()) {
1416 1.112 christos case '<':
1417 1.112 christos if (sizeof (struct nfile) != sizeof (struct nhere)) {
1418 1.112 christos np = stalloc(sizeof(struct nhere));
1419 1.112 christos np->nfile.fd = 0;
1420 1.112 christos }
1421 1.112 christos np->type = NHERE;
1422 1.112 christos heredoc = stalloc(sizeof(struct heredoc));
1423 1.112 christos heredoc->here = np;
1424 1.116 christos heredoc->startline = plinno;
1425 1.112 christos if ((c = pgetc()) == '-') {
1426 1.112 christos heredoc->striptabs = 1;
1427 1.112 christos } else {
1428 1.112 christos heredoc->striptabs = 0;
1429 1.112 christos pungetc();
1430 1.112 christos }
1431 1.112 christos break;
1432 1.112 christos
1433 1.112 christos case '&':
1434 1.112 christos np->type = NFROMFD;
1435 1.112 christos break;
1436 1.112 christos
1437 1.112 christos case '>':
1438 1.112 christos np->type = NFROMTO;
1439 1.112 christos break;
1440 1.112 christos
1441 1.112 christos default:
1442 1.112 christos np->type = NFROM;
1443 1.112 christos pungetc();
1444 1.112 christos break;
1445 1.112 christos }
1446 1.112 christos }
1447 1.112 christos np->nfile.fd = fd;
1448 1.112 christos
1449 1.112 christos redirnode = np; /* this is the "value" of TRENODE */
1450 1.112 christos }
1451 1.112 christos
1452 1.112 christos
1453 1.112 christos /*
1454 1.112 christos * The lowest level basic tokenizer.
1455 1.112 christos *
1456 1.112 christos * The next input byte (character) is in firstc, syn says which
1457 1.112 christos * syntax tables we are to use (basic, single or double quoted, or arith)
1458 1.112 christos * and magicq (used with sqsyntax and dqsyntax only) indicates that the
1459 1.112 christos * quote character itself is not special (used parsing here docs and similar)
1460 1.112 christos *
1461 1.112 christos * The result is the type of the next token (its value, when there is one,
1462 1.112 christos * is saved in the relevant global var - must fix that someday!) which is
1463 1.112 christos * also saved for re-reading ("lasttoken").
1464 1.112 christos *
1465 1.112 christos * Overall, this routine does far more parsing than it is supposed to.
1466 1.112 christos * That will also need fixing, someday...
1467 1.112 christos */
1468 1.1 cgd STATIC int
1469 1.111 christos readtoken1(int firstc, char const *syn, int magicq)
1470 1.54 christos {
1471 1.113 christos int c;
1472 1.103 christos char * out;
1473 1.1 cgd int len;
1474 1.1 cgd struct nodelist *bqlist;
1475 1.106 christos int quotef;
1476 1.96 christos VSS static_stack;
1477 1.106 christos VSS *stack = &static_stack;
1478 1.96 christos
1479 1.96 christos stack->prev = NULL;
1480 1.96 christos stack->cur = 0;
1481 1.96 christos
1482 1.96 christos syntax = syn;
1483 1.1 cgd
1484 1.1 cgd startlinno = plinno;
1485 1.51 christos varnest = 0;
1486 1.99 christos quoted = 0;
1487 1.108 christos if (syntax == DQSYNTAX)
1488 1.51 christos SETDBLQUOTE();
1489 1.1 cgd quotef = 0;
1490 1.1 cgd bqlist = NULL;
1491 1.11 jtc arinest = 0;
1492 1.11 jtc parenlevel = 0;
1493 1.11 jtc
1494 1.1 cgd STARTSTACKSTR(out);
1495 1.113 christos
1496 1.113 christos for (c = firstc ;; c = pgetc_macro()) { /* until of token */
1497 1.113 christos CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */
1498 1.113 christos switch (syntax[c]) {
1499 1.113 christos case CNL: /* '\n' */
1500 1.113 christos if (syntax == BASESYNTAX)
1501 1.113 christos break; /* exit loop */
1502 1.113 christos USTPUTC(c, out);
1503 1.113 christos plinno++;
1504 1.113 christos if (doprompt)
1505 1.113 christos setprompt(2);
1506 1.113 christos else
1507 1.113 christos setprompt(0);
1508 1.113 christos continue;
1509 1.113 christos
1510 1.113 christos case CWORD:
1511 1.113 christos USTPUTC(c, out);
1512 1.113 christos continue;
1513 1.113 christos case CCTL:
1514 1.113 christos if (!magicq || ISDBLQUOTE())
1515 1.113 christos USTPUTC(CTLESC, out);
1516 1.113 christos USTPUTC(c, out);
1517 1.113 christos continue;
1518 1.113 christos case CBACK: /* backslash */
1519 1.113 christos c = pgetc();
1520 1.113 christos if (c == PEOF) {
1521 1.113 christos USTPUTC('\\', out);
1522 1.113 christos pungetc();
1523 1.113 christos continue;
1524 1.113 christos }
1525 1.113 christos if (c == '\n') {
1526 1.1 cgd plinno++;
1527 1.11 jtc if (doprompt)
1528 1.11 jtc setprompt(2);
1529 1.11 jtc else
1530 1.11 jtc setprompt(0);
1531 1.113 christos continue;
1532 1.113 christos }
1533 1.113 christos quotef = 1; /* current token is quoted */
1534 1.113 christos if (ISDBLQUOTE() && c != '\\' && c != '`' &&
1535 1.113 christos c != '$' && (c != '"' || magicq))
1536 1.113 christos USTPUTC('\\', out);
1537 1.113 christos if (SQSYNTAX[c] == CCTL)
1538 1.113 christos USTPUTC(CTLESC, out);
1539 1.113 christos else if (!magicq) {
1540 1.113 christos USTPUTC(CTLQUOTEMARK, out);
1541 1.59 dsl USTPUTC(c, out);
1542 1.113 christos if (varnest != 0)
1543 1.113 christos USTPUTC(CTLQUOTEEND, out);
1544 1.113 christos continue;
1545 1.113 christos }
1546 1.113 christos USTPUTC(c, out);
1547 1.113 christos continue;
1548 1.113 christos case CSQUOTE:
1549 1.113 christos if (syntax != SQSYNTAX) {
1550 1.113 christos if (!magicq)
1551 1.113 christos USTPUTC(CTLQUOTEMARK, out);
1552 1.113 christos quotef = 1;
1553 1.113 christos TS_PUSH();
1554 1.113 christos syntax = SQSYNTAX;
1555 1.113 christos quoted = SQ;
1556 1.113 christos continue;
1557 1.113 christos }
1558 1.113 christos if (magicq && arinest == 0 && varnest == 0) {
1559 1.113 christos /* Ignore inside quoted here document */
1560 1.1 cgd USTPUTC(c, out);
1561 1.113 christos continue;
1562 1.113 christos }
1563 1.113 christos /* End of single quotes... */
1564 1.113 christos TS_POP();
1565 1.113 christos if (syntax == BASESYNTAX && varnest != 0)
1566 1.113 christos USTPUTC(CTLQUOTEEND, out);
1567 1.113 christos continue;
1568 1.113 christos case CDQUOTE:
1569 1.113 christos if (magicq && arinest == 0 && varnest == 0) {
1570 1.113 christos /* Ignore inside here document */
1571 1.56 dsl USTPUTC(c, out);
1572 1.113 christos continue;
1573 1.113 christos }
1574 1.113 christos quotef = 1;
1575 1.113 christos if (arinest) {
1576 1.56 dsl if (ISDBLQUOTE()) {
1577 1.96 christos TS_POP();
1578 1.1 cgd } else {
1579 1.96 christos TS_PUSH();
1580 1.56 dsl syntax = DQSYNTAX;
1581 1.56 dsl SETDBLQUOTE();
1582 1.56 dsl USTPUTC(CTLQUOTEMARK, out);
1583 1.1 cgd }
1584 1.113 christos continue;
1585 1.113 christos }
1586 1.113 christos if (magicq)
1587 1.113 christos continue;
1588 1.113 christos if (ISDBLQUOTE()) {
1589 1.113 christos TS_POP();
1590 1.113 christos if (varnest != 0)
1591 1.113 christos USTPUTC(CTLQUOTEEND, out);
1592 1.113 christos } else {
1593 1.113 christos TS_PUSH();
1594 1.113 christos syntax = DQSYNTAX;
1595 1.113 christos SETDBLQUOTE();
1596 1.113 christos USTPUTC(CTLQUOTEMARK, out);
1597 1.113 christos }
1598 1.113 christos continue;
1599 1.113 christos case CVAR: /* '$' */
1600 1.113 christos PARSESUB(); /* parse substitution */
1601 1.113 christos continue;
1602 1.113 christos case CENDVAR: /* CLOSEBRACE */
1603 1.113 christos if (varnest > 0 && !ISDBLQUOTE()) {
1604 1.113 christos TS_POP();
1605 1.113 christos USTPUTC(CTLENDVAR, out);
1606 1.113 christos } else {
1607 1.113 christos USTPUTC(c, out);
1608 1.113 christos }
1609 1.113 christos continue;
1610 1.113 christos case CLP: /* '(' in arithmetic */
1611 1.113 christos parenlevel++;
1612 1.113 christos USTPUTC(c, out);
1613 1.113 christos continue;;
1614 1.113 christos case CRP: /* ')' in arithmetic */
1615 1.113 christos if (parenlevel > 0) {
1616 1.11 jtc USTPUTC(c, out);
1617 1.113 christos --parenlevel;
1618 1.113 christos } else {
1619 1.113 christos if (pgetc() == ')') {
1620 1.113 christos if (--arinest == 0) {
1621 1.113 christos TS_POP();
1622 1.113 christos USTPUTC(CTLENDARI, out);
1623 1.113 christos } else
1624 1.113 christos USTPUTC(')', out);
1625 1.11 jtc } else {
1626 1.113 christos /*
1627 1.113 christos * unbalanced parens
1628 1.113 christos * (don't 2nd guess - no error)
1629 1.113 christos */
1630 1.113 christos pungetc();
1631 1.113 christos USTPUTC(')', out);
1632 1.11 jtc }
1633 1.1 cgd }
1634 1.113 christos continue;
1635 1.113 christos case CBQUOTE: /* '`' */
1636 1.113 christos out = parsebackq(stack, out, &bqlist, 1);
1637 1.113 christos continue;
1638 1.113 christos case CEOF: /* --> c == PEOF */
1639 1.113 christos break; /* will exit loop */
1640 1.113 christos default:
1641 1.113 christos if (varnest == 0 && !ISDBLQUOTE())
1642 1.113 christos break; /* exit loop */
1643 1.113 christos USTPUTC(c, out);
1644 1.113 christos continue;
1645 1.1 cgd }
1646 1.113 christos break; /* break from switch -> break from for loop too */
1647 1.1 cgd }
1648 1.113 christos
1649 1.96 christos if (syntax == ARISYNTAX) {
1650 1.96 christos cleanup_state_stack(stack);
1651 1.11 jtc synerror("Missing '))'");
1652 1.96 christos }
1653 1.111 christos if (syntax != BASESYNTAX && /* ! parsebackquote && */ !magicq) {
1654 1.96 christos cleanup_state_stack(stack);
1655 1.1 cgd synerror("Unterminated quoted string");
1656 1.96 christos }
1657 1.1 cgd if (varnest != 0) {
1658 1.96 christos cleanup_state_stack(stack);
1659 1.1 cgd startlinno = plinno;
1660 1.51 christos /* { */
1661 1.1 cgd synerror("Missing '}'");
1662 1.1 cgd }
1663 1.113 christos
1664 1.1 cgd USTPUTC('\0', out);
1665 1.1 cgd len = out - stackblock();
1666 1.1 cgd out = stackblock();
1667 1.113 christos
1668 1.111 christos if (!magicq) {
1669 1.111 christos if ((c == '<' || c == '>')
1670 1.113 christos && quotef == 0 && (*out == '\0' || is_number(out))) {
1671 1.112 christos parseredir(out, c);
1672 1.96 christos cleanup_state_stack(stack);
1673 1.1 cgd return lasttoken = TREDIR;
1674 1.1 cgd } else {
1675 1.1 cgd pungetc();
1676 1.1 cgd }
1677 1.1 cgd }
1678 1.113 christos
1679 1.1 cgd quoteflag = quotef;
1680 1.1 cgd backquotelist = bqlist;
1681 1.1 cgd grabstackblock(len);
1682 1.1 cgd wordtext = out;
1683 1.96 christos cleanup_state_stack(stack);
1684 1.1 cgd return lasttoken = TWORD;
1685 1.1 cgd /* end of readtoken routine */
1686 1.1 cgd
1687 1.1 cgd
1688 1.1 cgd /*
1689 1.1 cgd * Parse a substitution. At this point, we have read the dollar sign
1690 1.1 cgd * and nothing else.
1691 1.1 cgd */
1692 1.1 cgd
1693 1.1 cgd parsesub: {
1694 1.84 christos char buf[10];
1695 1.1 cgd int subtype;
1696 1.1 cgd int typeloc;
1697 1.1 cgd int flags;
1698 1.1 cgd char *p;
1699 1.1 cgd static const char types[] = "}-+?=";
1700 1.84 christos int i;
1701 1.84 christos int linno;
1702 1.1 cgd
1703 1.1 cgd c = pgetc();
1704 1.51 christos if (c != '(' && c != OPENBRACE && !is_name(c) && !is_special(c)) {
1705 1.1 cgd USTPUTC('$', out);
1706 1.1 cgd pungetc();
1707 1.11 jtc } else if (c == '(') { /* $(command) or $((arith)) */
1708 1.11 jtc if (pgetc() == '(') {
1709 1.11 jtc PARSEARITH();
1710 1.11 jtc } else {
1711 1.11 jtc pungetc();
1712 1.106 christos out = parsebackq(stack, out, &bqlist, 0);
1713 1.11 jtc }
1714 1.1 cgd } else {
1715 1.1 cgd USTPUTC(CTLVAR, out);
1716 1.1 cgd typeloc = out - stackblock();
1717 1.1 cgd USTPUTC(VSNORMAL, out);
1718 1.1 cgd subtype = VSNORMAL;
1719 1.84 christos flags = 0;
1720 1.51 christos if (c == OPENBRACE) {
1721 1.1 cgd c = pgetc();
1722 1.23 christos if (c == '#') {
1723 1.51 christos if ((c = pgetc()) == CLOSEBRACE)
1724 1.26 christos c = '#';
1725 1.26 christos else
1726 1.26 christos subtype = VSLENGTH;
1727 1.23 christos }
1728 1.23 christos else
1729 1.23 christos subtype = 0;
1730 1.1 cgd }
1731 1.1 cgd if (is_name(c)) {
1732 1.84 christos p = out;
1733 1.1 cgd do {
1734 1.1 cgd STPUTC(c, out);
1735 1.1 cgd c = pgetc();
1736 1.1 cgd } while (is_in_name(c));
1737 1.84 christos if (out - p == 6 && strncmp(p, "LINENO", 6) == 0) {
1738 1.84 christos /* Replace the variable name with the
1739 1.84 christos * current line number. */
1740 1.84 christos linno = plinno;
1741 1.84 christos if (funclinno != 0)
1742 1.84 christos linno -= funclinno - 1;
1743 1.84 christos snprintf(buf, sizeof(buf), "%d", linno);
1744 1.84 christos STADJUST(-6, out);
1745 1.84 christos for (i = 0; buf[i] != '\0'; i++)
1746 1.84 christos STPUTC(buf[i], out);
1747 1.84 christos flags |= VSLINENO;
1748 1.84 christos }
1749 1.34 christos } else if (is_digit(c)) {
1750 1.33 christos do {
1751 1.33 christos USTPUTC(c, out);
1752 1.33 christos c = pgetc();
1753 1.114 christos } while (subtype != VSNORMAL && is_digit(c));
1754 1.34 christos }
1755 1.34 christos else if (is_special(c)) {
1756 1.34 christos USTPUTC(c, out);
1757 1.34 christos c = pgetc();
1758 1.1 cgd }
1759 1.96 christos else {
1760 1.96 christos badsub:
1761 1.96 christos cleanup_state_stack(stack);
1762 1.96 christos synerror("Bad substitution");
1763 1.96 christos }
1764 1.33 christos
1765 1.1 cgd STPUTC('=', out);
1766 1.1 cgd if (subtype == 0) {
1767 1.23 christos switch (c) {
1768 1.23 christos case ':':
1769 1.84 christos flags |= VSNUL;
1770 1.1 cgd c = pgetc();
1771 1.23 christos /*FALLTHROUGH*/
1772 1.23 christos default:
1773 1.23 christos p = strchr(types, c);
1774 1.23 christos if (p == NULL)
1775 1.23 christos goto badsub;
1776 1.23 christos subtype = p - types + VSNORMAL;
1777 1.23 christos break;
1778 1.23 christos case '%':
1779 1.30 christos case '#':
1780 1.23 christos {
1781 1.23 christos int cc = c;
1782 1.23 christos subtype = c == '#' ? VSTRIMLEFT :
1783 1.23 christos VSTRIMRIGHT;
1784 1.23 christos c = pgetc();
1785 1.23 christos if (c == cc)
1786 1.23 christos subtype++;
1787 1.23 christos else
1788 1.23 christos pungetc();
1789 1.23 christos break;
1790 1.23 christos }
1791 1.1 cgd }
1792 1.1 cgd } else {
1793 1.1 cgd pungetc();
1794 1.1 cgd }
1795 1.51 christos if (ISDBLQUOTE() || arinest)
1796 1.1 cgd flags |= VSQUOTE;
1797 1.98 christos if (subtype >= VSTRIMLEFT && subtype <= VSTRIMRIGHTMAX)
1798 1.98 christos flags |= VSPATQ;
1799 1.1 cgd *(stackblock() + typeloc) = subtype | flags;
1800 1.96 christos if (subtype != VSNORMAL) {
1801 1.96 christos TS_PUSH();
1802 1.96 christos varnest++;
1803 1.96 christos arinest = 0;
1804 1.96 christos if (subtype > VSASSIGN) { /* # ## % %% */
1805 1.96 christos syntax = BASESYNTAX;
1806 1.96 christos CLRDBLQUOTE();
1807 1.96 christos }
1808 1.96 christos }
1809 1.1 cgd }
1810 1.1 cgd goto parsesub_return;
1811 1.1 cgd }
1812 1.1 cgd
1813 1.1 cgd
1814 1.1 cgd /*
1815 1.11 jtc * Parse an arithmetic expansion (indicate start of one and set state)
1816 1.1 cgd */
1817 1.11 jtc parsearith: {
1818 1.1 cgd
1819 1.96 christos if (syntax == ARISYNTAX) {
1820 1.96 christos /*
1821 1.96 christos * we collapse embedded arithmetic expansion to
1822 1.96 christos * parentheses, which should be equivalent
1823 1.96 christos */
1824 1.96 christos USTPUTC('(', out);
1825 1.96 christos USTPUTC('(', out);
1826 1.96 christos /*
1827 1.96 christos * Need 2 of them because there will (should be)
1828 1.96 christos * two closing ))'s to follow later.
1829 1.96 christos */
1830 1.96 christos parenlevel += 2;
1831 1.96 christos } else {
1832 1.96 christos TS_PUSH();
1833 1.11 jtc syntax = ARISYNTAX;
1834 1.96 christos ++arinest;
1835 1.96 christos varnest = 0;
1836 1.96 christos
1837 1.11 jtc USTPUTC(CTLARI, out);
1838 1.51 christos if (ISDBLQUOTE())
1839 1.41 mycroft USTPUTC('"',out);
1840 1.41 mycroft else
1841 1.41 mycroft USTPUTC(' ',out);
1842 1.1 cgd }
1843 1.11 jtc goto parsearith_return;
1844 1.1 cgd }
1845 1.1 cgd
1846 1.11 jtc } /* end of readtoken */
1847 1.1 cgd
1848 1.1 cgd
1849 1.1 cgd
1850 1.11 jtc #ifdef mkinit
1851 1.11 jtc RESET {
1852 1.11 jtc tokpushback = 0;
1853 1.11 jtc checkkwd = 0;
1854 1.1 cgd }
1855 1.1 cgd #endif
1856 1.1 cgd
1857 1.1 cgd /*
1858 1.1 cgd * Returns true if the text contains nothing to expand (no dollar signs
1859 1.1 cgd * or backquotes).
1860 1.1 cgd */
1861 1.1 cgd
1862 1.1 cgd STATIC int
1863 1.54 christos noexpand(char *text)
1864 1.54 christos {
1865 1.32 tls char *p;
1866 1.32 tls char c;
1867 1.1 cgd
1868 1.1 cgd p = text;
1869 1.1 cgd while ((c = *p++) != '\0') {
1870 1.41 mycroft if (c == CTLQUOTEMARK)
1871 1.41 mycroft continue;
1872 1.1 cgd if (c == CTLESC)
1873 1.1 cgd p++;
1874 1.38 mrg else if (BASESYNTAX[(int)c] == CCTL)
1875 1.1 cgd return 0;
1876 1.1 cgd }
1877 1.1 cgd return 1;
1878 1.1 cgd }
1879 1.1 cgd
1880 1.1 cgd
1881 1.1 cgd /*
1882 1.1 cgd * Return true if the argument is a legal variable name (a letter or
1883 1.1 cgd * underscore followed by zero or more letters, underscores, and digits).
1884 1.1 cgd */
1885 1.1 cgd
1886 1.1 cgd int
1887 1.45 cgd goodname(char *name)
1888 1.108 christos {
1889 1.32 tls char *p;
1890 1.1 cgd
1891 1.1 cgd p = name;
1892 1.1 cgd if (! is_name(*p))
1893 1.1 cgd return 0;
1894 1.1 cgd while (*++p) {
1895 1.1 cgd if (! is_in_name(*p))
1896 1.1 cgd return 0;
1897 1.1 cgd }
1898 1.1 cgd return 1;
1899 1.1 cgd }
1900 1.1 cgd
1901 1.1 cgd
1902 1.1 cgd /*
1903 1.1 cgd * Called when an unexpected token is read during the parse. The argument
1904 1.1 cgd * is the token that is expected, or -1 if more than one type of token can
1905 1.1 cgd * occur at this point.
1906 1.1 cgd */
1907 1.1 cgd
1908 1.1 cgd STATIC void
1909 1.108 christos synexpect(int token, const char *text)
1910 1.22 cgd {
1911 1.1 cgd char msg[64];
1912 1.108 christos char *p;
1913 1.108 christos
1914 1.108 christos if (lasttoken == TWORD) {
1915 1.108 christos size_t len = strlen(wordtext);
1916 1.108 christos
1917 1.108 christos if (len <= 13)
1918 1.108 christos fmtstr(msg, 34, "Word \"%.13s\" unexpected", wordtext);
1919 1.108 christos else
1920 1.108 christos fmtstr(msg, 34,
1921 1.108 christos "Word \"%.10s...\" unexpected", wordtext);
1922 1.108 christos } else
1923 1.108 christos fmtstr(msg, 34, "%s unexpected", tokname[lasttoken]);
1924 1.108 christos
1925 1.108 christos p = strchr(msg, '\0');
1926 1.108 christos if (text)
1927 1.108 christos fmtstr(p, 30, " (expecting \"%.10s\")", text);
1928 1.108 christos else if (token >= 0)
1929 1.108 christos fmtstr(p, 30, " (expecting %s)", tokname[token]);
1930 1.1 cgd
1931 1.1 cgd synerror(msg);
1932 1.39 mycroft /* NOTREACHED */
1933 1.1 cgd }
1934 1.1 cgd
1935 1.1 cgd
1936 1.1 cgd STATIC void
1937 1.54 christos synerror(const char *msg)
1938 1.54 christos {
1939 1.108 christos error("%d: Syntax error: %s\n", startlinno, msg);
1940 1.39 mycroft /* NOTREACHED */
1941 1.11 jtc }
1942 1.11 jtc
1943 1.11 jtc STATIC void
1944 1.54 christos setprompt(int which)
1945 1.54 christos {
1946 1.11 jtc whichprompt = which;
1947 1.11 jtc
1948 1.35 christos #ifndef SMALL
1949 1.11 jtc if (!el)
1950 1.14 cgd #endif
1951 1.11 jtc out2str(getprompt(NULL));
1952 1.11 jtc }
1953 1.11 jtc
1954 1.11 jtc /*
1955 1.11 jtc * called by editline -- any expansions to the prompt
1956 1.11 jtc * should be added here.
1957 1.11 jtc */
1958 1.43 christos const char *
1959 1.45 cgd getprompt(void *unused)
1960 1.108 christos {
1961 1.11 jtc switch (whichprompt) {
1962 1.11 jtc case 0:
1963 1.11 jtc return "";
1964 1.11 jtc case 1:
1965 1.11 jtc return ps1val();
1966 1.11 jtc case 2:
1967 1.11 jtc return ps2val();
1968 1.11 jtc default:
1969 1.11 jtc return "<internal prompt error>";
1970 1.11 jtc }
1971 1.1 cgd }
1972