summaryrefslogtreecommitdiff
path: root/bin/sh/parser.c
diff options
context:
space:
mode:
Diffstat (limited to 'bin/sh/parser.c')
-rw-r--r--bin/sh/parser.c2756
1 files changed, 2756 insertions, 0 deletions
diff --git a/bin/sh/parser.c b/bin/sh/parser.c
new file mode 100644
index 0000000..6b153aa
--- /dev/null
+++ b/bin/sh/parser.c
@@ -0,0 +1,2756 @@
+/* $NetBSD: parser.c,v 1.164 2019/01/22 14:32:17 kre Exp $ */
+
+/*-
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Kenneth Almquist.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)parser.c 8.7 (Berkeley) 5/16/95";
+#else
+__RCSID("$NetBSD: parser.c,v 1.164 2019/01/22 14:32:17 kre Exp $");
+#endif
+#endif /* not lint */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#include "shell.h"
+#include "parser.h"
+#include "nodes.h"
+#include "expand.h" /* defines rmescapes() */
+#include "eval.h" /* defines commandname */
+#include "syntax.h"
+#include "options.h"
+#include "input.h"
+#include "output.h"
+#include "var.h"
+#include "error.h"
+#include "memalloc.h"
+#include "mystring.h"
+#include "alias.h"
+#include "show.h"
+#ifndef SMALL
+#include "myhistedit.h"
+#endif
+#ifdef DEBUG
+#include "nodenames.h"
+#endif
+
+/*
+ * Shell command parser.
+ */
+
+/* values returned by readtoken */
+#include "token.h"
+
+#define OPENBRACE '{'
+#define CLOSEBRACE '}'
+
+struct HereDoc {
+ struct HereDoc *next; /* next here document in list */
+ union node *here; /* redirection node */
+ char *eofmark; /* string indicating end of input */
+ int striptabs; /* if set, strip leading tabs */
+ int startline; /* line number where << seen */
+};
+
+MKINIT struct parse_state parse_state;
+union parse_state_p psp = { .c_current_parser = &parse_state };
+
+static const struct parse_state init_parse_state = { /* all 0's ... */
+ .ps_heredoclist = NULL,
+ .ps_parsebackquote = 0,
+ .ps_doprompt = 0,
+ .ps_needprompt = 0,
+ .ps_lasttoken = 0,
+ .ps_tokpushback = 0,
+ .ps_wordtext = NULL,
+ .ps_checkkwd = 0,
+ .ps_redirnode = NULL,
+ .ps_heredoc = NULL,
+ .ps_quoteflag = 0,
+ .ps_startlinno = 0,
+ .ps_funclinno = 0,
+ .ps_elided_nl = 0,
+};
+
+STATIC union node *list(int);
+STATIC union node *andor(void);
+STATIC union node *pipeline(void);
+STATIC union node *command(void);
+STATIC union node *simplecmd(union node **, union node *);
+STATIC union node *makeword(int);
+STATIC void parsefname(void);
+STATIC int slurp_heredoc(char *const, const int, const int);
+STATIC void readheredocs(void);
+STATIC int peektoken(void);
+STATIC int readtoken(void);
+STATIC int xxreadtoken(void);
+STATIC int readtoken1(int, char const *, int);
+STATIC int noexpand(char *);
+STATIC void linebreak(void);
+STATIC void consumetoken(int);
+STATIC void synexpect(int, const char *) __dead;
+STATIC void synerror(const char *) __dead;
+STATIC void setprompt(int);
+STATIC int pgetc_linecont(void);
+
+static const char EOFhere[] = "EOF reading here (<<) document";
+
+#ifdef DEBUG
+int parsing = 0;
+#endif
+
+/*
+ * Read and parse a command. Returns NEOF on end of file. (NULL is a
+ * valid parse tree indicating a blank line.)
+ */
+
+union node *
+parsecmd(int interact)
+{
+ int t;
+ union node *n;
+
+#ifdef DEBUG
+ parsing++;
+#endif
+ tokpushback = 0;
+ checkkwd = 0;
+ doprompt = interact;
+ if (doprompt)
+ setprompt(1);
+ else
+ setprompt(0);
+ needprompt = 0;
+ t = readtoken();
+#ifdef DEBUG
+ parsing--;
+#endif
+ if (t == TEOF)
+ return NEOF;
+ if (t == TNL)
+ return NULL;
+
+#ifdef DEBUG
+ parsing++;
+#endif
+ tokpushback++;
+ n = list(1);
+#ifdef DEBUG
+ parsing--;
+#endif
+ if (heredoclist)
+ error("%d: Here document (<<%s) expected but not present",
+ heredoclist->startline, heredoclist->eofmark);
+ return n;
+}
+
+
+STATIC union node *
+list(int nlflag)
+{
+ union node *ntop, *n1, *n2, *n3;
+ int tok;
+
+ CTRACE(DBG_PARSE, ("list(%d): entered @%d\n",nlflag,plinno));
+
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if (nlflag == 0 && tokendlist[peektoken()])
+ return NULL;
+ ntop = n1 = NULL;
+ for (;;) {
+ n2 = andor();
+ tok = readtoken();
+ if (tok == TBACKGND) {
+ if (n2->type == NCMD || n2->type == NPIPE)
+ n2->ncmd.backgnd = 1;
+ else if (n2->type == NREDIR)
+ n2->type = NBACKGND;
+ else {
+ n3 = stalloc(sizeof(struct nredir));
+ n3->type = NBACKGND;
+ n3->nredir.n = n2;
+ n3->nredir.redirect = NULL;
+ n2 = n3;
+ }
+ }
+
+ if (ntop == NULL)
+ ntop = n2;
+ else if (n1 == NULL) {
+ n1 = stalloc(sizeof(struct nbinary));
+ n1->type = NSEMI;
+ n1->nbinary.ch1 = ntop;
+ n1->nbinary.ch2 = n2;
+ ntop = n1;
+ } else {
+ n3 = stalloc(sizeof(struct nbinary));
+ n3->type = NSEMI;
+ n3->nbinary.ch1 = n1->nbinary.ch2;
+ n3->nbinary.ch2 = n2;
+ n1->nbinary.ch2 = n3;
+ n1 = n3;
+ }
+
+ switch (tok) {
+ case TBACKGND:
+ case TSEMI:
+ tok = readtoken();
+ /* FALLTHROUGH */
+ case TNL:
+ if (tok == TNL) {
+ readheredocs();
+ if (nlflag)
+ return ntop;
+ } else if (tok == TEOF && nlflag)
+ return ntop;
+ else
+ tokpushback++;
+
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if (!nlflag && tokendlist[peektoken()])
+ return ntop;
+ break;
+ case TEOF:
+ pungetc(); /* push back EOF on input */
+ return ntop;
+ default:
+ if (nlflag)
+ synexpect(-1, 0);
+ tokpushback++;
+ return ntop;
+ }
+ }
+}
+
+STATIC union node *
+andor(void)
+{
+ union node *n1, *n2, *n3;
+ int t;
+
+ CTRACE(DBG_PARSE, ("andor: entered @%d\n", plinno));
+
+ n1 = pipeline();
+ for (;;) {
+ if ((t = readtoken()) == TAND) {
+ t = NAND;
+ } else if (t == TOR) {
+ t = NOR;
+ } else {
+ tokpushback++;
+ return n1;
+ }
+ n2 = pipeline();
+ n3 = stalloc(sizeof(struct nbinary));
+ n3->type = t;
+ n3->nbinary.ch1 = n1;
+ n3->nbinary.ch2 = n2;
+ n1 = n3;
+ }
+}
+
+STATIC union node *
+pipeline(void)
+{
+ union node *n1, *n2, *pipenode;
+ struct nodelist *lp, *prev;
+ int negate;
+
+ CTRACE(DBG_PARSE, ("pipeline: entered @%d\n", plinno));
+
+ negate = 0;
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ while (readtoken() == TNOT) {
+ CTRACE(DBG_PARSE, ("pipeline: TNOT recognized\n"));
+#ifndef BOGUS_NOT_COMMAND
+ if (posix && negate)
+ synerror("2nd \"!\" unexpected");
+#endif
+ negate++;
+ }
+ tokpushback++;
+ n1 = command();
+ if (readtoken() == TPIPE) {
+ pipenode = stalloc(sizeof(struct npipe));
+ pipenode->type = NPIPE;
+ pipenode->npipe.backgnd = 0;
+ lp = stalloc(sizeof(struct nodelist));
+ pipenode->npipe.cmdlist = lp;
+ lp->n = n1;
+ do {
+ prev = lp;
+ lp = stalloc(sizeof(struct nodelist));
+ lp->n = command();
+ prev->next = lp;
+ } while (readtoken() == TPIPE);
+ lp->next = NULL;
+ n1 = pipenode;
+ }
+ tokpushback++;
+ if (negate) {
+ CTRACE(DBG_PARSE, ("%snegate pipeline\n",
+ (negate&1) ? "" : "double "));
+ n2 = stalloc(sizeof(struct nnot));
+ n2->type = (negate & 1) ? NNOT : NDNOT;
+ n2->nnot.com = n1;
+ return n2;
+ } else
+ return n1;
+}
+
+
+
+STATIC union node *
+command(void)
+{
+ union node *n1, *n2;
+ union node *ap, **app;
+ union node *cp, **cpp;
+ union node *redir, **rpp;
+ int t;
+#ifdef BOGUS_NOT_COMMAND
+ int negate = 0;
+#endif
+
+ CTRACE(DBG_PARSE, ("command: entered @%d\n", plinno));
+
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ redir = NULL;
+ n1 = NULL;
+ rpp = &redir;
+
+ /* Check for redirection which may precede command */
+ while (readtoken() == TREDIR) {
+ *rpp = n2 = redirnode;
+ rpp = &n2->nfile.next;
+ parsefname();
+ }
+ tokpushback++;
+
+#ifdef BOGUS_NOT_COMMAND /* only in pileline() */
+ while (readtoken() == TNOT) {
+ CTRACE(DBG_PARSE, ("command: TNOT (bogus) recognized\n"));
+ negate++;
+ }
+ tokpushback++;
+#endif
+
+ switch (readtoken()) {
+ case TIF:
+ n1 = stalloc(sizeof(struct nif));
+ n1->type = NIF;
+ n1->nif.test = list(0);
+ consumetoken(TTHEN);
+ n1->nif.ifpart = list(0);
+ n2 = n1;
+ while (readtoken() == TELIF) {
+ n2->nif.elsepart = stalloc(sizeof(struct nif));
+ n2 = n2->nif.elsepart;
+ n2->type = NIF;
+ n2->nif.test = list(0);
+ consumetoken(TTHEN);
+ n2->nif.ifpart = list(0);
+ }
+ if (lasttoken == TELSE)
+ n2->nif.elsepart = list(0);
+ else {
+ n2->nif.elsepart = NULL;
+ tokpushback++;
+ }
+ consumetoken(TFI);
+ checkkwd = CHKKWD | CHKALIAS;
+ break;
+ case TWHILE:
+ case TUNTIL:
+ n1 = stalloc(sizeof(struct nbinary));
+ n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
+ n1->nbinary.ch1 = list(0);
+ consumetoken(TDO);
+ n1->nbinary.ch2 = list(0);
+ consumetoken(TDONE);
+ checkkwd = CHKKWD | CHKALIAS;
+ break;
+ case TFOR:
+ if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
+ synerror("Bad for loop variable");
+ n1 = stalloc(sizeof(struct nfor));
+ n1->type = NFOR;
+ n1->nfor.var = wordtext;
+ linebreak();
+ if (lasttoken==TWORD && !quoteflag && equal(wordtext,"in")) {
+ app = &ap;
+ while (readtoken() == TWORD) {
+ n2 = makeword(startlinno);
+ *app = n2;
+ app = &n2->narg.next;
+ }
+ *app = NULL;
+ n1->nfor.args = ap;
+ if (lasttoken != TNL && lasttoken != TSEMI)
+ synexpect(TSEMI, 0);
+ } else {
+ static char argvars[5] = {
+ CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'
+ };
+
+ n2 = stalloc(sizeof(struct narg));
+ n2->type = NARG;
+ n2->narg.text = argvars;
+ n2->narg.backquote = NULL;
+ n2->narg.next = NULL;
+ n2->narg.lineno = startlinno;
+ n1->nfor.args = n2;
+ /*
+ * Newline or semicolon here is optional (but note
+ * that the original Bourne shell only allowed NL).
+ */
+ if (lasttoken != TNL && lasttoken != TSEMI)
+ tokpushback++;
+ }
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if ((t = readtoken()) == TDO)
+ t = TDONE;
+ else if (t == TBEGIN)
+ t = TEND;
+ else
+ synexpect(TDO, 0);
+ n1->nfor.body = list(0);
+ consumetoken(t);
+ checkkwd = CHKKWD | CHKALIAS;
+ break;
+ case TCASE:
+ n1 = stalloc(sizeof(struct ncase));
+ n1->type = NCASE;
+ n1->ncase.lineno = startlinno - elided_nl;
+ consumetoken(TWORD);
+ n1->ncase.expr = makeword(startlinno);
+ linebreak();
+ if (lasttoken != TWORD || !equal(wordtext, "in"))
+ synexpect(-1, "in");
+ cpp = &n1->ncase.cases;
+ checkkwd = CHKNL | CHKKWD;
+ readtoken();
+ /*
+ * Both ksh and bash accept 'case x in esac'
+ * so configure scripts started taking advantage of this.
+ * The page: http://pubs.opengroup.org/onlinepubs/\
+ * 009695399/utilities/xcu_chap02.html contradicts itself,
+ * as to if this is legal; the "Case Conditional Format"
+ * paragraph shows one case is required, but the "Grammar"
+ * section shows a grammar that explicitly allows the no
+ * case option.
+ *
+ * The standard also says (section 2.10):
+ * This formal syntax shall take precedence over the
+ * preceding text syntax description.
+ * ie: the "Grammar" section wins. The text is just
+ * a rough guide (introduction to the common case.)
+ */
+ while (lasttoken != TESAC) {
+ *cpp = cp = stalloc(sizeof(struct nclist));
+ cp->type = NCLIST;
+ app = &cp->nclist.pattern;
+ if (lasttoken == TLP)
+ readtoken();
+ for (;;) {
+ if (lasttoken < TWORD)
+ synexpect(TWORD, 0);
+ *app = ap = makeword(startlinno);
+ checkkwd = CHKNL | CHKKWD;
+ if (readtoken() != TPIPE)
+ break;
+ app = &ap->narg.next;
+ readtoken();
+ }
+ if (lasttoken != TRP)
+ synexpect(TRP, 0);
+ cp->nclist.lineno = startlinno;
+ cp->nclist.body = list(0);
+
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if ((t = readtoken()) != TESAC) {
+ if (t != TENDCASE && t != TCASEFALL) {
+ synexpect(TENDCASE, 0);
+ } else {
+ if (t == TCASEFALL)
+ cp->type = NCLISTCONT;
+ checkkwd = CHKNL | CHKKWD;
+ readtoken();
+ }
+ }
+ cpp = &cp->nclist.next;
+ }
+ *cpp = NULL;
+ checkkwd = CHKKWD | CHKALIAS;
+ break;
+ case TLP:
+ n1 = stalloc(sizeof(struct nredir));
+ n1->type = NSUBSHELL;
+ n1->nredir.n = list(0);
+ n1->nredir.redirect = NULL;
+ if (n1->nredir.n == NULL)
+ synexpect(-1, 0);
+ consumetoken(TRP);
+ checkkwd = CHKKWD | CHKALIAS;
+ break;
+ case TBEGIN:
+ n1 = list(0);
+ if (posix && n1 == NULL)
+ synexpect(-1, 0);
+ consumetoken(TEND);
+ checkkwd = CHKKWD | CHKALIAS;
+ break;
+
+ case TBACKGND:
+ case TSEMI:
+ case TAND:
+ case TOR:
+ case TPIPE:
+ case TNL:
+ case TEOF:
+ case TRP:
+ case TENDCASE:
+ case TCASEFALL:
+ /*
+ * simple commands must have something in them,
+ * either a word (which at this point includes a=b)
+ * or a redirection. If we reached the end of the
+ * command (which one of these tokens indicates)
+ * when we are just starting, and have not had a
+ * redirect, then ...
+ *
+ * nb: it is still possible to end up with empty
+ * simple commands, if the "command" is a var
+ * expansion that produces nothing:
+ * X= ; $X && $X
+ * --> &&
+ * That is OK and is handled after word expansions.
+ */
+ if (!redir)
+ synexpect(-1, 0);
+ /*
+ * continue to build a node containing the redirect.
+ * the tokpushback means that our ending token will be
+ * read again in simplecmd, causing it to terminate,
+ * so only the redirect(s) will be contained in the
+ * returned n1
+ */
+ /* FALLTHROUGH */
+ case TWORD:
+ tokpushback++;
+ n1 = simplecmd(rpp, redir);
+ goto checkneg;
+ default:
+ synexpect(-1, 0);
+ /* NOTREACHED */
+ }
+
+ /* Now check for redirection which may follow command */
+ while (readtoken() == TREDIR) {
+ *rpp = n2 = redirnode;
+ rpp = &n2->nfile.next;
+ parsefname();
+ }
+ tokpushback++;
+ *rpp = NULL;
+ if (redir) {
+ if (n1 == NULL || n1->type != NSUBSHELL) {
+ n2 = stalloc(sizeof(struct nredir));
+ n2->type = NREDIR;
+ n2->nredir.n = n1;
+ n1 = n2;
+ }
+ n1->nredir.redirect = redir;
+ }
+
+ checkneg:
+#ifdef BOGUS_NOT_COMMAND
+ if (negate) {
+ VTRACE(DBG_PARSE, ("bogus %snegate command\n",
+ (negate&1) ? "" : "double "));
+ n2 = stalloc(sizeof(struct nnot));
+ n2->type = (negate & 1) ? NNOT : NDNOT;
+ n2->nnot.com = n1;
+ return n2;
+ }
+ else
+#endif
+ return n1;
+}
+
+
+STATIC union node *
+simplecmd(union node **rpp, union node *redir)
+{
+ union node *args, **app;
+ union node *n = NULL;
+ int line = 0;
+ int savecheckkwd;
+#ifdef BOGUS_NOT_COMMAND
+ union node *n2;
+ int negate = 0;
+#endif
+
+ CTRACE(DBG_PARSE, ("simple command with%s redir already @%d\n",
+ redir ? "" : "out", plinno));
+
+ /* If we don't have any redirections already, then we must reset */
+ /* rpp to be the address of the local redir variable. */
+ if (redir == 0)
+ rpp = &redir;
+
+ args = NULL;
+ app = &args;
+
+#ifdef BOGUS_NOT_COMMAND /* pipelines get negated, commands do not */
+ while (readtoken() == TNOT) {
+ VTRACE(DBG_PARSE, ("simplcmd: bogus TNOT recognized\n"));
+ negate++;
+ }
+ tokpushback++;
+#endif
+
+ savecheckkwd = CHKALIAS;
+ for (;;) {
+ checkkwd = savecheckkwd;
+ if (readtoken() == TWORD) {
+ if (line == 0)
+ line = startlinno;
+ n = makeword(startlinno);
+ *app = n;
+ app = &n->narg.next;
+ if (savecheckkwd != 0 && !isassignment(wordtext))
+ savecheckkwd = 0;
+ } else if (lasttoken == TREDIR) {
+ if (line == 0)
+ line = startlinno;
+ *rpp = n = redirnode;
+ rpp = &n->nfile.next;
+ parsefname(); /* read name of redirection file */
+ } else if (lasttoken == TLP && app == &args->narg.next
+ && redir == 0) {
+ /* We have a function */
+ consumetoken(TRP);
+ funclinno = plinno;
+ rmescapes(n->narg.text);
+ if (strchr(n->narg.text, '/'))
+ synerror("Bad function name");
+ VTRACE(DBG_PARSE, ("Function '%s' seen @%d\n",
+ n->narg.text, plinno));
+ n->type = NDEFUN;
+ n->narg.lineno = plinno - elided_nl;
+ n->narg.next = command();
+ funclinno = 0;
+ goto checkneg;
+ } else {
+ tokpushback++;
+ break;
+ }
+ }
+
+ if (args == NULL && redir == NULL)
+ synexpect(-1, 0);
+ *app = NULL;
+ *rpp = NULL;
+ n = stalloc(sizeof(struct ncmd));
+ n->type = NCMD;
+ n->ncmd.lineno = line - elided_nl;
+ n->ncmd.backgnd = 0;
+ n->ncmd.args = args;
+ n->ncmd.redirect = redir;
+ n->ncmd.lineno = startlinno;
+
+ checkneg:
+#ifdef BOGUS_NOT_COMMAND
+ if (negate) {
+ VTRACE(DBG_PARSE, ("bogus %snegate simplecmd\n",
+ (negate&1) ? "" : "double "));
+ n2 = stalloc(sizeof(struct nnot));
+ n2->type = (negate & 1) ? NNOT : NDNOT;
+ n2->nnot.com = n;
+ return n2;
+ }
+ else
+#endif
+ return n;
+}
+
+STATIC union node *
+makeword(int lno)
+{
+ union node *n;
+
+ n = stalloc(sizeof(struct narg));
+ n->type = NARG;
+ n->narg.next = NULL;
+ n->narg.text = wordtext;
+ n->narg.backquote = backquotelist;
+ n->narg.lineno = lno;
+ return n;
+}
+
+void
+fixredir(union node *n, const char *text, int err)
+{
+
+ VTRACE(DBG_PARSE, ("Fix redir %s %d\n", text, err));
+ if (!err)
+ n->ndup.vname = NULL;
+
+ if (is_number(text))
+ n->ndup.dupfd = number(text);
+ else if (text[0] == '-' && text[1] == '\0')
+ n->ndup.dupfd = -1;
+ else {
+
+ if (err)
+ synerror("Bad fd number");
+ else
+ n->ndup.vname = makeword(startlinno - elided_nl);
+ }
+}
+
+
+STATIC void
+parsefname(void)
+{
+ union node *n = redirnode;
+
+ if (readtoken() != TWORD)
+ synexpect(-1, 0);
+ if (n->type == NHERE) {
+ struct HereDoc *here = heredoc;
+ struct HereDoc *p;
+
+ if (quoteflag == 0)
+ n->type = NXHERE;
+ VTRACE(DBG_PARSE, ("Here document %d @%d\n", n->type, plinno));
+ if (here->striptabs) {
+ while (*wordtext == '\t')
+ wordtext++;
+ }
+
+ /*
+ * this test is not really necessary, we are not
+ * required to expand wordtext, but there's no reason
+ * it cannot be $$ or something like that - that would
+ * not mean the pid, but literally two '$' characters.
+ * There is no need for limits on what the word can be.
+ * However, it needs to stay literal as entered, not
+ * have $ converted to CTLVAR or something, which as
+ * the parser is, at the minute, is impossible to prevent.
+ * So, leave it like this until the rest of the parser is fixed.
+ */
+ if (!noexpand(wordtext))
+ synerror("Illegal eof marker for << redirection");
+
+ rmescapes(wordtext);
+ here->eofmark = wordtext;
+ here->next = NULL;
+ if (heredoclist == NULL)
+ heredoclist = here;
+ else {
+ for (p = heredoclist ; p->next ; p = p->next)
+ continue;
+ p->next = here;
+ }
+ } else if (n->type == NTOFD || n->type == NFROMFD) {
+ fixredir(n, wordtext, 0);
+ } else {
+ n->nfile.fname = makeword(startlinno - elided_nl);
+ }
+}
+
+/*
+ * Check to see whether we are at the end of the here document. When this
+ * is called, c is set to the first character of the next input line. If
+ * we are at the end of the here document, this routine sets the c to PEOF.
+ * The new value of c is returned.
+ */
+
+static int
+checkend(int c, char * const eofmark, const int striptabs)
+{
+
+ if (striptabs) {
+ while (c == '\t')
+ c = pgetc();
+ }
+ if (c == PEOF) {
+ if (*eofmark == '\0')
+ return (c);
+ synerror(EOFhere);
+ }
+ if (c == *eofmark) {
+ int c2;
+ char *q;
+
+ for (q = eofmark + 1; c2 = pgetc(), *q != '\0' && c2 == *q; q++)
+ if (c2 == '\n') {
+ plinno++;
+ needprompt = doprompt;
+ }
+ if ((c2 == PEOF || c2 == '\n') && *q == '\0') {
+ c = PEOF;
+ if (c2 == '\n') {
+ plinno++;
+ needprompt = doprompt;
+ }
+ } else {
+ pungetc();
+ pushstring(eofmark + 1, q - (eofmark + 1), NULL);
+ }
+ } else if (c == '\n' && *eofmark == '\0') {
+ c = PEOF;
+ plinno++;
+ needprompt = doprompt;
+ }
+ return (c);
+}
+
+
+/*
+ * Input any here documents.
+ */
+
+STATIC int
+slurp_heredoc(char *const eofmark, const int striptabs, const int sq)
+{
+ int c;
+ char *out;
+ int lines = plinno;
+
+ c = pgetc();
+
+ /*
+ * If we hit EOF on the input, and the eofmark is a null string ('')
+ * we consider this empty line to be the eofmark, and exit without err.
+ */
+ if (c == PEOF && *eofmark != '\0')
+ synerror(EOFhere);
+
+ STARTSTACKSTR(out);
+
+ while ((c = checkend(c, eofmark, striptabs)) != PEOF) {
+ do {
+ if (sq) {
+ /*
+ * in single quoted mode (eofmark quoted)
+ * all we look for is \n so we can check
+ * for the epfmark - everything saved literally.
+ */
+ STPUTC(c, out);
+ if (c == '\n') {
+ plinno++;
+ break;
+ }
+ continue;
+ }
+ /*
+ * In double quoted (non-quoted eofmark)
+ * we must handle \ followed by \n here
+ * otherwise we can mismatch the end mark.
+ * All other uses of \ will be handled later
+ * when the here doc is expanded.
+ *
+ * This also makes sure \\ followed by \n does
+ * not suppress the newline (the \ quotes itself)
+ */
+ if (c == '\\') { /* A backslash */
+ STPUTC(c, out);
+ c = pgetc(); /* followed by */
+ if (c == '\n') { /* a newline? */
+ STPUTC(c, out);
+ plinno++;
+ continue; /* don't break */
+ }
+ }
+ STPUTC(c, out); /* keep the char */
+ if (c == '\n') { /* at end of line */
+ plinno++;
+ break; /* look for eofmark */
+ }
+ } while ((c = pgetc()) != PEOF);
+
+ /*
+ * If we have read a line, and reached EOF, without
+ * finding the eofmark, whether the EOF comes before
+ * or immediately after the \n, that is an error.
+ */
+ if (c == PEOF || (c = pgetc()) == PEOF)
+ synerror(EOFhere);
+ }
+ STPUTC('\0', out);
+
+ c = out - stackblock();
+ out = stackblock();
+ grabstackblock(c);
+ wordtext = out;
+
+ VTRACE(DBG_PARSE,
+ ("Slurped a %d line %sheredoc (to '%s')%s: len %d, \"%.*s%s\" @%d\n",
+ plinno - lines, sq ? "quoted " : "", eofmark,
+ striptabs ? " tab stripped" : "", c, (c > 16 ? 16 : c),
+ wordtext, (c > 16 ? "..." : ""), plinno));
+
+ return (plinno - lines);
+}
+
+static char *
+insert_elided_nl(char *str)
+{
+ while (elided_nl > 0) {
+ STPUTC(CTLNONL, str);
+ elided_nl--;
+ }
+ return str;
+}
+
+STATIC void
+readheredocs(void)
+{
+ struct HereDoc *here;
+ union node *n;
+ int line, l;
+
+ line = 0; /*XXX - gcc! obviously unneeded */
+ if (heredoclist)
+ line = heredoclist->startline + 1;
+ l = 0;
+ while (heredoclist) {
+ line += l;
+ here = heredoclist;
+ heredoclist = here->next;
+ if (needprompt) {
+ setprompt(2);
+ needprompt = 0;
+ }
+
+ l = slurp_heredoc(here->eofmark, here->striptabs,
+ here->here->nhere.type == NHERE);
+
+ here->here->nhere.doc = n = makeword(line);
+
+ if (here->here->nhere.type == NHERE)
+ continue;
+
+ /*
+ * Now "parse" here docs that have unquoted eofmarkers.
+ */
+ setinputstring(wordtext, 1, line);
+ VTRACE(DBG_PARSE, ("Reprocessing %d line here doc from %d\n",
+ l, line));
+ readtoken1(pgetc(), DQSYNTAX, 1);
+ n->narg.text = wordtext;
+ n->narg.backquote = backquotelist;
+ popfile();
+ }
+}
+
+STATIC int
+peektoken(void)
+{
+ int t;
+
+ t = readtoken();
+ tokpushback++;
+ return (t);
+}
+
+STATIC int
+readtoken(void)
+{
+ int t;
+#ifdef DEBUG
+ int alreadyseen = tokpushback;
+ int savecheckkwd = checkkwd;
+#endif
+ struct alias *ap;
+
+ top:
+ t = xxreadtoken();
+
+ if (checkkwd & CHKNL) {
+ while (t == TNL) {
+ readheredocs();
+ t = xxreadtoken();
+ }
+ }
+
+ /*
+ * check for keywords and aliases
+ */
+ if (t == TWORD && !quoteflag) {
+ const char *const *pp;
+
+ if (checkkwd & CHKKWD)
+ for (pp = parsekwd; *pp; pp++) {
+ if (**pp == *wordtext && equal(*pp, wordtext)) {
+ lasttoken = t = pp -
+ parsekwd + KWDOFFSET;
+ VTRACE(DBG_PARSE,
+ ("keyword %s recognized @%d\n",
+ tokname[t], plinno));
+ goto out;
+ }
+ }
+
+ if (checkkwd & CHKALIAS &&
+ (ap = lookupalias(wordtext, 1)) != NULL) {
+ VTRACE(DBG_PARSE,
+ ("alias '%s' recognized -> <:%s:>\n",
+ wordtext, ap->val));
+ pushstring(ap->val, strlen(ap->val), ap);
+ goto top;
+ }
+ }
+ out:
+ if (t != TNOT)
+ checkkwd = 0;
+
+ VTRACE(DBG_PARSE, ("%stoken %s %s @%d (chkkwd %x->%x)\n",
+ alreadyseen ? "reread " : "", tokname[t],
+ t == TWORD ? wordtext : "", plinno, savecheckkwd, checkkwd));
+ return (t);
+}
+
+
+/*
+ * Read the next input token.
+ * If the token is a word, we set backquotelist to the list of cmds in
+ * backquotes. We set quoteflag to true if any part of the word was
+ * quoted.
+ * If the token is TREDIR, then we set redirnode to a structure containing
+ * the redirection.
+ * In all cases, the variable startlinno is set to the number of the line
+ * on which the token starts.
+ *
+ * [Change comment: here documents and internal procedures]
+ * [Readtoken shouldn't have any arguments. Perhaps we should make the
+ * word parsing code into a separate routine. In this case, readtoken
+ * doesn't need to have any internal procedures, but parseword does.
+ * We could also make parseoperator in essence the main routine, and
+ * have parseword (readtoken1?) handle both words and redirection.]
+ */
+
+#define RETURN(token) return lasttoken = (token)
+
+STATIC int
+xxreadtoken(void)
+{
+ int c;
+
+ if (tokpushback) {
+ tokpushback = 0;
+ CTRACE(DBG_LEXER,
+ ("xxreadtoken() returns %s (%d) again\n",
+ tokname[lasttoken], lasttoken));
+ return lasttoken;
+ }
+ if (needprompt) {
+ setprompt(2);
+ needprompt = 0;
+ }
+ elided_nl = 0;
+ startlinno = plinno;
+ for (;;) { /* until token or start of word found */
+ c = pgetc_macro();
+ CTRACE(DBG_LEXER, ("xxreadtoken() sees '%c' (%#.2x) ",
+ c&0xFF, c&0x1FF));
+ switch (c) {
+ case ' ': case '\t': case PFAKE:
+ CTRACE(DBG_LEXER, (" ignored\n"));
+ continue;
+ case '#':
+ while ((c = pgetc()) != '\n' && c != PEOF)
+ continue;
+ CTRACE(DBG_LEXER,
+ ("skipped comment to (not incl) \\n\n"));
+ pungetc();
+ continue;
+
+ case '\n':
+ plinno++;
+ CTRACE(DBG_LEXER, ("newline now @%d\n", plinno));
+ needprompt = doprompt;
+ RETURN(TNL);
+ case PEOF:
+ CTRACE(DBG_LEXER, ("EOF -> TEOF (return)\n"));
+ RETURN(TEOF);
+
+ case '&':
+ if (pgetc_linecont() == '&') {
+ CTRACE(DBG_LEXER,
+ ("and another -> TAND (return)\n"));
+ RETURN(TAND);
+ }
+ pungetc();
+ CTRACE(DBG_LEXER, (" -> TBACKGND (return)\n"));
+ RETURN(TBACKGND);
+ case '|':
+ if (pgetc_linecont() == '|') {
+ CTRACE(DBG_LEXER,
+ ("and another -> TOR (return)\n"));
+ RETURN(TOR);
+ }
+ pungetc();
+ CTRACE(DBG_LEXER, (" -> TPIPE (return)\n"));
+ RETURN(TPIPE);
+ case ';':
+ switch (pgetc_linecont()) {
+ case ';':
+ CTRACE(DBG_LEXER,
+ ("and another -> TENDCASE (return)\n"));
+ RETURN(TENDCASE);
+ case '&':
+ CTRACE(DBG_LEXER,
+ ("and '&' -> TCASEFALL (return)\n"));
+ RETURN(TCASEFALL);
+ default:
+ pungetc();
+ CTRACE(DBG_LEXER, (" -> TSEMI (return)\n"));
+ RETURN(TSEMI);
+ }
+ case '(':
+ CTRACE(DBG_LEXER, (" -> TLP (return)\n"));
+ RETURN(TLP);
+ case ')':
+ CTRACE(DBG_LEXER, (" -> TRP (return)\n"));
+ RETURN(TRP);
+
+ case '\\':
+ switch (pgetc()) {
+ case '\n':
+ startlinno = ++plinno;
+ CTRACE(DBG_LEXER, ("\\\n ignored, now @%d\n",
+ plinno));
+ if (doprompt)
+ setprompt(2);
+ else
+ setprompt(0);
+ continue;
+ case PEOF:
+ CTRACE(DBG_LEXER,
+ ("then EOF -> TEOF (return) '\\' dropped\n"));
+ RETURN(TEOF);
+ default:
+ CTRACE(DBG_LEXER, ("not \\\n or EOF: "));
+ pungetc();
+ break;
+ }
+ /* FALLTHROUGH */
+ default:
+ CTRACE(DBG_LEXER, ("getting a word\n"));
+ return readtoken1(c, BASESYNTAX, 0);
+ }
+ }
+#undef RETURN
+}
+
+
+
+/*
+ * If eofmark is NULL, read a word or a redirection symbol. If eofmark
+ * is not NULL, read a here document. In the latter case, eofmark is the
+ * word which marks the end of the document and striptabs is true if
+ * leading tabs should be stripped from the document. The argument firstc
+ * is the first character of the input token or document.
+ *
+ * Because C does not have internal subroutines, I have simulated them
+ * using goto's to implement the subroutine linkage. The following macros
+ * will run code that appears at the end of readtoken1.
+ */
+
+/*
+ * We used to remember only the current syntax, variable nesting level,
+ * double quote state for each var nesting level, and arith nesting
+ * level (unrelated to var nesting) and one prev syntax when in arith
+ * syntax. This worked for simple cases, but can't handle arith inside
+ * var expansion inside arith inside var with some quoted and some not.
+ *
+ * Inspired by FreeBSD's implementation (though it was the obvious way)
+ * though implemented differently, we now have a stack that keeps track
+ * of what we are doing now, and what we were doing previously.
+ * Every time something changes, which will eventually end and should
+ * revert to the previous state, we push this stack, and then pop it
+ * again later (that is every ${} with an operator (to parse the word
+ * or pattern that follows) ${x} and $x are too simple to need it)
+ * $(( )) $( ) and "...". Always. Really, always!
+ *
+ * The stack is implemented as one static (on the C stack) base block
+ * containing LEVELS_PER_BLOCK (8) stack entries, which should be
+ * enough for the vast majority of cases. For torture tests, we
+ * malloc more blocks as needed. All accesses through the inline
+ * functions below.
+ */
+
+/*
+ * varnest & arinest will typically be 0 or 1
+ * (varnest can increment in usages like ${x=${y}} but probably
+ * does not really need to)
+ * parenlevel allows balancing parens inside a $(( )), it is reset
+ * at each new nesting level ( $(( ( x + 3 ${unset-)} )) does not work.
+ * quoted is special - we need to know 2 things ... are we inside "..."
+ * (even if inherited from some previous nesting level) and was there
+ * an opening '"' at this level (so the next will be closing).
+ * "..." can span nesting levels, but cannot be opened in one and
+ * closed in a different one.
+ * To handle this, "quoted" has two fields, the bottom 4 (really 2)
+ * bits are 0, 1, or 2, for un, single, and double quoted (single quoted
+ * is really so special that this setting is not very important)
+ * and 0x10 that indicates that an opening quote has been seen.
+ * The bottom 4 bits are inherited, the 0x10 bit is not.
+ */
+struct tokenstate {
+ const char *ts_syntax;
+ unsigned short ts_parenlevel; /* counters */
+ unsigned short ts_varnest; /* 64000 levels should be enough! */
+ unsigned short ts_arinest;
+ unsigned short ts_quoted; /* 1 -> single, 2 -> double */
+ unsigned short ts_magicq; /* heredoc or word expand */
+};
+
+#define NQ 0x00 /* Unquoted */
+#define SQ 0x01 /* Single Quotes */
+#define DQ 0x02 /* Double Quotes (or equivalent) */
+#define CQ 0x03 /* C style Single Quotes */
+#define QF 0x0F /* Mask to extract previous values */
+#define QS 0x10 /* Quoting started at this level in stack */
+
+#define LEVELS_PER_BLOCK 8
+#define VSS struct statestack
+
+struct statestack {
+ VSS *prev; /* previous block in list */
+ int cur; /* which of our tokenstates is current */
+ struct tokenstate tokenstate[LEVELS_PER_BLOCK];
+};
+
+static inline struct tokenstate *
+currentstate(VSS *stack)
+{
+ return &stack->tokenstate[stack->cur];
+}
+
+#ifdef notdef
+static inline struct tokenstate *
+prevstate(VSS *stack)
+{
+ if (stack->cur != 0)
+ return &stack->tokenstate[stack->cur - 1];
+ if (stack->prev == NULL) /* cannot drop below base */
+ return &stack->tokenstate[0];
+ return &stack->prev->tokenstate[LEVELS_PER_BLOCK - 1];
+}
+#endif
+
+static inline VSS *
+bump_state_level(VSS *stack)
+{
+ struct tokenstate *os, *ts;
+
+ os = currentstate(stack);
+
+ if (++stack->cur >= LEVELS_PER_BLOCK) {
+ VSS *ss;
+
+ ss = (VSS *)ckmalloc(sizeof (struct statestack));
+ ss->cur = 0;
+ ss->prev = stack;
+ stack = ss;
+ }
+
+ ts = currentstate(stack);
+
+ ts->ts_parenlevel = 0; /* parens inside never match outside */
+
+ ts->ts_quoted = os->ts_quoted & QF; /* these are default settings */
+ ts->ts_varnest = os->ts_varnest;
+ ts->ts_arinest = os->ts_arinest; /* when appropriate */
+ ts->ts_syntax = os->ts_syntax; /* they will be altered */
+ ts->ts_magicq = os->ts_magicq;
+
+ return stack;
+}
+
+static inline VSS *
+drop_state_level(VSS *stack)
+{
+ if (stack->cur == 0) {
+ VSS *ss;
+
+ ss = stack;
+ stack = ss->prev;
+ if (stack == NULL)
+ return ss;
+ ckfree(ss);
+ }
+ --stack->cur;
+ return stack;
+}
+
+static inline void
+cleanup_state_stack(VSS *stack)
+{
+ while (stack->prev != NULL) {
+ stack->cur = 0;
+ stack = drop_state_level(stack);
+ }
+}
+
+#define PARSESUB() {goto parsesub; parsesub_return:;}
+#define PARSEARITH() {goto parsearith; parsearith_return:;}
+
+/*
+ * The following macros all assume the existance of a local var "stack"
+ * which contains a pointer to the current struct stackstate
+ */
+
+/*
+ * These are macros rather than inline funcs to avoid code churn as much
+ * as possible - they replace macros of the same name used previously.
+ */
+#define ISDBLQUOTE() (currentstate(stack)->ts_quoted & QS)
+#define SETDBLQUOTE() (currentstate(stack)->ts_quoted = QS | DQ)
+#ifdef notdef
+#define CLRDBLQUOTE() (currentstate(stack)->ts_quoted = \
+ stack->cur != 0 || stack->prev ? \
+ prevstate(stack)->ts_quoted & QF : 0)
+#endif
+
+/*
+ * This set are just to avoid excess typing and line lengths...
+ * The ones that "look like" var names must be implemented to be lvalues
+ */
+#define syntax (currentstate(stack)->ts_syntax)
+#define parenlevel (currentstate(stack)->ts_parenlevel)
+#define varnest (currentstate(stack)->ts_varnest)
+#define arinest (currentstate(stack)->ts_arinest)
+#define quoted (currentstate(stack)->ts_quoted)
+#define magicq (currentstate(stack)->ts_magicq)
+#define TS_PUSH() (stack = bump_state_level(stack))
+#define TS_POP() (stack = drop_state_level(stack))
+
+/*
+ * Called to parse command substitutions. oldstyle is true if the command
+ * is enclosed inside `` (otherwise it was enclosed in "$( )")
+ *
+ * Internally nlpp is a pointer to the head of the linked
+ * list of commands (passed by reference), and savelen is the number of
+ * characters on the top of the stack which must be preserved.
+ */
+static char *
+parsebackq(VSS *const stack, char * const in,
+ struct nodelist **const pbqlist, const int oldstyle)
+{
+ struct nodelist **nlpp;
+ const int savepbq = parsebackquote;
+ union node *n;
+ char *out;
+ char *str = NULL;
+ char *volatile sstr = str;
+ struct jmploc jmploc;
+ struct jmploc *const savehandler = handler;
+ struct parsefile *const savetopfile = getcurrentfile();
+ const int savelen = in - stackblock();
+ int saveprompt;
+ int lno;
+
+ if (setjmp(jmploc.loc)) {
+ popfilesupto(savetopfile);
+ if (sstr)
+ ckfree(__UNVOLATILE(sstr));
+ cleanup_state_stack(stack);
+ parsebackquote = 0;
+ handler = savehandler;
+ CTRACE(DBG_LEXER, ("parsebackq() err (%d), unwinding\n",
+ exception));
+ longjmp(handler->loc, 1);
+ }
+ INTOFF;
+ sstr = str = NULL;
+ if (savelen > 0) {
+ sstr = str = ckmalloc(savelen);
+ memcpy(str, stackblock(), savelen);
+ }
+ handler = &jmploc;
+ INTON;
+ if (oldstyle) {
+ /*
+ * We must read until the closing backquote, giving special
+ * treatment to some slashes, and then push the string and
+ * reread it as input, interpreting it normally.
+ */
+ int pc;
+ int psavelen;
+ char *pstr;
+ int line1 = plinno;
+
+ VTRACE(DBG_PARSE|DBG_LEXER,
+ ("parsebackq: repackaging `` as $( )"));
+ /*
+ * Because the entire `...` is read here, we don't
+ * need to bother the state stack. That will be used
+ * (as appropriate) when the processed string is re-read.
+ */
+ STARTSTACKSTR(out);
+#ifdef DEBUG
+ for (psavelen = 0;;psavelen++) { /* } */
+#else
+ for (;;) {
+#endif
+ if (needprompt) {
+ setprompt(2);
+ needprompt = 0;
+ }
+ pc = pgetc();
+ VTRACE(DBG_LEXER,
+ ("parsebackq() got '%c'(%#.2x) in `` %s", pc&0xFF,
+ pc&0x1FF, pc == '`' ? "terminator\n" : ""));
+ if (pc == '`')
+ break;
+ switch (pc) {
+ case '\\':
+ pc = pgetc();
+ VTRACE(DBG_LEXER, ("then '%c'(%#.2x) ",
+ pc&0xFF, pc&0x1FF));
+#ifdef DEBUG
+ psavelen++;
+#endif
+ if (pc == '\n') { /* keep \ \n for later */
+ plinno++;
+ VTRACE(DBG_LEXER, ("@%d ", plinno));
+ needprompt = doprompt;
+ }
+ if (pc != '\\' && pc != '`' && pc != '$'
+ && (!ISDBLQUOTE() || pc != '"')) {
+ VTRACE(DBG_LEXER, ("keep '\\' "));
+ STPUTC('\\', out);
+ }
+ break;
+
+ case '\n':
+ plinno++;
+ VTRACE(DBG_LEXER, ("@%d ", plinno));
+ needprompt = doprompt;
+ break;
+
+ case PEOF:
+ startlinno = line1;
+ VTRACE(DBG_LEXER, ("EOF\n", plinno));
+ synerror("EOF in backquote substitution");
+ break;
+
+ default:
+ break;
+ }
+ VTRACE(DBG_LEXER, (".\n", plinno));
+ STPUTC(pc, out);
+ }
+ STPUTC('\0', out);
+ VTRACE(DBG_LEXER, ("parsebackq() ``:"));
+ VTRACE(DBG_PARSE|DBG_LEXER, (" read %d", psavelen));
+ psavelen = out - stackblock();
+ VTRACE(DBG_PARSE|DBG_LEXER, (" produced %d\n", psavelen));
+ if (psavelen > 0) {
+ pstr = grabstackstr(out);
+ CTRACE(DBG_LEXER,
+ ("parsebackq() reprocessing as $(%s)\n", pstr));
+ setinputstring(pstr, 1, line1);
+ }
+ }
+ nlpp = pbqlist;
+ while (*nlpp)
+ nlpp = &(*nlpp)->next;
+ *nlpp = stalloc(sizeof(struct nodelist));
+ (*nlpp)->next = NULL;
+ parsebackquote = oldstyle;
+
+ if (oldstyle) {
+ saveprompt = doprompt;
+ doprompt = 0;
+ } else
+ saveprompt = 0;
+
+ lno = -plinno;
+ CTRACE(DBG_LEXER, ("parsebackq() parsing embedded command list\n"));
+ n = list(0);
+ CTRACE(DBG_LEXER, ("parsebackq() parsed $() (%d -> %d)\n", -lno,
+ lno + plinno));
+ lno += plinno;
+
+ if (oldstyle) {
+ if (peektoken() != TEOF)
+ synexpect(-1, 0);
+ doprompt = saveprompt;
+ } else
+ consumetoken(TRP);
+
+ (*nlpp)->n = n;
+ if (oldstyle) {
+ /*
+ * Start reading from old file again, ignoring any pushed back
+ * tokens left from the backquote parsing
+ */
+ CTRACE(DBG_LEXER, ("parsebackq() back to previous input\n"));
+ popfile();
+ tokpushback = 0;
+ }
+
+ while (stackblocksize() <= savelen)
+ growstackblock();
+ STARTSTACKSTR(out);
+ if (str) {
+ memcpy(out, str, savelen);
+ STADJUST(savelen, out);
+ INTOFF;
+ ckfree(str);
+ sstr = str = NULL;
+ INTON;
+ }
+ parsebackquote = savepbq;
+ handler = savehandler;
+ if (arinest || ISDBLQUOTE()) {
+ STPUTC(CTLBACKQ | CTLQUOTE, out);
+ while (--lno >= 0)
+ STPUTC(CTLNONL, out);
+ } else
+ STPUTC(CTLBACKQ, out);
+
+ return out;
+}
+
+/*
+ * Parse a redirection operator. The parameter "out" points to a string
+ * specifying the fd to be redirected. It is guaranteed to be either ""
+ * or a numeric string (for now anyway). The parameter "c" contains the
+ * first character of the redirection operator.
+ *
+ * Note the string "out" is on the stack, which we are about to clobber,
+ * so process it first...
+ */
+
+static void
+parseredir(const char *out, int c)
+{
+ union node *np;
+ int fd;
+
+ fd = (*out == '\0') ? -1 : number(out);
+
+ np = stalloc(sizeof(struct nfile));
+ VTRACE(DBG_LEXER, ("parseredir after '%s%c' ", out, c));
+ if (c == '>') {
+ if (fd < 0)
+ fd = 1;
+ c = pgetc_linecont();
+ VTRACE(DBG_LEXER, ("is '%c'(%#.2x) ", c&0xFF, c&0x1FF));
+ if (c == '>')
+ np->type = NAPPEND;
+ else if (c == '|')
+ np->type = NCLOBBER;
+ else if (c == '&')
+ np->type = NTOFD;
+ else {
+ np->type = NTO;
+ VTRACE(DBG_LEXER, ("unwanted ", c));
+ pungetc();
+ }
+ } else { /* c == '<' */
+ if (fd < 0)
+ fd = 0;
+ c = pgetc_linecont();
+ VTRACE(DBG_LEXER, ("is '%c'(%#.2x) ", c&0xFF, c&0x1FF));
+ switch (c) {
+ case '<':
+ /* if sizes differ, just discard the old one */
+ if (sizeof (struct nfile) != sizeof (struct nhere))
+ np = stalloc(sizeof(struct nhere));
+ np->type = NHERE;
+ np->nhere.fd = 0;
+ heredoc = stalloc(sizeof(struct HereDoc));
+ heredoc->here = np;
+ heredoc->startline = plinno;
+ if ((c = pgetc_linecont()) == '-') {
+ CTRACE(DBG_LEXER, ("and '%c'(%#.2x) ",
+ c & 0xFF, c & 0x1FF));
+ heredoc->striptabs = 1;
+ } else {
+ heredoc->striptabs = 0;
+ pungetc();
+ }
+ break;
+
+ case '&':
+ np->type = NFROMFD;
+ break;
+
+ case '>':
+ np->type = NFROMTO;
+ break;
+
+ default:
+ np->type = NFROM;
+ VTRACE(DBG_LEXER, ("unwanted('%c'0#.2x)", c&0xFF,
+ c&0x1FF));
+ pungetc();
+ break;
+ }
+ }
+ np->nfile.fd = fd;
+
+ VTRACE(DBG_LEXER, (" ->%"PRIdsNT" fd=%d\n", NODETYPENAME(np->type),fd));
+
+ redirnode = np; /* this is the "value" of TRENODE */
+}
+
+/*
+ * Called to parse a backslash escape sequence inside $'...'.
+ * The backslash has already been read.
+ */
+static char *
+readcstyleesc(char *out)
+{
+ int c, vc, i, n;
+ unsigned int v;
+
+ c = pgetc();
+ VTRACE(DBG_LEXER, ("CSTR(\\%c)(\\%#x)", c&0xFF, c&0x1FF));
+ switch (c) {
+ case '\0':
+ case PEOF:
+ synerror("Unterminated quoted string");
+ case '\n':
+ plinno++;
+ VTRACE(DBG_LEXER, ("@%d ", plinno));
+ if (doprompt)
+ setprompt(2);
+ else
+ setprompt(0);
+ return out;
+
+ case '\\':
+ case '\'':
+ case '"':
+ v = c;
+ break;
+
+ case 'a': v = '\a'; break;
+ case 'b': v = '\b'; break;
+ case 'e': v = '\033'; break;
+ case 'f': v = '\f'; break;
+ case 'n': v = '\n'; break;
+ case 'r': v = '\r'; break;
+ case 't': v = '\t'; break;
+ case 'v': v = '\v'; break;
+
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ v = c - '0';
+ c = pgetc();
+ if (c >= '0' && c <= '7') {
+ v <<= 3;
+ v += c - '0';
+ c = pgetc();
+ if (c >= '0' && c <= '7') {
+ v <<= 3;
+ v += c - '0';
+ } else
+ pungetc();
+ } else
+ pungetc();
+ break;
+
+ case 'c':
+ c = pgetc();
+ if (c < 0x3f || c > 0x7a || c == 0x60)
+ synerror("Bad \\c escape sequence");
+ if (c == '\\' && pgetc() != '\\')
+ synerror("Bad \\c\\ escape sequence");
+ if (c == '?')
+ v = 127;
+ else
+ v = c & 0x1f;
+ break;
+
+ case 'x':
+ n = 2;
+ goto hexval;
+ case 'u':
+ n = 4;
+ goto hexval;
+ case 'U':
+ n = 8;
+ hexval:
+ v = 0;
+ for (i = 0; i < n; i++) {
+ c = pgetc();
+ if (c >= '0' && c <= '9')
+ v = (v << 4) + c - '0';
+ else if (c >= 'A' && c <= 'F')
+ v = (v << 4) + c - 'A' + 10;
+ else if (c >= 'a' && c <= 'f')
+ v = (v << 4) + c - 'a' + 10;
+ else {
+ pungetc();
+ break;
+ }
+ }
+ if (n > 2 && v > 127) {
+ if (v >= 0xd800 && v <= 0xdfff)
+ synerror("Invalid \\u escape sequence");
+
+ /* XXX should we use iconv here. What locale? */
+ CHECKSTRSPACE(4, out);
+
+ if (v <= 0x7ff) {
+ USTPUTC(0xc0 | v >> 6, out);
+ USTPUTC(0x80 | (v & 0x3f), out);
+ return out;
+ } else if (v <= 0xffff) {
+ USTPUTC(0xe0 | v >> 12, out);
+ USTPUTC(0x80 | ((v >> 6) & 0x3f), out);
+ USTPUTC(0x80 | (v & 0x3f), out);
+ return out;
+ } else if (v <= 0x10ffff) {
+ USTPUTC(0xf0 | v >> 18, out);
+ USTPUTC(0x80 | ((v >> 12) & 0x3f), out);
+ USTPUTC(0x80 | ((v >> 6) & 0x3f), out);
+ USTPUTC(0x80 | (v & 0x3f), out);
+ return out;
+ }
+ if (v > 127)
+ v = '?';
+ }
+ break;
+ default:
+ synerror("Unknown $'' escape sequence");
+ }
+ vc = (char)v;
+ VTRACE(DBG_LEXER, ("->%u(%#x)['%c']", v, v, vc&0xFF));
+
+ /*
+ * If we managed to create a \n from a \ sequence (no matter how)
+ * then we replace it with the magic CRTCNL control char, which
+ * will turn into a \n again later, but in the meantime, never
+ * causes LINENO increments.
+ */
+ if (vc == '\n') {
+ VTRACE(DBG_LEXER, ("CTLCNL."));
+ USTPUTC(CTLCNL, out);
+ return out;
+ }
+
+ /*
+ * We can't handle NUL bytes.
+ * POSIX says we should skip till the closing quote.
+ */
+ if (vc == '\0') {
+ CTRACE(DBG_LEXER, ("\\0: skip to '", v, v, vc&0xFF));
+ while ((c = pgetc()) != '\'') {
+ if (c == '\\')
+ c = pgetc();
+ if (c == PEOF)
+ synerror("Unterminated quoted string");
+ if (c == '\n') {
+ plinno++;
+ if (doprompt)
+ setprompt(2);
+ else
+ setprompt(0);
+ }
+ }
+ pungetc();
+ return out;
+ }
+ CVTRACE(DBG_LEXER, NEEDESC(vc), ("CTLESC-"));
+ VTRACE(DBG_LEXER, ("'%c'(%#.2x)", vc&0xFF, vc&0x1FF));
+ if (NEEDESC(vc))
+ USTPUTC(CTLESC, out);
+ USTPUTC(vc, out);
+ return out;
+}
+
+/*
+ * The lowest level basic tokenizer.
+ *
+ * The next input byte (character) is in firstc, syn says which
+ * syntax tables we are to use (basic, single or double quoted, or arith)
+ * and magicq (used with sqsyntax and dqsyntax only) indicates that the
+ * quote character itself is not special (used parsing here docs and similar)
+ *
+ * The result is the type of the next token (its value, when there is one,
+ * is saved in the relevant global var - must fix that someday!) which is
+ * also saved for re-reading ("lasttoken").
+ *
+ * Overall, this routine does far more parsing than it is supposed to.
+ * That will also need fixing, someday...
+ */
+STATIC int
+readtoken1(int firstc, char const *syn, int oneword)
+{
+ int c;
+ char * out;
+ int len;
+ struct nodelist *bqlist;
+ int quotef;
+ VSS static_stack;
+ VSS *stack = &static_stack;
+
+ stack->prev = NULL;
+ stack->cur = 0;
+
+ syntax = syn;
+
+#ifdef DEBUG
+#define SYNTAX ( syntax == BASESYNTAX ? "BASE" : \
+ syntax == DQSYNTAX ? "DQ" : \
+ syntax == SQSYNTAX ? "SQ" : \
+ syntax == ARISYNTAX ? "ARI" : \
+ "???" )
+#endif
+
+ startlinno = plinno;
+ varnest = 0;
+ quoted = 0;
+ if (syntax == DQSYNTAX)
+ SETDBLQUOTE();
+ quotef = 0;
+ bqlist = NULL;
+ arinest = 0;
+ parenlevel = 0;
+ elided_nl = 0;
+ magicq = oneword;
+
+ CTRACE(DBG_LEXER, ("readtoken1(%c) syntax=%s %s%s(quoted=%x)\n",
+ firstc&0xFF, SYNTAX, magicq ? "magic quotes" : "",
+ ISDBLQUOTE()?" ISDBLQUOTE":"", quoted));
+
+ STARTSTACKSTR(out);
+
+ for (c = firstc ;; c = pgetc_macro()) { /* until of token */
+ if (syntax == ARISYNTAX)
+ out = insert_elided_nl(out);
+ CHECKSTRSPACE(6, out); /* permit 6 calls to USTPUTC */
+ switch (syntax[c]) {
+ case CFAKE:
+ VTRACE(DBG_LEXER, ("CFAKE"));
+ if (syntax == BASESYNTAX && varnest == 0)
+ break;
+ VTRACE(DBG_LEXER, (","));
+ continue;
+ case CNL: /* '\n' */
+ VTRACE(DBG_LEXER, ("CNL"));
+ if (syntax == BASESYNTAX && varnest == 0)
+ break; /* exit loop */
+ USTPUTC(c, out);
+ plinno++;
+ VTRACE(DBG_LEXER, ("@%d,", plinno));
+ if (doprompt)
+ setprompt(2);
+ else
+ setprompt(0);
+ continue;
+
+ case CSBACK: /* single quoted backslash */
+ if ((quoted & QF) == CQ) {
+ out = readcstyleesc(out);
+ continue;
+ }
+ VTRACE(DBG_LEXER, ("ESC:"));
+ USTPUTC(CTLESC, out);
+ /* FALLTHROUGH */
+ case CWORD:
+ VTRACE(DBG_LEXER, ("'%c'", c));
+ USTPUTC(c, out);
+ continue;
+
+ case CCTL:
+ CVTRACE(DBG_LEXER, !magicq || ISDBLQUOTE(),
+ ("%s%sESC:",!magicq?"!m":"",ISDBLQUOTE()?"DQ":""));
+ if (!magicq || ISDBLQUOTE())
+ USTPUTC(CTLESC, out);
+ VTRACE(DBG_LEXER, ("'%c'", c));
+ USTPUTC(c, out);
+ continue;
+ case CBACK: /* backslash */
+ c = pgetc();
+ VTRACE(DBG_LEXER, ("\\'%c'(%#.2x)", c&0xFF, c&0x1FF));
+ if (c == PEOF) {
+ VTRACE(DBG_LEXER, ("EOF, keep \\ "));
+ USTPUTC('\\', out);
+ pungetc();
+ continue;
+ }
+ if (c == '\n') {
+ plinno++;
+ elided_nl++;
+ VTRACE(DBG_LEXER, ("eli \\n (%d) @%d ",
+ elided_nl, plinno));
+ if (doprompt)
+ setprompt(2);
+ else
+ setprompt(0);
+ continue;
+ }
+ CVTRACE(DBG_LEXER, quotef==0, (" QF=1 "));
+ quotef = 1; /* current token is quoted */
+ if (quoted && c != '\\' && c != '`' &&
+ c != '$' && (c != '"' || magicq)) {
+ /*
+ * retain the \ (which we *know* needs CTLESC)
+ * when in "..." and the following char is
+ * not one of the magic few.)
+ * Otherwise the \ has done its work, and
+ * is dropped.
+ */
+ VTRACE(DBG_LEXER, ("ESC:'\\'"));
+ USTPUTC(CTLESC, out);
+ USTPUTC('\\', out);
+ }
+ CVTRACE(DBG_LEXER, NEEDESC(c) || !magicq,
+ ("%sESC:", NEEDESC(c) ? "+" : "m"));
+ VTRACE(DBG_LEXER, ("'%c'(%#.2x)", c&0xFF, c&0x1FF));
+ if (NEEDESC(c))
+ USTPUTC(CTLESC, out);
+ else if (!magicq) {
+ USTPUTC(CTLESC, out);
+ USTPUTC(c, out);
+ continue;
+ }
+ USTPUTC(c, out);
+ continue;
+ case CSQUOTE:
+ if (syntax != SQSYNTAX) {
+ CVTRACE(DBG_LEXER, !magicq, (" CQM "));
+ if (!magicq)
+ USTPUTC(CTLQUOTEMARK, out);
+ CVTRACE(DBG_LEXER, quotef==0, (" QF=1 "));
+ quotef = 1;
+ TS_PUSH();
+ syntax = SQSYNTAX;
+ quoted = SQ;
+ VTRACE(DBG_LEXER, (" TS_PUSH(SQ)"));
+ continue;
+ }
+ if (magicq && arinest == 0 && varnest == 0) {
+ /* Ignore inside quoted here document */
+ VTRACE(DBG_LEXER, ("<<'>>"));
+ USTPUTC(c, out);
+ continue;
+ }
+ /* End of single quotes... */
+ TS_POP();
+ VTRACE(DBG_LEXER, ("SQ TS_POP->%s ", SYNTAX));
+ CVTRACE(DBG_LEXER, syntax == BASESYNTAX, (" CQE "));
+ if (syntax == BASESYNTAX)
+ USTPUTC(CTLQUOTEEND, out);
+ continue;
+ case CDQUOTE:
+ if (magicq && arinest == 0 /* && varnest == 0 */) {
+ VTRACE(DBG_LEXER, ("<<\">>"));
+ /* Ignore inside here document */
+ USTPUTC(c, out);
+ continue;
+ }
+ CVTRACE(DBG_LEXER, quotef==0, (" QF=1 "));
+ quotef = 1;
+ if (arinest) {
+ if (ISDBLQUOTE()) {
+ VTRACE(DBG_LEXER,
+ (" CQE ari(%d", arinest));
+ USTPUTC(CTLQUOTEEND, out);
+ TS_POP();
+ VTRACE(DBG_LEXER, ("%d)TS_POP->%s ",
+ arinest, SYNTAX));
+ } else {
+ VTRACE(DBG_LEXER,
+ (" ari(%d) %s TS_PUSH->DQ CQM ",
+ arinest, SYNTAX));
+ TS_PUSH();
+ syntax = DQSYNTAX;
+ SETDBLQUOTE();
+ USTPUTC(CTLQUOTEMARK, out);
+ }
+ continue;
+ }
+ CVTRACE(DBG_LEXER, magicq, (" MQignDQ "));
+ if (magicq)
+ continue;
+ if (ISDBLQUOTE()) {
+ TS_POP();
+ VTRACE(DBG_LEXER,
+ (" DQ TS_POP->%s CQE ", SYNTAX));
+ USTPUTC(CTLQUOTEEND, out);
+ } else {
+ VTRACE(DBG_LEXER,
+ (" %s TS_POP->DQ CQM ", SYNTAX));
+ TS_PUSH();
+ syntax = DQSYNTAX;
+ SETDBLQUOTE();
+ USTPUTC(CTLQUOTEMARK, out);
+ }
+ continue;
+ case CVAR: /* '$' */
+ VTRACE(DBG_LEXER, ("'$'..."));
+ out = insert_elided_nl(out);
+ PARSESUB(); /* parse substitution */
+ continue;
+ case CENDVAR: /* CLOSEBRACE */
+ if (varnest > 0 && !ISDBLQUOTE()) {
+ VTRACE(DBG_LEXER, ("vn=%d !DQ", varnest));
+ TS_POP();
+ VTRACE(DBG_LEXER, (" TS_POP->%s CEV ", SYNTAX));
+ USTPUTC(CTLENDVAR, out);
+ } else {
+ VTRACE(DBG_LEXER, ("'%c'", c));
+ USTPUTC(c, out);
+ }
+ out = insert_elided_nl(out);
+ continue;
+ case CLP: /* '(' in arithmetic */
+ parenlevel++;
+ VTRACE(DBG_LEXER, ("'('(%d)", parenlevel));
+ USTPUTC(c, out);
+ continue;;
+ case CRP: /* ')' in arithmetic */
+ if (parenlevel > 0) {
+ USTPUTC(c, out);
+ --parenlevel;
+ VTRACE(DBG_LEXER, ("')'(%d)", parenlevel));
+ } else {
+ VTRACE(DBG_LEXER, ("')'(%d)", parenlevel));
+ if (pgetc_linecont() == /*(*/ ')') {
+ out = insert_elided_nl(out);
+ if (--arinest == 0) {
+ TS_POP();
+ USTPUTC(CTLENDARI, out);
+ } else
+ USTPUTC(/*(*/ ')', out);
+ } else {
+ break; /* to synerror() just below */
+#if 0 /* the old way, causes weird errors on bad input */
+ /*
+ * unbalanced parens
+ * (don't 2nd guess - no error)
+ */
+ pungetc();
+ USTPUTC(/*(*/ ')', out);
+#endif
+ }
+ }
+ continue;
+ case CBQUOTE: /* '`' */
+ VTRACE(DBG_LEXER, ("'`' -> parsebackq()\n"));
+ out = parsebackq(stack, out, &bqlist, 1);
+ VTRACE(DBG_LEXER, ("parsebackq() -> readtoken1: "));
+ continue;
+ case CEOF: /* --> c == PEOF */
+ VTRACE(DBG_LEXER, ("EOF "));
+ break; /* will exit loop */
+ default:
+ VTRACE(DBG_LEXER, ("['%c'(%#.2x)]", c&0xFF, c&0x1FF));
+ if (varnest == 0 && !ISDBLQUOTE())
+ break; /* exit loop */
+ USTPUTC(c, out);
+ VTRACE(DBG_LEXER, (","));
+ continue;
+ }
+ VTRACE(DBG_LEXER, (" END TOKEN\n", c&0xFF, c&0x1FF));
+ break; /* break from switch -> break from for loop too */
+ }
+
+ if (syntax == ARISYNTAX) {
+ cleanup_state_stack(stack);
+ synerror(/*((*/ "Missing '))'");
+ }
+ if (syntax != BASESYNTAX && /* ! parsebackquote && */ !magicq) {
+ cleanup_state_stack(stack);
+ synerror("Unterminated quoted string");
+ }
+ if (varnest != 0) {
+ cleanup_state_stack(stack);
+ startlinno = plinno;
+ /* { */
+ synerror("Missing '}'");
+ }
+
+ STPUTC('\0', out);
+ len = out - stackblock();
+ out = stackblock();
+
+ if (!magicq) {
+ if ((c == '<' || c == '>')
+ && quotef == 0 && (*out == '\0' || is_number(out))) {
+ parseredir(out, c);
+ cleanup_state_stack(stack);
+ return lasttoken = TREDIR;
+ } else {
+ pungetc();
+ }
+ }
+
+ VTRACE(DBG_PARSE|DBG_LEXER,
+ ("readtoken1 %sword \"%s\", completed%s (%d) left %d enl\n",
+ (quotef ? "quoted " : ""), out, (bqlist ? " with cmdsubs" : ""),
+ len, elided_nl));
+
+ quoteflag = quotef;
+ backquotelist = bqlist;
+ grabstackblock(len);
+ wordtext = out;
+ cleanup_state_stack(stack);
+ return lasttoken = TWORD;
+/* end of readtoken routine */
+
+
+/*
+ * Parse a substitution. At this point, we have read the dollar sign
+ * and nothing else.
+ */
+
+parsesub: {
+ int subtype;
+ int typeloc;
+ int flags;
+ char *p;
+ static const char types[] = "}-+?=";
+
+ c = pgetc_linecont();
+ VTRACE(DBG_LEXER, ("\"$%c\"(%#.2x)", c&0xFF, c&0x1FF));
+ if (c == '(' /*)*/) { /* $(command) or $((arith)) */
+ if (pgetc_linecont() == '(' /*')'*/ ) {
+ VTRACE(DBG_LEXER, ("\"$((\" ARITH "));
+ out = insert_elided_nl(out);
+ PARSEARITH();
+ } else {
+ VTRACE(DBG_LEXER, ("\"$(\" CSUB->parsebackq()\n"));
+ out = insert_elided_nl(out);
+ pungetc();
+ out = parsebackq(stack, out, &bqlist, 0);
+ VTRACE(DBG_LEXER, ("parseback()->readtoken1(): "));
+ }
+ } else if (c == OPENBRACE || is_name(c) || is_special(c)) {
+ VTRACE(DBG_LEXER, (" $EXP:CTLVAR "));
+ USTPUTC(CTLVAR, out);
+ typeloc = out - stackblock();
+ USTPUTC(VSNORMAL, out);
+ subtype = VSNORMAL;
+ flags = 0;
+ if (c == OPENBRACE) {
+ c = pgetc_linecont();
+ if (c == '#') {
+ if ((c = pgetc_linecont()) == CLOSEBRACE)
+ c = '#';
+ else if (is_name(c) || isdigit(c))
+ subtype = VSLENGTH;
+ else if (is_special(c)) {
+ /*
+ * ${#} is $# - the number of sh params
+ * ${##} is the length of ${#}
+ * ${###} is ${#} with as much nothing
+ * as possible removed from start
+ * ${##1} is ${#} with leading 1 gone
+ * ${##\#} is ${#} with leading # gone
+ *
+ * this stuff is UGLY!
+ */
+ if (pgetc_linecont() == CLOSEBRACE) {
+ pungetc();
+ subtype = VSLENGTH;
+ } else {
+ static char cbuf[2];
+
+ pungetc(); /* would like 2 */
+ cbuf[0] = c; /* so ... */
+ cbuf[1] = '\0';
+ pushstring(cbuf, 1, NULL);
+ c = '#'; /* ${#:...} */
+ subtype = 0; /* .. or similar */
+ }
+ } else {
+ pungetc();
+ c = '#';
+ subtype = 0;
+ }
+ }
+ else
+ subtype = 0;
+ VTRACE(DBG_LEXER, ("${ st=%d ", subtype));
+ }
+ if (is_name(c)) {
+ p = out;
+ do {
+ VTRACE(DBG_LEXER, ("%c", c));
+ STPUTC(c, out);
+ c = pgetc_linecont();
+ } while (is_in_name(c));
+
+#if 0
+ if (out - p == 6 && strncmp(p, "LINENO", 6) == 0) {
+ int i;
+ int linno;
+ char buf[10];
+
+ /*
+ * The "LINENO hack"
+ *
+ * Replace the variable name with the
+ * current line number.
+ */
+ linno = plinno;
+ if (funclinno != 0)
+ linno -= funclinno - 1;
+ snprintf(buf, sizeof(buf), "%d", linno);
+ STADJUST(-6, out);
+ for (i = 0; buf[i] != '\0'; i++)
+ STPUTC(buf[i], out);
+ flags |= VSLINENO;
+ }
+#endif
+ } else if (is_digit(c)) {
+ do {
+ VTRACE(DBG_LEXER, ("%c", c));
+ STPUTC(c, out);
+ c = pgetc_linecont();
+ } while (subtype != VSNORMAL && is_digit(c));
+ }
+ else if (is_special(c)) {
+ VTRACE(DBG_LEXER, ("\"$%c", c));
+ USTPUTC(c, out);
+ c = pgetc_linecont();
+ }
+ else {
+ VTRACE(DBG_LEXER, ("\"$%c(%#.2x)??\n", c&0xFF,c&0x1FF));
+ badsub:
+ cleanup_state_stack(stack);
+ synerror("Bad substitution");
+ }
+
+ STPUTC('=', out);
+ if (subtype == 0) {
+ switch (c) {
+ case ':':
+ flags |= VSNUL;
+ c = pgetc_linecont();
+ /*FALLTHROUGH*/
+ default:
+ p = strchr(types, c);
+ if (p == NULL)
+ goto badsub;
+ subtype = p - types + VSNORMAL;
+ break;
+ case '%':
+ case '#':
+ {
+ int cc = c;
+ subtype = c == '#' ? VSTRIMLEFT :
+ VSTRIMRIGHT;
+ c = pgetc_linecont();
+ if (c == cc)
+ subtype++;
+ else
+ pungetc();
+ break;
+ }
+ }
+ } else {
+ if (subtype == VSLENGTH && c != /*{*/ '}')
+ synerror("no modifiers allowed with ${#var}");
+ pungetc();
+ }
+ if (quoted || arinest)
+ flags |= VSQUOTE;
+ if (subtype >= VSTRIMLEFT && subtype <= VSTRIMRIGHTMAX)
+ flags |= VSPATQ;
+ VTRACE(DBG_LEXER, (" st%d:%x", subtype, flags));
+ *(stackblock() + typeloc) = subtype | flags;
+ if (subtype != VSNORMAL) {
+ TS_PUSH();
+ varnest++;
+ arinest = 0;
+ if (subtype > VSASSIGN) { /* # ## % %% */
+ syntax = BASESYNTAX;
+ quoted = 0;
+ magicq = 0;
+ }
+ VTRACE(DBG_LEXER, (" TS_PUSH->%s vn=%d%s ",
+ SYNTAX, varnest, quoted ? " Q" : ""));
+ }
+ } else if (c == '\'' && syntax == BASESYNTAX) {
+ USTPUTC(CTLQUOTEMARK, out);
+ VTRACE(DBG_LEXER, (" CSTR \"$'\" CQM "));
+ CVTRACE(DBG_LEXER, quotef==0, ("QF=1 "));
+ quotef = 1;
+ TS_PUSH();
+ syntax = SQSYNTAX;
+ quoted = CQ;
+ VTRACE(DBG_LEXER, ("%s->TS_PUSH()->SQ ", SYNTAX));
+ } else {
+ VTRACE(DBG_LEXER, ("$unk -> '$' (pushback '%c'%#.2x)",
+ c & 0xFF, c & 0x1FF));
+ USTPUTC('$', out);
+ pungetc();
+ }
+ goto parsesub_return;
+}
+
+
+/*
+ * Parse an arithmetic expansion (indicate start of one and set state)
+ */
+parsearith: {
+
+#if 0
+ if (syntax == ARISYNTAX) {
+ /*
+ * we collapse embedded arithmetic expansion to
+ * parentheses, which should be equivalent
+ *
+ * XXX It isn't, must fix, soonish...
+ */
+ USTPUTC('(' /*)*/, out);
+ USTPUTC('(' /*)*/, out);
+ /*
+ * Need 2 of them because there will (should be)
+ * two closing ))'s to follow later.
+ */
+ parenlevel += 2;
+ } else
+#endif
+ {
+ VTRACE(DBG_LEXER, (" CTLARI%c ", ISDBLQUOTE()?'"':'_'));
+ USTPUTC(CTLARI, out);
+ if (ISDBLQUOTE())
+ USTPUTC('"',out);
+ else
+ USTPUTC(' ',out);
+
+ VTRACE(DBG_LEXER, ("%s->TS_PUSH->ARI(1)", SYNTAX));
+ TS_PUSH();
+ syntax = ARISYNTAX;
+ arinest = 1;
+ varnest = 0;
+ magicq = 1;
+ }
+ goto parsearith_return;
+}
+
+} /* end of readtoken */
+
+
+
+
+#ifdef mkinit
+INCLUDE "parser.h"
+
+RESET {
+ psp.v_current_parser = &parse_state;
+
+ parse_state.ps_tokpushback = 0;
+ parse_state.ps_checkkwd = 0;
+ parse_state.ps_heredoclist = NULL;
+}
+#endif
+
+/*
+ * Returns true if the text contains nothing to expand (no dollar signs
+ * or backquotes).
+ */
+
+STATIC int
+noexpand(char *text)
+{
+ char *p;
+ char c;
+
+ p = text;
+ while ((c = *p++) != '\0') {
+ if (c == CTLQUOTEMARK || c == CTLQUOTEEND)
+ continue;
+ if (c == CTLESC)
+ p++;
+ else if (BASESYNTAX[(int)c] == CCTL)
+ return 0;
+ }
+ return 1;
+}
+
+
+/*
+ * Return true if the argument is a legal variable name (a letter or
+ * underscore followed by zero or more letters, underscores, and digits).
+ */
+
+int
+goodname(const char *name)
+{
+ const char *p;
+
+ p = name;
+ if (! is_name(*p))
+ return 0;
+ while (*++p) {
+ if (! is_in_name(*p))
+ return 0;
+ }
+ return 1;
+}
+
+int
+isassignment(const char *p)
+{
+ if (!is_name(*p))
+ return 0;
+ while (*++p != '=')
+ if (*p == '\0' || !is_in_name(*p))
+ return 0;
+ return 1;
+}
+
+/*
+ * skip past any \n's, and leave lasttoken set to whatever follows
+ */
+STATIC void
+linebreak(void)
+{
+ while (readtoken() == TNL)
+ ;
+}
+
+/*
+ * The next token must be "token" -- check, then move past it
+ */
+STATIC void
+consumetoken(int token)
+{
+ if (readtoken() != token) {
+ VTRACE(DBG_PARSE, ("consumetoken(%d): expecting %s got %s",
+ token, tokname[token], tokname[lasttoken]));
+ CVTRACE(DBG_PARSE, (lasttoken==TWORD), (" \"%s\"", wordtext));
+ VTRACE(DBG_PARSE, ("\n"));
+ synexpect(token, NULL);
+ }
+}
+
+/*
+ * Called when an unexpected token is read during the parse. The argument
+ * is the token that is expected, or -1 if more than one type of token can
+ * occur at this point.
+ */
+
+STATIC void
+synexpect(int token, const char *text)
+{
+ char msg[64];
+ char *p;
+
+ if (lasttoken == TWORD) {
+ size_t len = strlen(wordtext);
+
+ if (len <= 13)
+ fmtstr(msg, 34, "Word \"%.13s\" unexpected", wordtext);
+ else
+ fmtstr(msg, 34,
+ "Word \"%.10s...\" unexpected", wordtext);
+ } else
+ fmtstr(msg, 34, "%s unexpected", tokname[lasttoken]);
+
+ p = strchr(msg, '\0');
+ if (text)
+ fmtstr(p, 30, " (expecting \"%.10s\")", text);
+ else if (token >= 0)
+ fmtstr(p, 30, " (expecting %s)", tokname[token]);
+
+ synerror(msg);
+ /* NOTREACHED */
+}
+
+
+STATIC void
+synerror(const char *msg)
+{
+ error("%d: Syntax error: %s", startlinno, msg);
+ /* NOTREACHED */
+}
+
+STATIC void
+setprompt(int which)
+{
+ whichprompt = which;
+
+#ifndef SMALL
+ if (!el)
+#endif
+ out2str(getprompt(NULL));
+}
+
+/*
+ * handle getting the next character, while ignoring \ \n
+ * (which is a little tricky as we only have one char of pushback
+ * and we need that one elsewhere).
+ */
+STATIC int
+pgetc_linecont(void)
+{
+ int c;
+
+ while ((c = pgetc()) == '\\') {
+ c = pgetc();
+ if (c == '\n') {
+ plinno++;
+ elided_nl++;
+ VTRACE(DBG_LEXER, ("\"\\n\"drop(el=%d@%d)",
+ elided_nl, plinno));
+ if (doprompt)
+ setprompt(2);
+ else
+ setprompt(0);
+ } else {
+ pungetc();
+ /* Allow the backslash to be pushed back. */
+ pushstring("\\", 1, NULL);
+ return (pgetc());
+ }
+ }
+ return (c);
+}
+
+/*
+ * called by editline -- any expansions to the prompt
+ * should be added here.
+ */
+const char *
+getprompt(void *unused)
+{
+ char *p;
+ const char *cp;
+ int wp;
+
+ if (!doprompt)
+ return "";
+
+ VTRACE(DBG_PARSE|DBG_EXPAND, ("getprompt %d\n", whichprompt));
+
+ switch (wp = whichprompt) {
+ case 0:
+ return "";
+ case 1:
+ p = ps1val();
+ break;
+ case 2:
+ p = ps2val();
+ break;
+ default:
+ return "<internal prompt error>";
+ }
+ if (p == NULL)
+ return "";
+
+ VTRACE(DBG_PARSE|DBG_EXPAND, ("prompt <<%s>>\n", p));
+
+ cp = expandstr(p, plinno);
+ whichprompt = wp; /* history depends on it not changing */
+
+ VTRACE(DBG_PARSE|DBG_EXPAND, ("prompt -> <<%s>>\n", cp));
+
+ return cp;
+}
+
+/*
+ * Expand a string ... used for expanding prompts (PS1...)
+ *
+ * Never return NULL, always some string (return input string if invalid)
+ *
+ * The internal routine does the work, leaving the result on the
+ * stack (or in a static string, or even the input string) and
+ * handles parser recursion, and cleanup after an error while parsing.
+ *
+ * The visible interface copies the result off the stack (if it is there),
+ * and handles stack management, leaving the stack in the exact same
+ * state it was when expandstr() was called (so it can be used part way
+ * through building a stack data structure - as in when PS2 is being
+ * expanded half way through reading a "command line")
+ *
+ * on error, expandonstack() cleans up the parser state, but then
+ * simply jumps out through expandstr() withut doing any stack cleanup,
+ * which is OK, as the error handler must deal with that anyway.
+ *
+ * The split into two funcs is to avoid problems with setjmp/longjmp
+ * and local variables which could otherwise be optimised into bizarre
+ * behaviour.
+ */
+static const char *
+expandonstack(char *ps, int cmdsub, int lineno)
+{
+ union node n;
+ struct jmploc jmploc;
+ struct jmploc *const savehandler = handler;
+ struct parsefile *const savetopfile = getcurrentfile();
+ const int save_x = xflag;
+ struct parse_state new_state = init_parse_state;
+ struct parse_state *const saveparser = psp.v_current_parser;
+ const char *result = NULL;
+
+ if (!setjmp(jmploc.loc)) {
+ handler = &jmploc;
+
+ psp.v_current_parser = &new_state;
+ setinputstring(ps, 1, lineno);
+
+ readtoken1(pgetc(), DQSYNTAX, 1);
+ if (backquotelist != NULL) {
+ if (!cmdsub)
+ result = ps;
+ else if (!promptcmds)
+ result = "-o promptcmds not set: ";
+ }
+ if (result == NULL) {
+ n.narg.type = NARG;
+ n.narg.next = NULL;
+ n.narg.text = wordtext;
+ n.narg.lineno = lineno;
+ n.narg.backquote = backquotelist;
+
+ xflag = 0; /* we might be expanding PS4 ... */
+ expandarg(&n, NULL, 0);
+ result = stackblock();
+ }
+ } else {
+ psp.v_current_parser = saveparser;
+ xflag = save_x;
+ popfilesupto(savetopfile);
+ handler = savehandler;
+
+ if (exception == EXEXIT)
+ longjmp(handler->loc, 1);
+ if (exception == EXINT)
+ exraise(SIGINT);
+ return ps;
+ }
+ psp.v_current_parser = saveparser;
+ xflag = save_x;
+ popfilesupto(savetopfile);
+ handler = savehandler;
+
+
+ if (result == NULL)
+ result = ps;
+
+ return result;
+}
+
+const char *
+expandstr(char *ps, int lineno)
+{
+ const char *result = NULL;
+ struct stackmark smark;
+ static char *buffer = NULL; /* storage for prompt, never freed */
+ static size_t bufferlen = 0;
+
+ setstackmark(&smark);
+ /*
+ * At this point we anticipate that there may be a string
+ * growing on the stack, but we have no idea how big it is.
+ * However we know that it cannot be bigger than the current
+ * allocated stack block, so simply reserve the whole thing,
+ * then we can use the stack without barfing all over what
+ * is there already... (the stack mark undoes this later.)
+ */
+ (void) stalloc(stackblocksize());
+
+ result = expandonstack(ps, 1, lineno);
+
+ if (__predict_true(result == stackblock())) {
+ size_t len = strlen(result) + 1;
+
+ /*
+ * the result (usual case) is on the stack, which we
+ * are just about to discard (popstackmark()) so we
+ * need to move it somewhere safe first.
+ */
+
+ if (__predict_false(len > bufferlen)) {
+ char *new;
+ size_t newlen = bufferlen;
+
+ if (__predict_false(len > (SIZE_MAX >> 4))) {
+ result = "huge prompt: ";
+ goto getout;
+ }
+
+ if (newlen == 0)
+ newlen = 32;
+ while (newlen <= len)
+ newlen <<= 1;
+
+ new = (char *)realloc(buffer, newlen);
+
+ if (__predict_false(new == NULL)) {
+ /*
+ * this should rarely (if ever) happen
+ * but we must do something when it does...
+ */
+ result = "No mem for prompt: ";
+ goto getout;
+ } else {
+ buffer = new;
+ bufferlen = newlen;
+ }
+ }
+ (void)memcpy(buffer, result, len);
+ result = buffer;
+ }
+
+ getout:;
+ popstackmark(&smark);
+
+ return result;
+}
+
+/*
+ * and a simpler version, which does no $( ) expansions, for
+ * use during shell startup when we know we are not parsing,
+ * and so the stack is not in use - we can do what we like,
+ * and do not need to clean up (that's handled externally).
+ *
+ * Simply return the result, even if it is on the stack
+ */
+const char *
+expandenv(char *arg)
+{
+ return expandonstack(arg, 0, 0);
+}
generated by cgit v1.2.3-60-g2f50 (git 2.42.0) at 2024-06-28 22:02:33 +0000