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