1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Kenneth Almquist.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #ifndef lint
36 #if 0
37 static char sccsid[] = "@(#)parser.c 8.7 (Berkeley) 5/16/95";
38 #endif
39 #endif /* not lint */
40 #include <sys/cdefs.h>
41 #include <sys/param.h>
42 #include <pwd.h>
43 #include <stdlib.h>
44 #include <unistd.h>
45 #include <stdio.h>
46
47 #include "shell.h"
48 #include "parser.h"
49 #include "nodes.h"
50 #include "expand.h" /* defines rmescapes() */
51 #include "syntax.h"
52 #include "options.h"
53 #include "input.h"
54 #include "output.h"
55 #include "var.h"
56 #include "error.h"
57 #include "memalloc.h"
58 #include "mystring.h"
59 #include "alias.h"
60 #include "show.h"
61 #include "eval.h"
62 #include "exec.h" /* to check for special builtins */
63 #ifndef NO_HISTORY
64 #include "myhistedit.h"
65 #endif
66
67 /*
68 * Shell command parser.
69 */
70
71 #define PROMPTLEN 192
72
73 /* values of checkkwd variable */
74 #define CHKALIAS 0x1
75 #define CHKKWD 0x2
76 #define CHKNL 0x4
77
78 /* values returned by readtoken */
79 #include "token.h"
80
81
82
83 struct heredoc {
84 struct heredoc *next; /* next here document in list */
85 union node *here; /* redirection node */
86 char *eofmark; /* string indicating end of input */
87 int striptabs; /* if set, strip leading tabs */
88 };
89
90 struct parser_temp {
91 struct parser_temp *next;
92 void *data;
93 };
94
95
96 static struct heredoc *heredoclist; /* list of here documents to read */
97 static int doprompt; /* if set, prompt the user */
98 static int needprompt; /* true if interactive and at start of line */
99 static int lasttoken; /* last token read */
100 static int tokpushback; /* last token pushed back */
101 static char *wordtext; /* text of last word returned by readtoken */
102 static int checkkwd;
103 static struct nodelist *backquotelist;
104 static union node *redirnode;
105 static struct heredoc *heredoc;
106 static int quoteflag; /* set if (part of) last token was quoted */
107 static int startlinno; /* line # where last token started */
108 static int funclinno; /* line # where the current function started */
109 static struct parser_temp *parser_temp;
110
111 #define NOEOFMARK ((const char *)&heredoclist)
112
113
114 static union node *list(int);
115 static union node *andor(void);
116 static union node *pipeline(void);
117 static union node *command(void);
118 static union node *simplecmd(union node **, union node *);
119 static union node *makename(void);
120 static union node *makebinary(int type, union node *n1, union node *n2);
121 static void parsefname(void);
122 static void parseheredoc(void);
123 static int peektoken(void);
124 static int readtoken(void);
125 static int xxreadtoken(void);
126 static int readtoken1(int, const char *, const char *, int);
127 static int noexpand(char *);
128 static void consumetoken(int);
129 static void synexpect(int) __dead2;
130 static void synerror(const char *) __dead2;
131 static void setprompt(int);
132 static int pgetc_linecont(void);
133 static void getusername(char *, size_t);
134
135
136 static void *
parser_temp_alloc(size_t len)137 parser_temp_alloc(size_t len)
138 {
139 struct parser_temp *t;
140
141 INTOFF;
142 t = ckmalloc(sizeof(*t));
143 t->data = NULL;
144 t->next = parser_temp;
145 parser_temp = t;
146 t->data = ckmalloc(len);
147 INTON;
148 return t->data;
149 }
150
151
152 static void *
parser_temp_realloc(void * ptr,size_t len)153 parser_temp_realloc(void *ptr, size_t len)
154 {
155 struct parser_temp *t;
156
157 INTOFF;
158 t = parser_temp;
159 if (ptr != t->data)
160 error("bug: parser_temp_realloc misused");
161 t->data = ckrealloc(t->data, len);
162 INTON;
163 return t->data;
164 }
165
166
167 static void
parser_temp_free_upto(void * ptr)168 parser_temp_free_upto(void *ptr)
169 {
170 struct parser_temp *t;
171 int done = 0;
172
173 INTOFF;
174 while (parser_temp != NULL && !done) {
175 t = parser_temp;
176 parser_temp = t->next;
177 done = t->data == ptr;
178 ckfree(t->data);
179 ckfree(t);
180 }
181 INTON;
182 if (!done)
183 error("bug: parser_temp_free_upto misused");
184 }
185
186
187 static void
parser_temp_free_all(void)188 parser_temp_free_all(void)
189 {
190 struct parser_temp *t;
191
192 INTOFF;
193 while (parser_temp != NULL) {
194 t = parser_temp;
195 parser_temp = t->next;
196 ckfree(t->data);
197 ckfree(t);
198 }
199 INTON;
200 }
201
202
203 /*
204 * Read and parse a command. Returns NEOF on end of file. (NULL is a
205 * valid parse tree indicating a blank line.)
206 */
207
208 union node *
parsecmd(int interact)209 parsecmd(int interact)
210 {
211 int t;
212
213 /* This assumes the parser is not re-entered,
214 * which could happen if we add command substitution on PS1/PS2.
215 */
216 parser_temp_free_all();
217 heredoclist = NULL;
218
219 tokpushback = 0;
220 checkkwd = 0;
221 doprompt = interact;
222 if (doprompt)
223 setprompt(1);
224 else
225 setprompt(0);
226 needprompt = 0;
227 t = readtoken();
228 if (t == TEOF)
229 return NEOF;
230 if (t == TNL)
231 return NULL;
232 tokpushback++;
233 return list(1);
234 }
235
236
237 /*
238 * Read and parse words for wordexp.
239 * Returns a list of NARG nodes; NULL if there are no words.
240 */
241 union node *
parsewordexp(void)242 parsewordexp(void)
243 {
244 union node *n, *first = NULL, **pnext;
245 int t;
246
247 /* This assumes the parser is not re-entered,
248 * which could happen if we add command substitution on PS1/PS2.
249 */
250 parser_temp_free_all();
251 heredoclist = NULL;
252
253 tokpushback = 0;
254 checkkwd = 0;
255 doprompt = 0;
256 setprompt(0);
257 needprompt = 0;
258 pnext = &first;
259 while ((t = readtoken()) != TEOF) {
260 if (t != TWORD)
261 synexpect(TWORD);
262 n = makename();
263 *pnext = n;
264 pnext = &n->narg.next;
265 }
266 return first;
267 }
268
269
270 static union node *
list(int nlflag)271 list(int nlflag)
272 {
273 union node *ntop, *n1, *n2, *n3;
274 int tok;
275
276 checkkwd = CHKNL | CHKKWD | CHKALIAS;
277 if (!nlflag && tokendlist[peektoken()])
278 return NULL;
279 ntop = n1 = NULL;
280 for (;;) {
281 n2 = andor();
282 tok = readtoken();
283 if (tok == TBACKGND) {
284 if (n2 != NULL && n2->type == NPIPE) {
285 n2->npipe.backgnd = 1;
286 } else if (n2 != NULL && n2->type == NREDIR) {
287 n2->type = NBACKGND;
288 } else {
289 n3 = (union node *)stalloc(sizeof (struct nredir));
290 n3->type = NBACKGND;
291 n3->nredir.n = n2;
292 n3->nredir.redirect = NULL;
293 n2 = n3;
294 }
295 }
296 if (ntop == NULL)
297 ntop = n2;
298 else if (n1 == NULL) {
299 n1 = makebinary(NSEMI, ntop, n2);
300 ntop = n1;
301 }
302 else {
303 n3 = makebinary(NSEMI, n1->nbinary.ch2, n2);
304 n1->nbinary.ch2 = n3;
305 n1 = n3;
306 }
307 switch (tok) {
308 case TBACKGND:
309 case TSEMI:
310 tok = readtoken();
311 /* FALLTHROUGH */
312 case TNL:
313 if (tok == TNL) {
314 parseheredoc();
315 if (nlflag)
316 return ntop;
317 } else if (tok == TEOF && nlflag) {
318 parseheredoc();
319 return ntop;
320 } else {
321 tokpushback++;
322 }
323 checkkwd = CHKNL | CHKKWD | CHKALIAS;
324 if (!nlflag && tokendlist[peektoken()])
325 return ntop;
326 break;
327 case TEOF:
328 if (heredoclist)
329 parseheredoc();
330 else
331 pungetc(); /* push back EOF on input */
332 return ntop;
333 default:
334 if (nlflag)
335 synexpect(-1);
336 tokpushback++;
337 return ntop;
338 }
339 }
340 }
341
342
343
344 static union node *
andor(void)345 andor(void)
346 {
347 union node *n;
348 int t;
349
350 n = pipeline();
351 for (;;) {
352 if ((t = readtoken()) == TAND) {
353 t = NAND;
354 } else if (t == TOR) {
355 t = NOR;
356 } else {
357 tokpushback++;
358 return n;
359 }
360 n = makebinary(t, n, pipeline());
361 }
362 }
363
364
365
366 static union node *
pipeline(void)367 pipeline(void)
368 {
369 union node *n1, *n2, *pipenode;
370 struct nodelist *lp, *prev;
371 int negate, t;
372
373 negate = 0;
374 checkkwd = CHKNL | CHKKWD | CHKALIAS;
375 TRACE(("pipeline: entered\n"));
376 while (readtoken() == TNOT)
377 negate = !negate;
378 tokpushback++;
379 n1 = command();
380 if (readtoken() == TPIPE) {
381 pipenode = (union node *)stalloc(sizeof (struct npipe));
382 pipenode->type = NPIPE;
383 pipenode->npipe.backgnd = 0;
384 lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
385 pipenode->npipe.cmdlist = lp;
386 lp->n = n1;
387 do {
388 prev = lp;
389 lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
390 checkkwd = CHKNL | CHKKWD | CHKALIAS;
391 t = readtoken();
392 tokpushback++;
393 if (t == TNOT)
394 lp->n = pipeline();
395 else
396 lp->n = command();
397 prev->next = lp;
398 } while (readtoken() == TPIPE);
399 lp->next = NULL;
400 n1 = pipenode;
401 }
402 tokpushback++;
403 if (negate) {
404 n2 = (union node *)stalloc(sizeof (struct nnot));
405 n2->type = NNOT;
406 n2->nnot.com = n1;
407 return n2;
408 } else
409 return n1;
410 }
411
412
413
414 static union node *
command(void)415 command(void)
416 {
417 union node *n1, *n2;
418 union node *ap, **app;
419 union node *cp, **cpp;
420 union node *redir, **rpp;
421 int t;
422 int is_subshell;
423
424 checkkwd = CHKNL | CHKKWD | CHKALIAS;
425 is_subshell = 0;
426 redir = NULL;
427 n1 = NULL;
428 rpp = &redir;
429
430 /* Check for redirection which may precede command */
431 while (readtoken() == TREDIR) {
432 *rpp = n2 = redirnode;
433 rpp = &n2->nfile.next;
434 parsefname();
435 }
436 tokpushback++;
437
438 switch (readtoken()) {
439 case TIF:
440 n1 = (union node *)stalloc(sizeof (struct nif));
441 n1->type = NIF;
442 if ((n1->nif.test = list(0)) == NULL)
443 synexpect(-1);
444 consumetoken(TTHEN);
445 n1->nif.ifpart = list(0);
446 n2 = n1;
447 while (readtoken() == TELIF) {
448 n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
449 n2 = n2->nif.elsepart;
450 n2->type = NIF;
451 if ((n2->nif.test = list(0)) == NULL)
452 synexpect(-1);
453 consumetoken(TTHEN);
454 n2->nif.ifpart = list(0);
455 }
456 if (lasttoken == TELSE)
457 n2->nif.elsepart = list(0);
458 else {
459 n2->nif.elsepart = NULL;
460 tokpushback++;
461 }
462 consumetoken(TFI);
463 checkkwd = CHKKWD | CHKALIAS;
464 break;
465 case TWHILE:
466 case TUNTIL:
467 t = lasttoken;
468 if ((n1 = list(0)) == NULL)
469 synexpect(-1);
470 consumetoken(TDO);
471 n1 = makebinary((t == TWHILE)? NWHILE : NUNTIL, n1, list(0));
472 consumetoken(TDONE);
473 checkkwd = CHKKWD | CHKALIAS;
474 break;
475 case TFOR:
476 if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
477 synerror("Bad for loop variable");
478 n1 = (union node *)stalloc(sizeof (struct nfor));
479 n1->type = NFOR;
480 n1->nfor.var = wordtext;
481 checkkwd = CHKNL;
482 if (readtoken() == TWORD && !quoteflag &&
483 equal(wordtext, "in")) {
484 app = ≈
485 while (readtoken() == TWORD) {
486 n2 = makename();
487 *app = n2;
488 app = &n2->narg.next;
489 }
490 *app = NULL;
491 n1->nfor.args = ap;
492 if (lasttoken == TNL)
493 tokpushback++;
494 else if (lasttoken != TSEMI)
495 synexpect(-1);
496 } else {
497 static char argvars[5] = {
498 CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'
499 };
500 n2 = (union node *)stalloc(sizeof (struct narg));
501 n2->type = NARG;
502 n2->narg.text = argvars;
503 n2->narg.backquote = NULL;
504 n2->narg.next = NULL;
505 n1->nfor.args = n2;
506 /*
507 * Newline or semicolon here is optional (but note
508 * that the original Bourne shell only allowed NL).
509 */
510 if (lasttoken != TSEMI)
511 tokpushback++;
512 }
513 checkkwd = CHKNL | CHKKWD | CHKALIAS;
514 if ((t = readtoken()) == TDO)
515 t = TDONE;
516 else if (t == TBEGIN)
517 t = TEND;
518 else
519 synexpect(-1);
520 n1->nfor.body = list(0);
521 consumetoken(t);
522 checkkwd = CHKKWD | CHKALIAS;
523 break;
524 case TCASE:
525 n1 = (union node *)stalloc(sizeof (struct ncase));
526 n1->type = NCASE;
527 consumetoken(TWORD);
528 n1->ncase.expr = makename();
529 checkkwd = CHKNL;
530 if (readtoken() != TWORD || ! equal(wordtext, "in"))
531 synerror("expecting \"in\"");
532 cpp = &n1->ncase.cases;
533 checkkwd = CHKNL | CHKKWD, readtoken();
534 while (lasttoken != TESAC) {
535 *cpp = cp = (union node *)stalloc(sizeof (struct nclist));
536 cp->type = NCLIST;
537 app = &cp->nclist.pattern;
538 if (lasttoken == TLP)
539 readtoken();
540 for (;;) {
541 *app = ap = makename();
542 checkkwd = CHKNL | CHKKWD;
543 if (readtoken() != TPIPE)
544 break;
545 app = &ap->narg.next;
546 readtoken();
547 }
548 ap->narg.next = NULL;
549 if (lasttoken != TRP)
550 synexpect(TRP);
551 cp->nclist.body = list(0);
552
553 checkkwd = CHKNL | CHKKWD | CHKALIAS;
554 if ((t = readtoken()) != TESAC) {
555 if (t == TENDCASE)
556 ;
557 else if (t == TFALLTHRU)
558 cp->type = NCLISTFALLTHRU;
559 else
560 synexpect(TENDCASE);
561 checkkwd = CHKNL | CHKKWD, readtoken();
562 }
563 cpp = &cp->nclist.next;
564 }
565 *cpp = NULL;
566 checkkwd = CHKKWD | CHKALIAS;
567 break;
568 case TLP:
569 n1 = (union node *)stalloc(sizeof (struct nredir));
570 n1->type = NSUBSHELL;
571 n1->nredir.n = list(0);
572 n1->nredir.redirect = NULL;
573 consumetoken(TRP);
574 checkkwd = CHKKWD | CHKALIAS;
575 is_subshell = 1;
576 break;
577 case TBEGIN:
578 n1 = list(0);
579 consumetoken(TEND);
580 checkkwd = CHKKWD | CHKALIAS;
581 break;
582 /* A simple command must have at least one redirection or word. */
583 case TBACKGND:
584 case TSEMI:
585 case TAND:
586 case TOR:
587 case TPIPE:
588 case TENDCASE:
589 case TFALLTHRU:
590 case TEOF:
591 case TNL:
592 case TRP:
593 if (!redir)
594 synexpect(-1);
595 case TWORD:
596 tokpushback++;
597 n1 = simplecmd(rpp, redir);
598 return n1;
599 default:
600 synexpect(-1);
601 }
602
603 /* Now check for redirection which may follow command */
604 while (readtoken() == TREDIR) {
605 *rpp = n2 = redirnode;
606 rpp = &n2->nfile.next;
607 parsefname();
608 }
609 tokpushback++;
610 *rpp = NULL;
611 if (redir) {
612 if (!is_subshell) {
613 n2 = (union node *)stalloc(sizeof (struct nredir));
614 n2->type = NREDIR;
615 n2->nredir.n = n1;
616 n1 = n2;
617 }
618 n1->nredir.redirect = redir;
619 }
620
621 return n1;
622 }
623
624
625 static union node *
simplecmd(union node ** rpp,union node * redir)626 simplecmd(union node **rpp, union node *redir)
627 {
628 union node *args, **app;
629 union node **orig_rpp = rpp;
630 union node *n = NULL;
631 int special;
632 int savecheckkwd;
633
634 /* If we don't have any redirections already, then we must reset */
635 /* rpp to be the address of the local redir variable. */
636 if (redir == NULL)
637 rpp = &redir;
638
639 args = NULL;
640 app = &args;
641 /*
642 * We save the incoming value, because we need this for shell
643 * functions. There can not be a redirect or an argument between
644 * the function name and the open parenthesis.
645 */
646 orig_rpp = rpp;
647
648 savecheckkwd = CHKALIAS;
649
650 for (;;) {
651 checkkwd = savecheckkwd;
652 if (readtoken() == TWORD) {
653 n = makename();
654 *app = n;
655 app = &n->narg.next;
656 if (savecheckkwd != 0 && !isassignment(wordtext))
657 savecheckkwd = 0;
658 } else if (lasttoken == TREDIR) {
659 *rpp = n = redirnode;
660 rpp = &n->nfile.next;
661 parsefname(); /* read name of redirection file */
662 } else if (lasttoken == TLP && app == &args->narg.next
663 && rpp == orig_rpp) {
664 /* We have a function */
665 consumetoken(TRP);
666 funclinno = plinno;
667 /*
668 * - Require plain text.
669 * - Functions with '/' cannot be called.
670 * - Reject name=().
671 * - Reject ksh extended glob patterns.
672 */
673 if (!noexpand(n->narg.text) || quoteflag ||
674 strchr(n->narg.text, '/') ||
675 strchr("!%*+-=?@}~",
676 n->narg.text[strlen(n->narg.text) - 1]))
677 synerror("Bad function name");
678 rmescapes(n->narg.text);
679 if (find_builtin(n->narg.text, &special) >= 0 &&
680 special)
681 synerror("Cannot override a special builtin with a function");
682 n->type = NDEFUN;
683 n->narg.next = command();
684 funclinno = 0;
685 return n;
686 } else {
687 tokpushback++;
688 break;
689 }
690 }
691 *app = NULL;
692 *rpp = NULL;
693 n = (union node *)stalloc(sizeof (struct ncmd));
694 n->type = NCMD;
695 n->ncmd.args = args;
696 n->ncmd.redirect = redir;
697 return n;
698 }
699
700 static union node *
makename(void)701 makename(void)
702 {
703 union node *n;
704
705 n = (union node *)stalloc(sizeof (struct narg));
706 n->type = NARG;
707 n->narg.next = NULL;
708 n->narg.text = wordtext;
709 n->narg.backquote = backquotelist;
710 return n;
711 }
712
713 static union node *
makebinary(int type,union node * n1,union node * n2)714 makebinary(int type, union node *n1, union node *n2)
715 {
716 union node *n;
717
718 n = (union node *)stalloc(sizeof (struct nbinary));
719 n->type = type;
720 n->nbinary.ch1 = n1;
721 n->nbinary.ch2 = n2;
722 return (n);
723 }
724
725 void
forcealias(void)726 forcealias(void)
727 {
728 checkkwd |= CHKALIAS;
729 }
730
731 void
fixredir(union node * n,const char * text,int err)732 fixredir(union node *n, const char *text, int err)
733 {
734 TRACE(("Fix redir %s %d\n", text, err));
735 if (!err)
736 n->ndup.vname = NULL;
737
738 if (is_digit(text[0]) && text[1] == '\0')
739 n->ndup.dupfd = digit_val(text[0]);
740 else if (text[0] == '-' && text[1] == '\0')
741 n->ndup.dupfd = -1;
742 else {
743
744 if (err)
745 synerror("Bad fd number");
746 else
747 n->ndup.vname = makename();
748 }
749 }
750
751
752 static void
parsefname(void)753 parsefname(void)
754 {
755 union node *n = redirnode;
756
757 consumetoken(TWORD);
758 if (n->type == NHERE) {
759 struct heredoc *here = heredoc;
760 struct heredoc *p;
761
762 if (quoteflag == 0)
763 n->type = NXHERE;
764 TRACE(("Here document %d\n", n->type));
765 if (here->striptabs) {
766 while (*wordtext == '\t')
767 wordtext++;
768 }
769 if (! noexpand(wordtext))
770 synerror("Illegal eof marker for << redirection");
771 rmescapes(wordtext);
772 here->eofmark = wordtext;
773 here->next = NULL;
774 if (heredoclist == NULL)
775 heredoclist = here;
776 else {
777 for (p = heredoclist ; p->next ; p = p->next);
778 p->next = here;
779 }
780 } else if (n->type == NTOFD || n->type == NFROMFD) {
781 fixredir(n, wordtext, 0);
782 } else {
783 n->nfile.fname = makename();
784 }
785 }
786
787
788 /*
789 * Input any here documents.
790 */
791
792 static void
parseheredoc(void)793 parseheredoc(void)
794 {
795 struct heredoc *here;
796 union node *n;
797
798 while (heredoclist) {
799 here = heredoclist;
800 heredoclist = here->next;
801 if (needprompt) {
802 setprompt(2);
803 needprompt = 0;
804 }
805 readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
806 here->eofmark, here->striptabs);
807 n = makename();
808 here->here->nhere.doc = n;
809 }
810 }
811
812 static int
peektoken(void)813 peektoken(void)
814 {
815 int t;
816
817 t = readtoken();
818 tokpushback++;
819 return (t);
820 }
821
822 static int
readtoken(void)823 readtoken(void)
824 {
825 int t;
826 struct alias *ap;
827 #ifdef DEBUG
828 int alreadyseen = tokpushback;
829 #endif
830
831 top:
832 t = xxreadtoken();
833
834 /*
835 * eat newlines
836 */
837 if (checkkwd & CHKNL) {
838 while (t == TNL) {
839 parseheredoc();
840 t = xxreadtoken();
841 }
842 }
843
844 /*
845 * check for keywords and aliases
846 */
847 if (t == TWORD && !quoteflag)
848 {
849 const char * const *pp;
850
851 if (checkkwd & CHKKWD)
852 for (pp = parsekwd; *pp; pp++) {
853 if (**pp == *wordtext && equal(*pp, wordtext))
854 {
855 lasttoken = t = pp - parsekwd + KWDOFFSET;
856 TRACE(("keyword %s recognized\n", tokname[t]));
857 goto out;
858 }
859 }
860 if (checkkwd & CHKALIAS &&
861 (ap = lookupalias(wordtext, 1)) != NULL) {
862 pushstring(ap->val, strlen(ap->val), ap);
863 goto top;
864 }
865 }
866 out:
867 if (t != TNOT)
868 checkkwd = 0;
869
870 #ifdef DEBUG
871 if (!alreadyseen)
872 TRACE(("token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
873 else
874 TRACE(("reread token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
875 #endif
876 return (t);
877 }
878
879
880 /*
881 * Read the next input token.
882 * If the token is a word, we set backquotelist to the list of cmds in
883 * backquotes. We set quoteflag to true if any part of the word was
884 * quoted.
885 * If the token is TREDIR, then we set redirnode to a structure containing
886 * the redirection.
887 * In all cases, the variable startlinno is set to the number of the line
888 * on which the token starts.
889 *
890 * [Change comment: here documents and internal procedures]
891 * [Readtoken shouldn't have any arguments. Perhaps we should make the
892 * word parsing code into a separate routine. In this case, readtoken
893 * doesn't need to have any internal procedures, but parseword does.
894 * We could also make parseoperator in essence the main routine, and
895 * have parseword (readtoken1?) handle both words and redirection.]
896 */
897
898 #define RETURN(token) return lasttoken = token
899
900 static int
xxreadtoken(void)901 xxreadtoken(void)
902 {
903 int c;
904
905 if (tokpushback) {
906 tokpushback = 0;
907 return lasttoken;
908 }
909 if (needprompt) {
910 setprompt(2);
911 needprompt = 0;
912 }
913 startlinno = plinno;
914 for (;;) { /* until token or start of word found */
915 c = pgetc_macro();
916 switch (c) {
917 case ' ': case '\t':
918 continue;
919 case '#':
920 while ((c = pgetc()) != '\n' && c != PEOF);
921 pungetc();
922 continue;
923 case '\\':
924 if (pgetc() == '\n') {
925 startlinno = ++plinno;
926 if (doprompt)
927 setprompt(2);
928 else
929 setprompt(0);
930 continue;
931 }
932 pungetc();
933 /* FALLTHROUGH */
934 default:
935 return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
936 case '\n':
937 plinno++;
938 needprompt = doprompt;
939 RETURN(TNL);
940 case PEOF:
941 RETURN(TEOF);
942 case '&':
943 if (pgetc_linecont() == '&')
944 RETURN(TAND);
945 pungetc();
946 RETURN(TBACKGND);
947 case '|':
948 if (pgetc_linecont() == '|')
949 RETURN(TOR);
950 pungetc();
951 RETURN(TPIPE);
952 case ';':
953 c = pgetc_linecont();
954 if (c == ';')
955 RETURN(TENDCASE);
956 else if (c == '&')
957 RETURN(TFALLTHRU);
958 pungetc();
959 RETURN(TSEMI);
960 case '(':
961 RETURN(TLP);
962 case ')':
963 RETURN(TRP);
964 }
965 }
966 #undef RETURN
967 }
968
969
970 #define MAXNEST_static 8
971 struct tokenstate
972 {
973 const char *syntax; /* *SYNTAX */
974 int parenlevel; /* levels of parentheses in arithmetic */
975 enum tokenstate_category
976 {
977 TSTATE_TOP,
978 TSTATE_VAR_OLD, /* ${var+-=?}, inherits dquotes */
979 TSTATE_VAR_NEW, /* other ${var...}, own dquote state */
980 TSTATE_ARITH
981 } category;
982 };
983
984
985 /*
986 * Check to see whether we are at the end of the here document. When this
987 * is called, c is set to the first character of the next input line. If
988 * we are at the end of the here document, this routine sets the c to PEOF.
989 * The new value of c is returned.
990 */
991
992 static int
checkend(int c,const char * eofmark,int striptabs)993 checkend(int c, const char *eofmark, int striptabs)
994 {
995 if (striptabs) {
996 while (c == '\t')
997 c = pgetc();
998 }
999 if (c == *eofmark) {
1000 int c2;
1001 const char *q;
1002
1003 for (q = eofmark + 1; c2 = pgetc(), *q != '\0' && c2 == *q; q++)
1004 ;
1005 if ((c2 == PEOF || c2 == '\n') && *q == '\0') {
1006 c = PEOF;
1007 if (c2 == '\n') {
1008 plinno++;
1009 needprompt = doprompt;
1010 }
1011 } else {
1012 pungetc();
1013 pushstring(eofmark + 1, q - (eofmark + 1), NULL);
1014 }
1015 } else if (c == '\n' && *eofmark == '\0') {
1016 c = PEOF;
1017 plinno++;
1018 needprompt = doprompt;
1019 }
1020 return (c);
1021 }
1022
1023
1024 /*
1025 * Parse a redirection operator. The variable "out" points to a string
1026 * specifying the fd to be redirected. The variable "c" contains the
1027 * first character of the redirection operator.
1028 */
1029
1030 static void
parseredir(char * out,int c)1031 parseredir(char *out, int c)
1032 {
1033 char fd = *out;
1034 union node *np;
1035
1036 np = (union node *)stalloc(sizeof (struct nfile));
1037 if (c == '>') {
1038 np->nfile.fd = 1;
1039 c = pgetc_linecont();
1040 if (c == '>')
1041 np->type = NAPPEND;
1042 else if (c == '&')
1043 np->type = NTOFD;
1044 else if (c == '|')
1045 np->type = NCLOBBER;
1046 else {
1047 np->type = NTO;
1048 pungetc();
1049 }
1050 } else { /* c == '<' */
1051 np->nfile.fd = 0;
1052 c = pgetc_linecont();
1053 if (c == '<') {
1054 if (sizeof (struct nfile) != sizeof (struct nhere)) {
1055 np = (union node *)stalloc(sizeof (struct nhere));
1056 np->nfile.fd = 0;
1057 }
1058 np->type = NHERE;
1059 heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
1060 heredoc->here = np;
1061 if ((c = pgetc_linecont()) == '-') {
1062 heredoc->striptabs = 1;
1063 } else {
1064 heredoc->striptabs = 0;
1065 pungetc();
1066 }
1067 } else if (c == '&')
1068 np->type = NFROMFD;
1069 else if (c == '>')
1070 np->type = NFROMTO;
1071 else {
1072 np->type = NFROM;
1073 pungetc();
1074 }
1075 }
1076 if (fd != '\0')
1077 np->nfile.fd = digit_val(fd);
1078 redirnode = np;
1079 }
1080
1081 /*
1082 * Called to parse command substitutions.
1083 */
1084
1085 static char *
parsebackq(char * out,struct nodelist ** pbqlist,int oldstyle,int dblquote,int quoted)1086 parsebackq(char *out, struct nodelist **pbqlist,
1087 int oldstyle, int dblquote, int quoted)
1088 {
1089 struct nodelist **nlpp;
1090 union node *n;
1091 char *volatile str;
1092 struct jmploc jmploc;
1093 struct jmploc *const savehandler = handler;
1094 size_t savelen;
1095 int saveprompt;
1096 const int bq_startlinno = plinno;
1097 char *volatile ostr = NULL;
1098 struct parsefile *const savetopfile = getcurrentfile();
1099 struct heredoc *const saveheredoclist = heredoclist;
1100 struct heredoc *here;
1101
1102 str = NULL;
1103 if (setjmp(jmploc.loc)) {
1104 popfilesupto(savetopfile);
1105 if (str)
1106 ckfree(str);
1107 if (ostr)
1108 ckfree(ostr);
1109 heredoclist = saveheredoclist;
1110 handler = savehandler;
1111 if (exception == EXERROR) {
1112 startlinno = bq_startlinno;
1113 synerror("Error in command substitution");
1114 }
1115 longjmp(handler->loc, 1);
1116 }
1117 INTOFF;
1118 savelen = out - stackblock();
1119 if (savelen > 0) {
1120 str = ckmalloc(savelen);
1121 memcpy(str, stackblock(), savelen);
1122 }
1123 handler = &jmploc;
1124 heredoclist = NULL;
1125 INTON;
1126 if (oldstyle) {
1127 /* We must read until the closing backquote, giving special
1128 treatment to some slashes, and then push the string and
1129 reread it as input, interpreting it normally. */
1130 char *oout;
1131 int c;
1132 int olen;
1133
1134
1135 STARTSTACKSTR(oout);
1136 for (;;) {
1137 if (needprompt) {
1138 setprompt(2);
1139 needprompt = 0;
1140 }
1141 CHECKSTRSPACE(2, oout);
1142 c = pgetc_linecont();
1143 if (c == '`')
1144 break;
1145 switch (c) {
1146 case '\\':
1147 c = pgetc();
1148 if (c != '\\' && c != '`' && c != '$'
1149 && (!dblquote || c != '"'))
1150 USTPUTC('\\', oout);
1151 break;
1152
1153 case '\n':
1154 plinno++;
1155 needprompt = doprompt;
1156 break;
1157
1158 case PEOF:
1159 startlinno = plinno;
1160 synerror("EOF in backquote substitution");
1161 break;
1162
1163 default:
1164 break;
1165 }
1166 USTPUTC(c, oout);
1167 }
1168 USTPUTC('\0', oout);
1169 olen = oout - stackblock();
1170 INTOFF;
1171 ostr = ckmalloc(olen);
1172 memcpy(ostr, stackblock(), olen);
1173 setinputstring(ostr, 1);
1174 INTON;
1175 }
1176 nlpp = pbqlist;
1177 while (*nlpp)
1178 nlpp = &(*nlpp)->next;
1179 *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
1180 (*nlpp)->next = NULL;
1181
1182 if (oldstyle) {
1183 saveprompt = doprompt;
1184 doprompt = 0;
1185 }
1186
1187 n = list(0);
1188
1189 if (oldstyle) {
1190 if (peektoken() != TEOF)
1191 synexpect(-1);
1192 doprompt = saveprompt;
1193 } else
1194 consumetoken(TRP);
1195
1196 (*nlpp)->n = n;
1197 if (oldstyle) {
1198 /*
1199 * Start reading from old file again, ignoring any pushed back
1200 * tokens left from the backquote parsing
1201 */
1202 popfile();
1203 tokpushback = 0;
1204 }
1205 STARTSTACKSTR(out);
1206 CHECKSTRSPACE(savelen + 1, out);
1207 INTOFF;
1208 if (str) {
1209 memcpy(out, str, savelen);
1210 STADJUST(savelen, out);
1211 ckfree(str);
1212 str = NULL;
1213 }
1214 if (ostr) {
1215 ckfree(ostr);
1216 ostr = NULL;
1217 }
1218 here = saveheredoclist;
1219 if (here != NULL) {
1220 while (here->next != NULL)
1221 here = here->next;
1222 here->next = heredoclist;
1223 heredoclist = saveheredoclist;
1224 }
1225 handler = savehandler;
1226 INTON;
1227 if (quoted)
1228 USTPUTC(CTLBACKQ | CTLQUOTE, out);
1229 else
1230 USTPUTC(CTLBACKQ, out);
1231 return out;
1232 }
1233
1234
1235 /*
1236 * Called to parse a backslash escape sequence inside $'...'.
1237 * The backslash has already been read.
1238 */
1239 static char *
readcstyleesc(char * out)1240 readcstyleesc(char *out)
1241 {
1242 int c, vc, i, n;
1243 unsigned int v;
1244
1245 c = pgetc();
1246 switch (c) {
1247 case '\0':
1248 synerror("Unterminated quoted string");
1249 case '\n':
1250 plinno++;
1251 if (doprompt)
1252 setprompt(2);
1253 else
1254 setprompt(0);
1255 return out;
1256 case '\\':
1257 case '\'':
1258 case '"':
1259 v = c;
1260 break;
1261 case 'a': v = '\a'; break;
1262 case 'b': v = '\b'; break;
1263 case 'e': v = '\033'; break;
1264 case 'f': v = '\f'; break;
1265 case 'n': v = '\n'; break;
1266 case 'r': v = '\r'; break;
1267 case 't': v = '\t'; break;
1268 case 'v': v = '\v'; break;
1269 case 'x':
1270 v = 0;
1271 for (;;) {
1272 c = pgetc();
1273 if (c >= '0' && c <= '9')
1274 v = (v << 4) + c - '0';
1275 else if (c >= 'A' && c <= 'F')
1276 v = (v << 4) + c - 'A' + 10;
1277 else if (c >= 'a' && c <= 'f')
1278 v = (v << 4) + c - 'a' + 10;
1279 else
1280 break;
1281 }
1282 pungetc();
1283 break;
1284 case '0': case '1': case '2': case '3':
1285 case '4': case '5': case '6': case '7':
1286 v = c - '0';
1287 c = pgetc();
1288 if (c >= '0' && c <= '7') {
1289 v <<= 3;
1290 v += c - '0';
1291 c = pgetc();
1292 if (c >= '0' && c <= '7') {
1293 v <<= 3;
1294 v += c - '0';
1295 } else
1296 pungetc();
1297 } else
1298 pungetc();
1299 break;
1300 case 'c':
1301 c = pgetc();
1302 if (c < 0x3f || c > 0x7a || c == 0x60)
1303 synerror("Bad escape sequence");
1304 if (c == '\\' && pgetc() != '\\')
1305 synerror("Bad escape sequence");
1306 if (c == '?')
1307 v = 127;
1308 else
1309 v = c & 0x1f;
1310 break;
1311 case 'u':
1312 case 'U':
1313 n = c == 'U' ? 8 : 4;
1314 v = 0;
1315 for (i = 0; i < n; i++) {
1316 c = pgetc();
1317 if (c >= '0' && c <= '9')
1318 v = (v << 4) + c - '0';
1319 else if (c >= 'A' && c <= 'F')
1320 v = (v << 4) + c - 'A' + 10;
1321 else if (c >= 'a' && c <= 'f')
1322 v = (v << 4) + c - 'a' + 10;
1323 else
1324 synerror("Bad escape sequence");
1325 }
1326 if (v == 0 || (v >= 0xd800 && v <= 0xdfff))
1327 synerror("Bad escape sequence");
1328 /* We really need iconv here. */
1329 if (initial_localeisutf8 && v > 127) {
1330 CHECKSTRSPACE(4, out);
1331 /*
1332 * We cannot use wctomb() as the locale may have
1333 * changed.
1334 */
1335 if (v <= 0x7ff) {
1336 USTPUTC(0xc0 | v >> 6, out);
1337 USTPUTC(0x80 | (v & 0x3f), out);
1338 return out;
1339 } else if (v <= 0xffff) {
1340 USTPUTC(0xe0 | v >> 12, out);
1341 USTPUTC(0x80 | ((v >> 6) & 0x3f), out);
1342 USTPUTC(0x80 | (v & 0x3f), out);
1343 return out;
1344 } else if (v <= 0x10ffff) {
1345 USTPUTC(0xf0 | v >> 18, out);
1346 USTPUTC(0x80 | ((v >> 12) & 0x3f), out);
1347 USTPUTC(0x80 | ((v >> 6) & 0x3f), out);
1348 USTPUTC(0x80 | (v & 0x3f), out);
1349 return out;
1350 }
1351 }
1352 if (v > 127)
1353 v = '?';
1354 break;
1355 default:
1356 synerror("Bad escape sequence");
1357 }
1358 vc = (char)v;
1359 /*
1360 * We can't handle NUL bytes.
1361 * POSIX says we should skip till the closing quote.
1362 */
1363 if (vc == '\0') {
1364 while ((c = pgetc()) != '\'') {
1365 if (c == '\\')
1366 c = pgetc();
1367 if (c == PEOF)
1368 synerror("Unterminated quoted string");
1369 if (c == '\n') {
1370 plinno++;
1371 if (doprompt)
1372 setprompt(2);
1373 else
1374 setprompt(0);
1375 }
1376 }
1377 pungetc();
1378 return out;
1379 }
1380 if (SQSYNTAX[vc] == CCTL)
1381 USTPUTC(CTLESC, out);
1382 USTPUTC(vc, out);
1383 return out;
1384 }
1385
1386
1387 /*
1388 * If eofmark is NULL, read a word or a redirection symbol. If eofmark
1389 * is not NULL, read a here document. In the latter case, eofmark is the
1390 * word which marks the end of the document and striptabs is true if
1391 * leading tabs should be stripped from the document. The argument firstc
1392 * is the first character of the input token or document.
1393 *
1394 * Because C does not have internal subroutines, I have simulated them
1395 * using goto's to implement the subroutine linkage. The following macros
1396 * will run code that appears at the end of readtoken1.
1397 */
1398
1399 #define PARSESUB() {goto parsesub; parsesub_return:;}
1400 #define PARSEARITH() {goto parsearith; parsearith_return:;}
1401
1402 static int
readtoken1(int firstc,char const * initialsyntax,const char * eofmark,int striptabs)1403 readtoken1(int firstc, char const *initialsyntax, const char *eofmark,
1404 int striptabs)
1405 {
1406 int c = firstc;
1407 char *out;
1408 int len;
1409 struct nodelist *bqlist;
1410 int quotef;
1411 int newvarnest;
1412 int level;
1413 int synentry;
1414 struct tokenstate state_static[MAXNEST_static];
1415 int maxnest = MAXNEST_static;
1416 struct tokenstate *state = state_static;
1417 int sqiscstyle = 0;
1418
1419 startlinno = plinno;
1420 quotef = 0;
1421 bqlist = NULL;
1422 newvarnest = 0;
1423 level = 0;
1424 state[level].syntax = initialsyntax;
1425 state[level].parenlevel = 0;
1426 state[level].category = TSTATE_TOP;
1427
1428 STARTSTACKSTR(out);
1429 loop: { /* for each line, until end of word */
1430 if (eofmark && eofmark != NOEOFMARK)
1431 /* set c to PEOF if at end of here document */
1432 c = checkend(c, eofmark, striptabs);
1433 for (;;) { /* until end of line or end of word */
1434 CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */
1435
1436 synentry = state[level].syntax[c];
1437
1438 switch(synentry) {
1439 case CNL: /* '\n' */
1440 if (level == 0)
1441 goto endword; /* exit outer loop */
1442 /* FALLTHROUGH */
1443 case CQNL:
1444 USTPUTC(c, out);
1445 plinno++;
1446 if (doprompt)
1447 setprompt(2);
1448 else
1449 setprompt(0);
1450 c = pgetc();
1451 goto loop; /* continue outer loop */
1452 case CSBACK:
1453 if (sqiscstyle) {
1454 out = readcstyleesc(out);
1455 break;
1456 }
1457 /* FALLTHROUGH */
1458 case CWORD:
1459 USTPUTC(c, out);
1460 break;
1461 case CCTL:
1462 if (eofmark == NULL || initialsyntax != SQSYNTAX)
1463 USTPUTC(CTLESC, out);
1464 USTPUTC(c, out);
1465 break;
1466 case CBACK: /* backslash */
1467 c = pgetc();
1468 if (c == PEOF) {
1469 USTPUTC('\\', out);
1470 pungetc();
1471 } else if (c == '\n') {
1472 plinno++;
1473 if (doprompt)
1474 setprompt(2);
1475 else
1476 setprompt(0);
1477 } else {
1478 if (state[level].syntax == DQSYNTAX &&
1479 c != '\\' && c != '`' && c != '$' &&
1480 (c != '"' || (eofmark != NULL &&
1481 newvarnest == 0)) &&
1482 (c != '}' || state[level].category != TSTATE_VAR_OLD))
1483 USTPUTC('\\', out);
1484 if ((eofmark == NULL ||
1485 newvarnest > 0) &&
1486 state[level].syntax == BASESYNTAX)
1487 USTPUTC(CTLQUOTEMARK, out);
1488 if (SQSYNTAX[c] == CCTL)
1489 USTPUTC(CTLESC, out);
1490 USTPUTC(c, out);
1491 if ((eofmark == NULL ||
1492 newvarnest > 0) &&
1493 state[level].syntax == BASESYNTAX &&
1494 state[level].category == TSTATE_VAR_OLD)
1495 USTPUTC(CTLQUOTEEND, out);
1496 quotef++;
1497 }
1498 break;
1499 case CSQUOTE:
1500 USTPUTC(CTLQUOTEMARK, out);
1501 state[level].syntax = SQSYNTAX;
1502 sqiscstyle = 0;
1503 break;
1504 case CDQUOTE:
1505 USTPUTC(CTLQUOTEMARK, out);
1506 state[level].syntax = DQSYNTAX;
1507 break;
1508 case CENDQUOTE:
1509 if (eofmark != NULL && newvarnest == 0)
1510 USTPUTC(c, out);
1511 else {
1512 if (state[level].category == TSTATE_VAR_OLD)
1513 USTPUTC(CTLQUOTEEND, out);
1514 state[level].syntax = BASESYNTAX;
1515 quotef++;
1516 }
1517 break;
1518 case CVAR: /* '$' */
1519 PARSESUB(); /* parse substitution */
1520 break;
1521 case CENDVAR: /* '}' */
1522 if (level > 0 &&
1523 ((state[level].category == TSTATE_VAR_OLD &&
1524 state[level].syntax ==
1525 state[level - 1].syntax) ||
1526 (state[level].category == TSTATE_VAR_NEW &&
1527 state[level].syntax == BASESYNTAX))) {
1528 if (state[level].category == TSTATE_VAR_NEW)
1529 newvarnest--;
1530 level--;
1531 USTPUTC(CTLENDVAR, out);
1532 } else {
1533 USTPUTC(c, out);
1534 }
1535 break;
1536 case CLP: /* '(' in arithmetic */
1537 state[level].parenlevel++;
1538 USTPUTC(c, out);
1539 break;
1540 case CRP: /* ')' in arithmetic */
1541 if (state[level].parenlevel > 0) {
1542 USTPUTC(c, out);
1543 --state[level].parenlevel;
1544 } else {
1545 if (pgetc_linecont() == ')') {
1546 if (level > 0 &&
1547 state[level].category == TSTATE_ARITH) {
1548 level--;
1549 USTPUTC(CTLENDARI, out);
1550 } else
1551 USTPUTC(')', out);
1552 } else {
1553 /*
1554 * unbalanced parens
1555 * (don't 2nd guess - no error)
1556 */
1557 pungetc();
1558 USTPUTC(')', out);
1559 }
1560 }
1561 break;
1562 case CBQUOTE: /* '`' */
1563 out = parsebackq(out, &bqlist, 1,
1564 state[level].syntax == DQSYNTAX &&
1565 (eofmark == NULL || newvarnest > 0),
1566 state[level].syntax == DQSYNTAX || state[level].syntax == ARISYNTAX);
1567 break;
1568 case CEOF:
1569 goto endword; /* exit outer loop */
1570 case CIGN:
1571 break;
1572 default:
1573 if (level == 0)
1574 goto endword; /* exit outer loop */
1575 USTPUTC(c, out);
1576 }
1577 c = pgetc_macro();
1578 }
1579 }
1580 endword:
1581 if (state[level].syntax == ARISYNTAX)
1582 synerror("Missing '))'");
1583 if (state[level].syntax != BASESYNTAX && eofmark == NULL)
1584 synerror("Unterminated quoted string");
1585 if (state[level].category == TSTATE_VAR_OLD ||
1586 state[level].category == TSTATE_VAR_NEW) {
1587 startlinno = plinno;
1588 synerror("Missing '}'");
1589 }
1590 if (state != state_static)
1591 parser_temp_free_upto(state);
1592 USTPUTC('\0', out);
1593 len = out - stackblock();
1594 out = stackblock();
1595 if (eofmark == NULL) {
1596 if ((c == '>' || c == '<')
1597 && quotef == 0
1598 && len <= 2
1599 && (*out == '\0' || is_digit(*out))) {
1600 parseredir(out, c);
1601 return lasttoken = TREDIR;
1602 } else {
1603 pungetc();
1604 }
1605 }
1606 quoteflag = quotef;
1607 backquotelist = bqlist;
1608 grabstackblock(len);
1609 wordtext = out;
1610 return lasttoken = TWORD;
1611 /* end of readtoken routine */
1612
1613
1614 /*
1615 * Parse a substitution. At this point, we have read the dollar sign
1616 * and nothing else.
1617 */
1618
1619 parsesub: {
1620 int subtype;
1621 int typeloc;
1622 int flags;
1623 char *p;
1624 static const char types[] = "}-+?=";
1625 int linno;
1626 int length;
1627 int c1;
1628
1629 c = pgetc_linecont();
1630 if (c == '(') { /* $(command) or $((arith)) */
1631 if (pgetc_linecont() == '(') {
1632 PARSEARITH();
1633 } else {
1634 pungetc();
1635 out = parsebackq(out, &bqlist, 0,
1636 state[level].syntax == DQSYNTAX &&
1637 (eofmark == NULL || newvarnest > 0),
1638 state[level].syntax == DQSYNTAX ||
1639 state[level].syntax == ARISYNTAX);
1640 }
1641 } else if (c == '{' || is_name(c) || is_special(c)) {
1642 USTPUTC(CTLVAR, out);
1643 typeloc = out - stackblock();
1644 USTPUTC(VSNORMAL, out);
1645 subtype = VSNORMAL;
1646 flags = 0;
1647 if (c == '{') {
1648 c = pgetc_linecont();
1649 subtype = 0;
1650 }
1651 varname:
1652 if (!is_eof(c) && is_name(c)) {
1653 length = 0;
1654 do {
1655 STPUTC(c, out);
1656 c = pgetc_linecont();
1657 length++;
1658 } while (!is_eof(c) && is_in_name(c));
1659 if (length == 6 &&
1660 strncmp(out - length, "LINENO", length) == 0) {
1661 /* Replace the variable name with the
1662 * current line number. */
1663 STADJUST(-6, out);
1664 CHECKSTRSPACE(11, out);
1665 linno = plinno;
1666 if (funclinno != 0)
1667 linno -= funclinno - 1;
1668 length = snprintf(out, 11, "%d", linno);
1669 if (length > 10)
1670 length = 10;
1671 out += length;
1672 flags |= VSLINENO;
1673 }
1674 } else if (is_digit(c)) {
1675 if (subtype != VSNORMAL) {
1676 do {
1677 STPUTC(c, out);
1678 c = pgetc_linecont();
1679 } while (is_digit(c));
1680 } else {
1681 USTPUTC(c, out);
1682 c = pgetc_linecont();
1683 }
1684 } else if (is_special(c)) {
1685 c1 = c;
1686 c = pgetc_linecont();
1687 if (subtype == 0 && c1 == '#') {
1688 subtype = VSLENGTH;
1689 if (strchr(types, c) == NULL && c != ':' &&
1690 c != '#' && c != '%')
1691 goto varname;
1692 c1 = c;
1693 c = pgetc_linecont();
1694 if (c1 != '}' && c == '}') {
1695 pungetc();
1696 c = c1;
1697 goto varname;
1698 }
1699 pungetc();
1700 c = c1;
1701 c1 = '#';
1702 subtype = 0;
1703 }
1704 USTPUTC(c1, out);
1705 } else {
1706 subtype = VSERROR;
1707 if (c == '}')
1708 pungetc();
1709 else if (c == '\n' || c == PEOF)
1710 synerror("Unexpected end of line in substitution");
1711 else if (BASESYNTAX[c] != CCTL)
1712 USTPUTC(c, out);
1713 }
1714 if (subtype == 0) {
1715 switch (c) {
1716 case ':':
1717 flags |= VSNUL;
1718 c = pgetc_linecont();
1719 /*FALLTHROUGH*/
1720 default:
1721 p = strchr(types, c);
1722 if (p == NULL) {
1723 if (c == '\n' || c == PEOF)
1724 synerror("Unexpected end of line in substitution");
1725 if (flags == VSNUL)
1726 STPUTC(':', out);
1727 if (BASESYNTAX[c] != CCTL)
1728 STPUTC(c, out);
1729 subtype = VSERROR;
1730 } else
1731 subtype = p - types + VSNORMAL;
1732 break;
1733 case '%':
1734 case '#':
1735 {
1736 int cc = c;
1737 subtype = c == '#' ? VSTRIMLEFT :
1738 VSTRIMRIGHT;
1739 c = pgetc_linecont();
1740 if (c == cc)
1741 subtype++;
1742 else
1743 pungetc();
1744 break;
1745 }
1746 }
1747 } else if (subtype != VSERROR) {
1748 if (subtype == VSLENGTH && c != '}')
1749 subtype = VSERROR;
1750 pungetc();
1751 }
1752 STPUTC('=', out);
1753 if (state[level].syntax == DQSYNTAX ||
1754 state[level].syntax == ARISYNTAX)
1755 flags |= VSQUOTE;
1756 *(stackblock() + typeloc) = subtype | flags;
1757 if (subtype != VSNORMAL) {
1758 if (level + 1 >= maxnest) {
1759 maxnest *= 2;
1760 if (state == state_static) {
1761 state = parser_temp_alloc(
1762 maxnest * sizeof(*state));
1763 memcpy(state, state_static,
1764 MAXNEST_static * sizeof(*state));
1765 } else
1766 state = parser_temp_realloc(state,
1767 maxnest * sizeof(*state));
1768 }
1769 level++;
1770 state[level].parenlevel = 0;
1771 if (subtype == VSMINUS || subtype == VSPLUS ||
1772 subtype == VSQUESTION || subtype == VSASSIGN) {
1773 /*
1774 * For operators that were in the Bourne shell,
1775 * inherit the double-quote state.
1776 */
1777 state[level].syntax = state[level - 1].syntax;
1778 state[level].category = TSTATE_VAR_OLD;
1779 } else {
1780 /*
1781 * The other operators take a pattern,
1782 * so go to BASESYNTAX.
1783 * Also, ' and " are now special, even
1784 * in here documents.
1785 */
1786 state[level].syntax = BASESYNTAX;
1787 state[level].category = TSTATE_VAR_NEW;
1788 newvarnest++;
1789 }
1790 }
1791 } else if (c == '\'' && state[level].syntax == BASESYNTAX) {
1792 /* $'cstylequotes' */
1793 USTPUTC(CTLQUOTEMARK, out);
1794 state[level].syntax = SQSYNTAX;
1795 sqiscstyle = 1;
1796 } else {
1797 USTPUTC('$', out);
1798 pungetc();
1799 }
1800 goto parsesub_return;
1801 }
1802
1803
1804 /*
1805 * Parse an arithmetic expansion (indicate start of one and set state)
1806 */
1807 parsearith: {
1808
1809 if (level + 1 >= maxnest) {
1810 maxnest *= 2;
1811 if (state == state_static) {
1812 state = parser_temp_alloc(
1813 maxnest * sizeof(*state));
1814 memcpy(state, state_static,
1815 MAXNEST_static * sizeof(*state));
1816 } else
1817 state = parser_temp_realloc(state,
1818 maxnest * sizeof(*state));
1819 }
1820 level++;
1821 state[level].syntax = ARISYNTAX;
1822 state[level].parenlevel = 0;
1823 state[level].category = TSTATE_ARITH;
1824 USTPUTC(CTLARI, out);
1825 if (state[level - 1].syntax == DQSYNTAX)
1826 USTPUTC('"',out);
1827 else
1828 USTPUTC(' ',out);
1829 goto parsearith_return;
1830 }
1831
1832 } /* end of readtoken */
1833
1834
1835 /*
1836 * Returns true if the text contains nothing to expand (no dollar signs
1837 * or backquotes).
1838 */
1839
1840 static int
noexpand(char * text)1841 noexpand(char *text)
1842 {
1843 char *p;
1844 char c;
1845
1846 p = text;
1847 while ((c = *p++) != '\0') {
1848 if ( c == CTLQUOTEMARK)
1849 continue;
1850 if (c == CTLESC)
1851 p++;
1852 else if (BASESYNTAX[(int)c] == CCTL)
1853 return 0;
1854 }
1855 return 1;
1856 }
1857
1858
1859 /*
1860 * Return true if the argument is a legal variable name (a letter or
1861 * underscore followed by zero or more letters, underscores, and digits).
1862 */
1863
1864 int
goodname(const char * name)1865 goodname(const char *name)
1866 {
1867 const char *p;
1868
1869 p = name;
1870 if (! is_name(*p))
1871 return 0;
1872 while (*++p) {
1873 if (! is_in_name(*p))
1874 return 0;
1875 }
1876 return 1;
1877 }
1878
1879
1880 int
isassignment(const char * p)1881 isassignment(const char *p)
1882 {
1883 if (!is_name(*p))
1884 return 0;
1885 p++;
1886 for (;;) {
1887 if (*p == '=')
1888 return 1;
1889 else if (!is_in_name(*p))
1890 return 0;
1891 p++;
1892 }
1893 }
1894
1895
1896 static void
consumetoken(int token)1897 consumetoken(int token)
1898 {
1899 if (readtoken() != token)
1900 synexpect(token);
1901 }
1902
1903
1904 /*
1905 * Called when an unexpected token is read during the parse. The argument
1906 * is the token that is expected, or -1 if more than one type of token can
1907 * occur at this point.
1908 */
1909
1910 static void
synexpect(int token)1911 synexpect(int token)
1912 {
1913 char msg[64];
1914
1915 if (token >= 0) {
1916 fmtstr(msg, 64, "%s unexpected (expecting %s)",
1917 tokname[lasttoken], tokname[token]);
1918 } else {
1919 fmtstr(msg, 64, "%s unexpected", tokname[lasttoken]);
1920 }
1921 synerror(msg);
1922 }
1923
1924
1925 static void
synerror(const char * msg)1926 synerror(const char *msg)
1927 {
1928 if (commandname)
1929 outfmt(out2, "%s: %d: ", commandname, startlinno);
1930 else if (arg0)
1931 outfmt(out2, "%s: ", arg0);
1932 outfmt(out2, "Syntax error: %s\n", msg);
1933 error((char *)NULL);
1934 }
1935
1936 static void
setprompt(int which)1937 setprompt(int which)
1938 {
1939 whichprompt = which;
1940 if (which == 0)
1941 return;
1942
1943 #ifndef NO_HISTORY
1944 if (!el)
1945 #endif
1946 {
1947 out2str(getprompt(NULL));
1948 flushout(out2);
1949 }
1950 }
1951
1952 static int
pgetc_linecont(void)1953 pgetc_linecont(void)
1954 {
1955 int c;
1956
1957 while ((c = pgetc_macro()) == '\\') {
1958 c = pgetc();
1959 if (c == '\n') {
1960 plinno++;
1961 if (doprompt)
1962 setprompt(2);
1963 else
1964 setprompt(0);
1965 } else {
1966 pungetc();
1967 /* Allow the backslash to be pushed back. */
1968 pushstring("\\", 1, NULL);
1969 return (pgetc());
1970 }
1971 }
1972 return (c);
1973 }
1974
1975
1976 static struct passwd *
getpwlogin(void)1977 getpwlogin(void)
1978 {
1979 const char *login;
1980
1981 login = getlogin();
1982 if (login == NULL)
1983 return (NULL);
1984
1985 return (getpwnam(login));
1986 }
1987
1988
1989 static void
getusername(char * name,size_t namelen)1990 getusername(char *name, size_t namelen)
1991 {
1992 static char cached_name[MAXLOGNAME];
1993 struct passwd *pw;
1994 uid_t euid;
1995
1996 if (cached_name[0] == '\0') {
1997 euid = geteuid();
1998
1999 /*
2000 * Handle the case when there is more than one
2001 * login with the same UID, or when the login
2002 * returned by getlogin(2) does no longer match
2003 * the current UID.
2004 */
2005 pw = getpwlogin();
2006 if (pw == NULL || pw->pw_uid != euid)
2007 pw = getpwuid(euid);
2008
2009 if (pw != NULL) {
2010 strlcpy(cached_name, pw->pw_name,
2011 sizeof(cached_name));
2012 } else {
2013 snprintf(cached_name, sizeof(cached_name),
2014 "%u", euid);
2015 }
2016 }
2017
2018 strlcpy(name, cached_name, namelen);
2019 }
2020
2021
2022 /*
2023 * called by editline -- any expansions to the prompt
2024 * should be added here.
2025 */
2026 char *
getprompt(void * unused __unused)2027 getprompt(void *unused __unused)
2028 {
2029 static char ps[PROMPTLEN];
2030 const char *fmt;
2031 const char *home;
2032 const char *pwd;
2033 size_t homelen;
2034 int i, trim;
2035 static char internal_error[] = "??";
2036
2037 /*
2038 * Select prompt format.
2039 */
2040 switch (whichprompt) {
2041 case 0:
2042 fmt = "";
2043 break;
2044 case 1:
2045 fmt = ps1val();
2046 break;
2047 case 2:
2048 fmt = ps2val();
2049 break;
2050 default:
2051 return internal_error;
2052 }
2053
2054 /*
2055 * Format prompt string.
2056 */
2057 for (i = 0; (i < PROMPTLEN - 1) && (*fmt != '\0'); i++, fmt++)
2058 if (*fmt == '\\')
2059 switch (*++fmt) {
2060
2061 /*
2062 * Non-printing sequence begin and end.
2063 */
2064 case '[':
2065 case ']':
2066 ps[i] = '\001';
2067 break;
2068
2069 /*
2070 * Literal \ and some ASCII characters:
2071 * \a BEL
2072 * \e ESC
2073 * \r CR
2074 */
2075 case '\\':
2076 case 'a':
2077 case 'e':
2078 case 'r':
2079 if (*fmt == 'a')
2080 ps[i] = '\007';
2081 else if (*fmt == 'e')
2082 ps[i] = '\033';
2083 else if (*fmt == 'r')
2084 ps[i] = '\r';
2085 else
2086 ps[i] = '\\';
2087 break;
2088
2089 /*
2090 * CRLF sequence
2091 */
2092 case 'n':
2093 if (i < PROMPTLEN - 3) {
2094 ps[i++] = '\r';
2095 ps[i] = '\n';
2096 }
2097 break;
2098
2099 /*
2100 * Hostname.
2101 *
2102 * \h specifies just the local hostname,
2103 * \H specifies fully-qualified hostname.
2104 */
2105 case 'h':
2106 case 'H':
2107 ps[i] = '\0';
2108 gethostname(&ps[i], PROMPTLEN - i - 1);
2109 ps[PROMPTLEN - 1] = '\0';
2110 /* Skip to end of hostname. */
2111 trim = (*fmt == 'h') ? '.' : '\0';
2112 while ((ps[i] != '\0') && (ps[i] != trim))
2113 i++;
2114 --i;
2115 break;
2116
2117 /*
2118 * User name.
2119 */
2120 case 'u':
2121 ps[i] = '\0';
2122 getusername(&ps[i], PROMPTLEN - i);
2123 /* Skip to end of username. */
2124 while (ps[i + 1] != '\0')
2125 i++;
2126 break;
2127
2128 /*
2129 * Working directory.
2130 *
2131 * \W specifies just the final component,
2132 * \w specifies the entire path.
2133 */
2134 case 'W':
2135 case 'w':
2136 pwd = lookupvar("PWD");
2137 if (pwd == NULL || *pwd == '\0')
2138 pwd = "?";
2139 if (*fmt == 'W' &&
2140 *pwd == '/' && pwd[1] != '\0')
2141 strlcpy(&ps[i], strrchr(pwd, '/') + 1,
2142 PROMPTLEN - i);
2143 else {
2144 home = lookupvar("HOME");
2145 if (home != NULL)
2146 homelen = strlen(home);
2147 if (home != NULL &&
2148 strcmp(home, "/") != 0 &&
2149 strncmp(pwd, home, homelen) == 0 &&
2150 (pwd[homelen] == '/' ||
2151 pwd[homelen] == '\0')) {
2152 strlcpy(&ps[i], "~",
2153 PROMPTLEN - i);
2154 strlcpy(&ps[i + 1],
2155 pwd + homelen,
2156 PROMPTLEN - i - 1);
2157 } else {
2158 strlcpy(&ps[i], pwd, PROMPTLEN - i);
2159 }
2160 }
2161 /* Skip to end of path. */
2162 while (ps[i + 1] != '\0')
2163 i++;
2164 break;
2165
2166 /*
2167 * Superuser status.
2168 *
2169 * '$' for normal users, '#' for root.
2170 */
2171 case '$':
2172 ps[i] = (geteuid() != 0) ? '$' : '#';
2173 break;
2174
2175 /*
2176 * Emit unrecognized formats verbatim.
2177 */
2178 default:
2179 ps[i] = '\\';
2180 if (i < PROMPTLEN - 2)
2181 ps[++i] = *fmt;
2182 break;
2183 }
2184 else
2185 ps[i] = *fmt;
2186 ps[i] = '\0';
2187 return (ps);
2188 }
2189
2190
2191 const char *
expandstr(const char * ps)2192 expandstr(const char *ps)
2193 {
2194 union node n;
2195 struct jmploc jmploc;
2196 struct jmploc *const savehandler = handler;
2197 const int saveprompt = doprompt;
2198 struct parsefile *const savetopfile = getcurrentfile();
2199 struct parser_temp *const saveparser_temp = parser_temp;
2200 const char *result = NULL;
2201
2202 if (!setjmp(jmploc.loc)) {
2203 handler = &jmploc;
2204 parser_temp = NULL;
2205 setinputstring(ps, 1);
2206 doprompt = 0;
2207 readtoken1(pgetc(), DQSYNTAX, NOEOFMARK, 0);
2208 if (backquotelist != NULL)
2209 error("Command substitution not allowed here");
2210
2211 n.narg.type = NARG;
2212 n.narg.next = NULL;
2213 n.narg.text = wordtext;
2214 n.narg.backquote = backquotelist;
2215
2216 expandarg(&n, NULL, 0);
2217 result = stackblock();
2218 INTOFF;
2219 }
2220 handler = savehandler;
2221 doprompt = saveprompt;
2222 popfilesupto(savetopfile);
2223 if (parser_temp != saveparser_temp) {
2224 parser_temp_free_all();
2225 parser_temp = saveparser_temp;
2226 }
2227 if (result != NULL) {
2228 INTON;
2229 } else if (exception == EXINT)
2230 raise(SIGINT);
2231 return result;
2232 }
2233