WebSVN – HelenOS – Diff – /branches/shell/uspace/app/ash/parser.c


/*  $NetBSD: parser.c,v 1.45 2000/07/27 04:09:27 cgd 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *  This product includes software developed by the University of
 *  California, Berkeley and its contributors.
 * 4. 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.45 2000/07/27 04:09:27 cgd Exp $");
#endif
#endif /* not lint */
 
#include <stdlib.h>
 
#include "shell.h"
#include "parser.h"
#include "nodes.h"
#include "expand.h" /* defines rmescapes() */
#include "redir.h"  /* defines copyfd() */
#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
 
/*
 * Shell command parser.
 */
 
#define EOFMARKLEN 79
 
/* values returned by readtoken */
#include "token.h"
 
 
 
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 */
};
 
 
 
struct heredoc *heredoclist;    /* list of here documents to read */
int parsebackquote;     /* nonzero if we are inside backquotes */
int doprompt;           /* if set, prompt the user */
int needprompt;         /* true if interactive and at start of line */
int lasttoken;          /* last token read */
MKINIT int tokpushback;     /* last token pushed back */
char *wordtext;         /* text of last word returned by readtoken */
MKINIT int checkkwd;            /* 1 == check for kwds, 2 == also eat newlines */
struct nodelist *backquotelist;
union node *redirnode;
struct heredoc *heredoc;
int quoteflag;          /* set if (part of) last token was quoted */
int startlinno;         /* line # where last token started */
 
 
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 *makename (void);
STATIC void parsefname (void);
STATIC void parseheredoc (void);
STATIC int peektoken (void);
STATIC int readtoken (void);
STATIC int xxreadtoken (void);
STATIC int readtoken1 (int, char const *, char *, int);
STATIC int noexpand (char *);
STATIC void synexpect (int) __attribute__((noreturn));
STATIC void synerror (const char *) __attribute__((noreturn));
STATIC void setprompt (int);
 
 
/*
 * 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;
 
    doprompt = interact;
    if (doprompt)
        setprompt(1);
    else
        setprompt(0);
    needprompt = 0;
    t = readtoken();
    if (t == TEOF)
        return NEOF;
    if (t == TNL)
        return NULL;
    tokpushback++;
    return list(1);
}
 
 
STATIC union node *
list(nlflag)
    int nlflag;
{
    union node *n1, *n2, *n3;
    int tok;
 
    checkkwd = 2;
    if (nlflag == 0 && tokendlist[peektoken()])
        return NULL;
    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 = (union node *)stalloc(sizeof (struct nredir));
                n3->type = NBACKGND;
                n3->nredir.n = n2;
                n3->nredir.redirect = NULL;
                n2 = n3;
            }
        }
        if (n1 == NULL) {
            n1 = n2;
        }
        else {
            n3 = (union node *)stalloc(sizeof (struct nbinary));
            n3->type = NSEMI;
            n3->nbinary.ch1 = n1;
            n3->nbinary.ch2 = n2;
            n1 = n3;
        }
        switch (tok) {
        case TBACKGND:
        case TSEMI:
            tok = readtoken();
            /* fall through */
        case TNL:
            if (tok == TNL) {
                parseheredoc();
                if (nlflag)
                    return n1;
            } else {
                tokpushback++;
            }
            checkkwd = 2;
            if (tokendlist[peektoken()])
                return n1;
            break;
        case TEOF:
            if (heredoclist)
                parseheredoc();
            else
                pungetc();      /* push back EOF on input */
            return n1;
        default:
            if (nlflag)
                synexpect(-1);
            tokpushback++;
            return n1;
        }
    }
}
 
 
 
STATIC union node *
andor() {
    union node *n1, *n2, *n3;
    int t;
 
    checkkwd = 1;
    n1 = pipeline();
    for (;;) {
        if ((t = readtoken()) == TAND) {
            t = NAND;
        } else if (t == TOR) {
            t = NOR;
        } else {
            tokpushback++;
            return n1;
        }
        checkkwd = 2;
        n2 = pipeline();
        n3 = (union node *)stalloc(sizeof (struct nbinary));
        n3->type = t;
        n3->nbinary.ch1 = n1;
        n3->nbinary.ch2 = n2;
        n1 = n3;
    }
}
 
 
 
STATIC union node *
pipeline() {
    union node *n1, *n2, *pipenode;
    struct nodelist *lp, *prev;
    int negate;
 
    negate = 0;
    TRACE(("pipeline: entered\n"));
    if (readtoken() == TNOT) {
        negate = !negate;
        checkkwd = 1;
    } else
        tokpushback++;
    n1 = command();
    if (readtoken() == TPIPE) {
        pipenode = (union node *)stalloc(sizeof (struct npipe));
        pipenode->type = NPIPE;
        pipenode->npipe.backgnd = 0;
        lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
        pipenode->npipe.cmdlist = lp;
        lp->n = n1;
        do {
            prev = lp;
            lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
            checkkwd = 2;
            lp->n = command();
            prev->next = lp;
        } while (readtoken() == TPIPE);
        lp->next = NULL;
        n1 = pipenode;
    }
    tokpushback++;
    if (negate) {
        n2 = (union node *)stalloc(sizeof (struct nnot));
        n2->type = NNOT;
        n2->nnot.com = n1;
        return n2;
    } else
        return n1;
}
 
 
 
STATIC union node *
command() {
    union node *n1, *n2;
    union node *ap, **app;
    union node *cp, **cpp;
    union node *redir, **rpp;
    int t;
 
    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++;
 
    switch (readtoken()) {
    case TIF:
        n1 = (union node *)stalloc(sizeof (struct nif));
        n1->type = NIF;
        n1->nif.test = list(0);
        if (readtoken() != TTHEN)
            synexpect(TTHEN);
        n1->nif.ifpart = list(0);
        n2 = n1;
        while (readtoken() == TELIF) {
            n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
            n2 = n2->nif.elsepart;
            n2->type = NIF;
            n2->nif.test = list(0);
            if (readtoken() != TTHEN)
                synexpect(TTHEN);
            n2->nif.ifpart = list(0);
        }
        if (lasttoken == TELSE)
            n2->nif.elsepart = list(0);
        else {
            n2->nif.elsepart = NULL;
            tokpushback++;
        }
        if (readtoken() != TFI)
            synexpect(TFI);
        checkkwd = 1;
        break;
    case TWHILE:
    case TUNTIL: {
        int got;
        n1 = (union node *)stalloc(sizeof (struct nbinary));
        n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
        n1->nbinary.ch1 = list(0);
        if ((got=readtoken()) != TDO) {
TRACE(("expecting DO got %s %s\n", tokname[got], got == TWORD ? wordtext : ""));
            synexpect(TDO);
        }
        n1->nbinary.ch2 = list(0);
        if (readtoken() != TDONE)
            synexpect(TDONE);
        checkkwd = 1;
        break;
    }
    case TFOR:
        if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
            synerror("Bad for loop variable");
        n1 = (union node *)stalloc(sizeof (struct nfor));
        n1->type = NFOR;
        n1->nfor.var = wordtext;
        if (readtoken() == TWORD && ! quoteflag && equal(wordtext, "in")) {
            app = &ap;
            while (readtoken() == TWORD) {
                n2 = (union node *)stalloc(sizeof (struct narg));
                n2->type = NARG;
                n2->narg.text = wordtext;
                n2->narg.backquote = backquotelist;
                *app = n2;
                app = &n2->narg.next;
            }
            *app = NULL;
            n1->nfor.args = ap;
            if (lasttoken != TNL && lasttoken != TSEMI)
                synexpect(-1);
        } else {
            static char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE,
                                   '@', '=', '\0'};
            n2 = (union node *)stalloc(sizeof (struct narg));
            n2->type = NARG;
            n2->narg.text = argvars;
            n2->narg.backquote = NULL;
            n2->narg.next = NULL;
            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 = 2;
        if ((t = readtoken()) == TDO)
            t = TDONE;
        else if (t == TBEGIN)
            t = TEND;
        else
            synexpect(-1);
        n1->nfor.body = list(0);
        if (readtoken() != t)
            synexpect(t);
        checkkwd = 1;
        break;
    case TCASE:
        n1 = (union node *)stalloc(sizeof (struct ncase));
        n1->type = NCASE;
        if (readtoken() != TWORD)
            synexpect(TWORD);
        n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
        n2->type = NARG;
        n2->narg.text = wordtext;
        n2->narg.backquote = backquotelist;
        n2->narg.next = NULL;
        while (readtoken() == TNL);
        if (lasttoken != TWORD || ! equal(wordtext, "in"))
            synerror("expecting \"in\"");
        cpp = &n1->ncase.cases;
        checkkwd = 2, readtoken();
        do {
            if (lasttoken == TLP)
                readtoken();
            *cpp = cp = (union node *)stalloc(sizeof (struct nclist));
            cp->type = NCLIST;
            app = &cp->nclist.pattern;
            for (;;) {
                *app = ap = (union node *)stalloc(sizeof (struct narg));
                ap->type = NARG;
                ap->narg.text = wordtext;
                ap->narg.backquote = backquotelist;
                if (checkkwd = 2, readtoken() != TPIPE)
                    break;
                app = &ap->narg.next;
                readtoken();
            }
            ap->narg.next = NULL;
            if (lasttoken != TRP)
                synexpect(TRP);
            cp->nclist.body = list(0);
 
            checkkwd = 2;
            if ((t = readtoken()) != TESAC) {
                if (t != TENDCASE)
                    synexpect(TENDCASE);
                else
                    checkkwd = 2, readtoken();
            }
            cpp = &cp->nclist.next;
        } while(lasttoken != TESAC);
        *cpp = NULL;
        checkkwd = 1;
        break;
    case TLP:
        n1 = (union node *)stalloc(sizeof (struct nredir));
        n1->type = NSUBSHELL;
        n1->nredir.n = list(0);
        n1->nredir.redirect = NULL;
        if (readtoken() != TRP)
            synexpect(TRP);
        checkkwd = 1;
        break;
    case TBEGIN:
        n1 = list(0);
        if (readtoken() != TEND)
            synexpect(TEND);
        checkkwd = 1;
        break;
    /* Handle an empty command like other simple commands.  */
    case TSEMI:
    case TAND:
    case TOR:
    case TNL:
    case TEOF:
    case TRP:
    case TBACKGND:
        /*
         * An empty command before a ; doesn't make much sense, and
         * should certainly be disallowed in the case of `if ;'.
         */
        if (!redir)
            synexpect(-1);
    case TWORD:
        tokpushback++;
        n1 = simplecmd(rpp, redir);
        return n1;
    default:
        synexpect(-1);
        /* 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->type != NSUBSHELL) {
            n2 = (union node *)stalloc(sizeof (struct nredir));
            n2->type = NREDIR;
            n2->nredir.n = n1;
            n1 = n2;
        }
        n1->nredir.redirect = redir;
    }
 
    return n1;
}
 
 
STATIC union node *
simplecmd(rpp, redir)
    union node **rpp, *redir;
    {
    union node *args, **app;
    union node **orig_rpp = rpp;
    union node *n = NULL;
 
    /* 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;
    /*
     * We save the incoming value, because we need this for shell
     * functions.  There can not be a redirect or an argument between
     * the function name and the open parenthesis.
     */
    orig_rpp = rpp;
 
    for (;;) {
        if (readtoken() == TWORD) {
            n = (union node *)stalloc(sizeof (struct narg));
            n->type = NARG;
            n->narg.text = wordtext;
            n->narg.backquote = backquotelist;
            *app = n;
            app = &n->narg.next;
        } else if (lasttoken == TREDIR) {
            *rpp = n = redirnode;
            rpp = &n->nfile.next;
            parsefname();   /* read name of redirection file */
        } else if (lasttoken == TLP && app == &args->narg.next
                        && rpp == orig_rpp) {
            /* We have a function */
            if (readtoken() != TRP)
                synexpect(TRP);
#ifdef notdef
            if (! goodname(n->narg.text))
                synerror("Bad function name");
#endif
            n->type = NDEFUN;
            checkkwd = 2;
            n->narg.next = command();
            return n;
        } else {
            tokpushback++;
            break;
        }
    }
    *app = NULL;
    *rpp = NULL;
    n = (union node *)stalloc(sizeof (struct ncmd));
    n->type = NCMD;
    n->ncmd.backgnd = 0;
    n->ncmd.args = args;
    n->ncmd.redirect = redir;
    return n;
}
 
STATIC union node *
makename() {
    union node *n;
 
    n = (union node *)stalloc(sizeof (struct narg));
    n->type = NARG;
    n->narg.next = NULL;
    n->narg.text = wordtext;
    n->narg.backquote = backquotelist;
    return n;
}
 
void fixredir(union node *n, const char *text, int err)
    {
    TRACE(("Fix redir %s %d\n", text, err));
    if (!err)
        n->ndup.vname = NULL;
 
    if (is_digit(text[0]) && text[1] == '\0')
        n->ndup.dupfd = digit_val(text[0]);
    else if (text[0] == '-' && text[1] == '\0')
        n->ndup.dupfd = -1;
    else {
 
        if (err)
            synerror("Bad fd number");
        else
            n->ndup.vname = makename();
    }
}
 
 
STATIC void
parsefname() {
    union node *n = redirnode;
 
    if (readtoken() != TWORD)
        synexpect(-1);
    if (n->type == NHERE) {
        struct heredoc *here = heredoc;
        struct heredoc *p;
        int i;
 
        if (quoteflag == 0)
            n->type = NXHERE;
        TRACE(("Here document %d\n", n->type));
        if (here->striptabs) {
            while (*wordtext == '\t')
                wordtext++;
        }
        if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
            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);
            p->next = here;
        }
    } else if (n->type == NTOFD || n->type == NFROMFD) {
        fixredir(n, wordtext, 0);
    } else {
        n->nfile.fname = makename();
    }
}
 
 
/*
 * Input any here documents.
 */
 
STATIC void
parseheredoc() {
    struct heredoc *here;
    union node *n;
 
    while (heredoclist) {
        here = heredoclist;
        heredoclist = here->next;
        if (needprompt) {
            setprompt(2);
            needprompt = 0;
        }
        readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
                here->eofmark, here->striptabs);
        n = (union node *)stalloc(sizeof (struct narg));
        n->narg.type = NARG;
        n->narg.next = NULL;
        n->narg.text = wordtext;
        n->narg.backquote = backquotelist;
        here->here->nhere.doc = n;
    }
}
 
STATIC int
peektoken() {
    int t;
 
    t = readtoken();
    tokpushback++;
    return (t);
}
 
STATIC int
readtoken() {
    int t;
    int savecheckkwd = checkkwd;
    struct alias *ap;
#ifdef DEBUG
    int alreadyseen = tokpushback;
#endif
 
    top:
    t = xxreadtoken();
 
    if (checkkwd) {
        /*
         * eat newlines
         */
        if (checkkwd == 2) {
            checkkwd = 0;
            while (t == TNL) {
                parseheredoc();
                t = xxreadtoken();
            }
        } else
            checkkwd = 0;
        /*
         * check for keywords and aliases
         */
        if (t == TWORD && !quoteflag)
        {
            const char *const *pp;
 
            for (pp = parsekwd; *pp; pp++) {
                if (**pp == *wordtext && equal(*pp, wordtext))
                {
                    lasttoken = t = pp -
                        parsekwd + KWDOFFSET;
                    TRACE(("keyword %s recognized\n", tokname[t]));
                    goto out;
                }
            }
            if ((ap = lookupalias(wordtext, 1)) != NULL) {
                pushstring(ap->val, strlen(ap->val), ap);
                checkkwd = savecheckkwd;
                goto top;
            }
        }
out:
        checkkwd = 0;
    }
#ifdef DEBUG
    if (!alreadyseen)
        TRACE(("token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
    else
        TRACE(("reread token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
#endif
    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() {
    int c;
 
    if (tokpushback) {
        tokpushback = 0;
        return lasttoken;
    }
    if (needprompt) {
        setprompt(2);
        needprompt = 0;
    }
    startlinno = plinno;
    for (;;) {  /* until token or start of word found */
        c = pgetc_macro();
        if (c == ' ' || c == '\t')
            continue;       /* quick check for white space first */
        switch (c) {
        case ' ': case '\t':
            continue;
        case '#':
            while ((c = pgetc()) != '\n' && c != PEOF);
            pungetc();
            continue;
        case '\\':
            if (pgetc() == '\n') {
                startlinno = ++plinno;
                if (doprompt)
                    setprompt(2);
                else
                    setprompt(0);
                continue;
            }
            pungetc();
            goto breakloop;
        case '\n':
            plinno++;
            needprompt = doprompt;
            RETURN(TNL);
        case PEOF:
            RETURN(TEOF);
        case '&':
            if (pgetc() == '&')
                RETURN(TAND);
            pungetc();
            RETURN(TBACKGND);
        case '|':
            if (pgetc() == '|')
                RETURN(TOR);
            pungetc();
            RETURN(TPIPE);
        case ';':
            if (pgetc() == ';')
                RETURN(TENDCASE);
            pungetc();
            RETURN(TSEMI);
        case '(':
            RETURN(TLP);
        case ')':
            RETURN(TRP);
        default:
            goto breakloop;
        }
    }
breakloop:
    return readtoken1(c, BASESYNTAX, (char *)NULL, 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.
 */
 
#define CHECKEND()  {goto checkend; checkend_return:;}
#define PARSEREDIR()    {goto parseredir; parseredir_return:;}
#define PARSESUB()  {goto parsesub; parsesub_return:;}
#define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
#define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
#define PARSEARITH()    {goto parsearith; parsearith_return:;}
 
STATIC int
readtoken1(firstc, syntax, eofmark, striptabs)
    int firstc;
    char const *syntax;
    char *eofmark;
    int striptabs;
    {
    int c = firstc;
    char *out;
    int len;
    char line[EOFMARKLEN + 1];
    struct nodelist *bqlist;
    int quotef;
    int dblquote;
    int varnest;    /* levels of variables expansion */
    int arinest;    /* levels of arithmetic expansion */
    int parenlevel; /* levels of parens in arithmetic */
    int dqvarnest;  /* levels of variables expansion within double quotes */
    int oldstyle;
    char const *prevsyntax; /* syntax before arithmetic */
#if __GNUC__
    /* Avoid longjmp clobbering */
    (void) &out;
    (void) &quotef;
    (void) &dblquote;
    (void) &varnest;
    (void) &arinest;
    (void) &parenlevel;
    (void) &dqvarnest;
    (void) &oldstyle;
    (void) &prevsyntax;
    (void) &syntax;
#endif
 
    startlinno = plinno;
    dblquote = 0;
    if (syntax == DQSYNTAX)
        dblquote = 1;
    quotef = 0;
    bqlist = NULL;
    varnest = 0;
    arinest = 0;
    parenlevel = 0;
    dqvarnest = 0;
 
    STARTSTACKSTR(out);
    loop: { /* for each line, until end of word */
#if ATTY
        if (c == '\034' && doprompt
         && attyset() && ! equal(termval(), "emacs")) {
            attyline();
            if (syntax == BASESYNTAX)
                return readtoken();
            c = pgetc();
            goto loop;
        }
#endif
        CHECKEND(); /* set c to PEOF if at end of here document */
        for (;;) {  /* until end of line or end of word */
            CHECKSTRSPACE(3, out);  /* permit 3 calls to USTPUTC */
            switch(syntax[c]) {
            case CNL:   /* '\n' */
                if (syntax == BASESYNTAX)
                    goto endword;   /* exit outer loop */
                USTPUTC(c, out);
                plinno++;
                if (doprompt)
                    setprompt(2);
                else
                    setprompt(0);
                c = pgetc();
                goto loop;      /* continue outer loop */
            case CWORD:
                USTPUTC(c, out);
                break;
            case CCTL:
                if ((eofmark == NULL || dblquote) &&
                    dqvarnest == 0)
                    USTPUTC(CTLESC, out);
                USTPUTC(c, out);
                break;
            case CBACK: /* backslash */
                c = pgetc();
                if (c == PEOF) {
                    USTPUTC('\\', out);
                    pungetc();
                } else if (c == '\n') {
                    if (doprompt)
                        setprompt(2);
                    else
                        setprompt(0);
                } else {
                    if (dblquote && c != '\\' && c != '`' && c != '$'
                             && (c != '"' || eofmark != NULL))
                        USTPUTC('\\', out);
                    if (SQSYNTAX[c] == CCTL)
                        USTPUTC(CTLESC, out);
                    else if (eofmark == NULL)
                        USTPUTC(CTLQUOTEMARK, out);
                    USTPUTC(c, out);
                    quotef++;
                }
                break;
            case CSQUOTE:
                if (eofmark == NULL)
                    USTPUTC(CTLQUOTEMARK, out);
                syntax = SQSYNTAX;
                break;
            case CDQUOTE:
                if (eofmark == NULL)
                    USTPUTC(CTLQUOTEMARK, out);
                syntax = DQSYNTAX;
                dblquote = 1;
                break;
            case CENDQUOTE:
                if (eofmark != NULL && arinest == 0 &&
                    varnest == 0) {
                    USTPUTC(c, out);
                } else {
                    if (arinest) {
                        syntax = ARISYNTAX;
                        dblquote = 0;
                    } else if (eofmark == NULL &&
                           dqvarnest == 0) {
                        syntax = BASESYNTAX;
                        dblquote = 0;
                    }
                    quotef++;
                }
                break;
            case CVAR:  /* '$' */
                PARSESUB();     /* parse substitution */
                break;
            case CENDVAR:   /* '}' */
                if (varnest > 0) {
                    varnest--;
                    if (dqvarnest > 0) {
                        dqvarnest--;
                    }
                    USTPUTC(CTLENDVAR, out);
                } else {
                    USTPUTC(c, out);
                }
                break;
            case CLP:   /* '(' in arithmetic */
                parenlevel++;
                USTPUTC(c, out);
                break;
            case CRP:   /* ')' in arithmetic */
                if (parenlevel > 0) {
                    USTPUTC(c, out);
                    --parenlevel;
                } else {
                    if (pgetc() == ')') {
                        if (--arinest == 0) {
                            USTPUTC(CTLENDARI, out);
                            syntax = prevsyntax;
                            if (syntax == DQSYNTAX)
                                dblquote = 1;
                            else
                                dblquote = 0;
                        } else
                            USTPUTC(')', out);
                    } else {
                        /*
                         * unbalanced parens
                         *  (don't 2nd guess - no error)
                         */
                        pungetc();
                        USTPUTC(')', out);
                    }
                }
                break;
            case CBQUOTE:   /* '`' */
                PARSEBACKQOLD();
                break;
            case CEOF:
                goto endword;       /* exit outer loop */
            default:
                if (varnest == 0)
                    goto endword;   /* exit outer loop */
                USTPUTC(c, out);
            }
            c = pgetc_macro();
        }
    }
endword:
    if (syntax == ARISYNTAX)
        synerror("Missing '))'");
    if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
        synerror("Unterminated quoted string");
    if (varnest != 0) {
        startlinno = plinno;
        synerror("Missing '}'");
    }
    USTPUTC('\0', out);
    len = out - stackblock();
    out = stackblock();
    if (eofmark == NULL) {
        if ((c == '>' || c == '<')
         && quotef == 0
         && len <= 2
         && (*out == '\0' || is_digit(*out))) {
            PARSEREDIR();
            return lasttoken = TREDIR;
        } else {
            pungetc();
        }
    }
    quoteflag = quotef;
    backquotelist = bqlist;
    grabstackblock(len);
    wordtext = out;
    return lasttoken = TWORD;
/* end of readtoken routine */
 
 
 
/*
 * 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.
 */
 
checkend: {
    if (eofmark) {
        if (striptabs) {
            while (c == '\t')
                c = pgetc();
        }
        if (c == *eofmark) {
            if (pfgets(line, sizeof line) != NULL) {
                char *p, *q;
 
                p = line;
                for (q = eofmark + 1 ; *q && *p == *q ; p++, q++);
                if (*p == '\n' && *q == '\0') {
                    c = PEOF;
                    plinno++;
                    needprompt = doprompt;
                } else {
                    pushstring(line, strlen(line), NULL);
                }
            }
        }
    }
    goto checkend_return;
}
 
 
/*
 * Parse a redirection operator.  The variable "out" points to a string
 * specifying the fd to be redirected.  The variable "c" contains the
 * first character of the redirection operator.
 */
 
parseredir: {
    char fd = *out;
    union node *np;
 
    np = (union node *)stalloc(sizeof (struct nfile));
    if (c == '>') {
        np->nfile.fd = 1;
        c = pgetc();
        if (c == '>')
            np->type = NAPPEND;
        else if (c == '&')
            np->type = NTOFD;
        else if (c == '|')
            np->type = NTOOV;
        else {
            np->type = NTO;
            pungetc();
        }
    } else {    /* c == '<' */
        np->nfile.fd = 0;
        switch (c = pgetc()) {
        case '<':
            if (sizeof (struct nfile) != sizeof (struct nhere)) {
                np = (union node *)stalloc(sizeof (struct nhere));
                np->nfile.fd = 0;
            }
            np->type = NHERE;
            heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
            heredoc->here = np;
            if ((c = pgetc()) == '-') {
                heredoc->striptabs = 1;
            } else {
                heredoc->striptabs = 0;
                pungetc();
            }
            break;
 
        case '&':
            np->type = NFROMFD;
            break;
 
        case '>':
            np->type = NFROMTO;
            break;
 
        default:
            np->type = NFROM;
            pungetc();
            break;
        }
    }
    if (fd != '\0')
        np->nfile.fd = digit_val(fd);
    redirnode = np;
    goto parseredir_return;
}
 
 
/*
 * 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();
    if (c != '(' && c != '{' && !is_name(c) && !is_special(c)) {
        USTPUTC('$', out);
        pungetc();
    } else if (c == '(') {  /* $(command) or $((arith)) */
        if (pgetc() == '(') {
            PARSEARITH();
        } else {
            pungetc();
            PARSEBACKQNEW();
        }
    } else {
        USTPUTC(CTLVAR, out);
        typeloc = out - stackblock();
        USTPUTC(VSNORMAL, out);
        subtype = VSNORMAL;
        if (c == '{') {
            c = pgetc();
            if (c == '#') {
                if ((c = pgetc()) == '}')
                    c = '#';
                else
                    subtype = VSLENGTH;
            }
            else
                subtype = 0;
        }
        if (is_name(c)) {
            do {
                STPUTC(c, out);
                c = pgetc();
            } while (is_in_name(c));
        } else if (is_digit(c)) {
            do {
                USTPUTC(c, out);
                c = pgetc();
            } while (is_digit(c));
        }
        else if (is_special(c)) {
            USTPUTC(c, out);
            c = pgetc();
        }
        else
badsub:         synerror("Bad substitution");
 
        STPUTC('=', out);
        flags = 0;
        if (subtype == 0) {
            switch (c) {
            case ':':
                flags = VSNUL;
                c = pgetc();
                /*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();
                    if (c == cc)
                        subtype++;
                    else
                        pungetc();
                    break;
                }
            }
        } else {
            pungetc();
        }
        if (dblquote || arinest)
            flags |= VSQUOTE;
        *(stackblock() + typeloc) = subtype | flags;
        if (subtype != VSNORMAL) {
            varnest++;
            if (dblquote) {
                dqvarnest++;
            }
        }
    }
    goto parsesub_return;
}
 
 
/*
 * Called to parse command substitutions.  Newstyle is set if the command
 * is enclosed inside $(...); 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.
 */
 
parsebackq: {
    struct nodelist **nlpp;
    int savepbq;
    union node *n;
    char *volatile str;
    struct jmploc jmploc;
    struct jmploc *volatile savehandler;
    int savelen;
    int saveprompt;
#ifdef __GNUC__
    (void) &saveprompt;
#endif
 
    savepbq = parsebackquote;
    if (setjmp(jmploc.loc)) {
        if (str)
            ckfree(str);
        parsebackquote = 0;
        handler = savehandler;
        longjmp(handler->loc, 1);
    }
    INTOFF;
    str = NULL;
    savelen = out - stackblock();
    if (savelen > 0) {
        str = ckmalloc(savelen);
        memcpy(str, stackblock(), savelen);
    }
    savehandler = handler;
    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.  */
                char *pout;
                int pc;
                int psavelen;
                char *pstr;
 
 
                STARTSTACKSTR(pout);
        for (;;) {
            if (needprompt) {
                setprompt(2);
                needprompt = 0;
            }
            switch (pc = pgetc()) {
            case '`':
                goto done;
 
            case '\\':
                                if ((pc = pgetc()) == '\n') {
                    plinno++;
                    if (doprompt)
                        setprompt(2);
                    else
                        setprompt(0);
                    /*
                     * If eating a newline, avoid putting
                     * the newline into the new character
                     * stream (via the STPUTC after the
                     * switch).
                     */
                    continue;
                }
                                if (pc != '\\' && pc != '`' && pc != '$'
                                    && (!dblquote || pc != '"'))
                                        STPUTC('\\', pout);
                break;
 
            case '\n':
                plinno++;
                needprompt = doprompt;
                break;
 
            case PEOF:
                    startlinno = plinno;
                synerror("EOF in backquote substitution");
                break;
 
            default:
                break;
            }
            STPUTC(pc, pout);
                }
done:
                STPUTC('\0', pout);
                psavelen = pout - stackblock();
                if (psavelen > 0) {
            pstr = grabstackstr(pout);
            setinputstring(pstr, 1);
                }
        }
    nlpp = &bqlist;
    while (*nlpp)
        nlpp = &(*nlpp)->next;
    *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
    (*nlpp)->next = NULL;
    parsebackquote = oldstyle;
 
    if (oldstyle) {
        saveprompt = doprompt;
        doprompt = 0;
    }
 
    n = list(0);
 
    if (oldstyle)
        doprompt = saveprompt;
    else {
        if (readtoken() != TRP)
            synexpect(TRP);
    }
 
    (*nlpp)->n = n;
        if (oldstyle) {
        /*
         * Start reading from old file again, ignoring any pushed back
         * tokens left from the backquote parsing
         */
                popfile();
        tokpushback = 0;
    }
    while (stackblocksize() <= savelen)
        growstackblock();
    STARTSTACKSTR(out);
    if (str) {
        memcpy(out, str, savelen);
        STADJUST(savelen, out);
        INTOFF;
        ckfree(str);
        str = NULL;
        INTON;
    }
    parsebackquote = savepbq;
    handler = savehandler;
    if (arinest || dblquote)
        USTPUTC(CTLBACKQ | CTLQUOTE, out);
    else
        USTPUTC(CTLBACKQ, out);
    if (oldstyle)
        goto parsebackq_oldreturn;
    else
        goto parsebackq_newreturn;
}
 
/*
 * Parse an arithmetic expansion (indicate start of one and set state)
 */
parsearith: {
 
    if (++arinest == 1) {
        prevsyntax = syntax;
        syntax = ARISYNTAX;
        USTPUTC(CTLARI, out);
        if (dblquote)
            USTPUTC('"',out);
        else
            USTPUTC(' ',out);
    } else {
        /*
         * we collapse embedded arithmetic expansion to
         * parenthesis, which should be equivalent
         */
        USTPUTC('(', out);
    }
    goto parsearith_return;
}
 
} /* end of readtoken */
 
 
 
#ifdef mkinit
RESET {
    tokpushback = 0;
    checkkwd = 0;
}
#endif
 
/*
 * Returns true if the text contains nothing to expand (no dollar signs
 * or backquotes).
 */
 
STATIC int
noexpand(text)
    char *text;
    {
    char *p;
    char c;
 
    p = text;
    while ((c = *p++) != '\0') {
        if (c == CTLQUOTEMARK)
            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(char *name)
    {
    char *p;
 
    p = name;
    if (! is_name(*p))
        return 0;
    while (*++p) {
        if (! is_in_name(*p))
            return 0;
    }
    return 1;
}
 
 
/*
 * 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(token)
    int token;
{
    char msg[64];
 
    if (token >= 0) {
        fmtstr(msg, 64, "%s unexpected (expecting %s)",
            tokname[lasttoken], tokname[token]);
    } else {
        fmtstr(msg, 64, "%s unexpected", tokname[lasttoken]);
    }
    synerror(msg);
    /* NOTREACHED */
}
 
 
STATIC void
synerror(msg)
    const char *msg;
    {
    if (commandname)
        outfmt(&errout, "%s: %d: ", commandname, startlinno);
    outfmt(&errout, "Syntax error: %s\n", msg);
    error((char *)NULL);
    /* NOTREACHED */
}
 
STATIC void
setprompt(which)
    int which;
    {
    whichprompt = which;
 
#ifndef SMALL
    if (!el)
#endif
        out2str(getprompt(NULL));
}
 
/*
 * called by editline -- any expansions to the prompt
 *    should be added here.
 */
const char *
getprompt(void *unused)
    {
    switch (whichprompt) {
    case 0:
        return "";
    case 1:
        return ps1val();
    case 2:
        return ps2val();
    default:
        return "<internal prompt error>";
    }
}
 

Rev 2714	Rev 3241
1	/* $NetBSD: parser.c,v 1.45 2000/07/27 04:09:27 cgd Exp $ */	1	/* $NetBSD: parser.c,v 1.45 2000/07/27 04:09:27 cgd Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 1991, 1993	4	* Copyright (c) 1991, 1993
5	* The Regents of the University of California. All rights reserved.	5	* The Regents of the University of California. All rights reserved.
6	*	6	*
7	* This code is derived from software contributed to Berkeley by	7	* This code is derived from software contributed to Berkeley by
8	* Kenneth Almquist.	8	* Kenneth Almquist.
9	*	9	*
10	* Redistribution and use in source and binary forms, with or without	10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions	11	* modification, are permitted provided that the following conditions
12	* are met:	12	* are met:
13	* 1. Redistributions of source code must retain the above copyright	13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.	14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright	15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the	16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.	17	* documentation and/or other materials provided with the distribution.
18	* 3. All advertising materials mentioning features or use of this software	18	* 3. All advertising materials mentioning features or use of this software
19	* must display the following acknowledgement:	19	* must display the following acknowledgement:
20	* This product includes software developed by the University of	20	* This product includes software developed by the University of
21	* California, Berkeley and its contributors.	21	* California, Berkeley and its contributors.
22	* 4. Neither the name of the University nor the names of its contributors	22	* 4. Neither the name of the University nor the names of its contributors
23	* may be used to endorse or promote products derived from this software	23	* may be used to endorse or promote products derived from this software
24	* without specific prior written permission.	24	* without specific prior written permission.
25	*	25	*
26	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND	26	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	27	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE	29	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL	30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS	31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)	32	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT	33	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY	34	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF	35	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36	* SUCH DAMAGE.	36	* SUCH DAMAGE.
37	*/	37	*/
38		38
39	#include <sys/cdefs.h>	39	#include <sys/cdefs.h>
40	#ifndef lint	40	#ifndef lint
41	#if 0	41	#if 0
42	static char sccsid[] = "@(#)parser.c 8.7 (Berkeley) 5/16/95";	42	static char sccsid[] = "@(#)parser.c 8.7 (Berkeley) 5/16/95";
43	#else	43	#else
44	__RCSID("$NetBSD: parser.c,v 1.45 2000/07/27 04:09:27 cgd Exp $");	44	__RCSID("$NetBSD: parser.c,v 1.45 2000/07/27 04:09:27 cgd Exp $");
45	#endif	45	#endif
46	#endif /* not lint */	46	#endif /* not lint */
47		47
48	#include <stdlib.h>	48	#include <stdlib.h>
49		49
50	#include "shell.h"	50	#include "shell.h"
51	#include "parser.h"	51	#include "parser.h"
52	#include "nodes.h"	52	#include "nodes.h"
53	#include "expand.h" /* defines rmescapes() */	53	#include "expand.h" /* defines rmescapes() */
54	#include "redir.h" /* defines copyfd() */	54	#include "redir.h" /* defines copyfd() */
55	#include "syntax.h"	55	#include "syntax.h"
56	#include "options.h"	56	#include "options.h"
57	#include "input.h"	57	#include "input.h"
58	#include "output.h"	58	#include "output.h"
59	#include "var.h"	59	#include "var.h"
60	#include "error.h"	60	#include "error.h"
61	#include "memalloc.h"	61	#include "memalloc.h"
62	#include "mystring.h"	62	#include "mystring.h"
63	#include "alias.h"	63	#include "alias.h"
64	#include "show.h"	64	#include "show.h"
65	#ifndef SMALL	65	#ifndef SMALL
66	#include "myhistedit.h"	66	#include "myhistedit.h"
67	#endif	67	#endif
68		68
69	/*	69	/*
70	* Shell command parser.	70	* Shell command parser.
71	*/	71	*/
72		72
73	#define EOFMARKLEN 79	73	#define EOFMARKLEN 79
74		74
75	/* values returned by readtoken */	75	/* values returned by readtoken */
76	#include "token.h"	76	#include "token.h"
77		77
78		78
79		79
80	struct heredoc {	80	struct heredoc {
81	struct heredoc next; / next here document in list */	81	struct heredoc next; / next here document in list */
82	union node here; / redirection node */	82	union node here; / redirection node */
83	char eofmark; / string indicating end of input */	83	char eofmark; / string indicating end of input */
84	int striptabs; /* if set, strip leading tabs */	84	int striptabs; /* if set, strip leading tabs */
85	};	85	};
86		86
87		87
88		88
89	struct heredoc heredoclist; / list of here documents to read */	89	struct heredoc heredoclist; / list of here documents to read */
90	int parsebackquote; /* nonzero if we are inside backquotes */	90	int parsebackquote; /* nonzero if we are inside backquotes */
91	int doprompt; /* if set, prompt the user */	91	int doprompt; /* if set, prompt the user */
92	int needprompt; /* true if interactive and at start of line */	92	int needprompt; /* true if interactive and at start of line */
93	int lasttoken; /* last token read */	93	int lasttoken; /* last token read */
94	MKINIT int tokpushback; /* last token pushed back */	94	MKINIT int tokpushback; /* last token pushed back */
95	char wordtext; / text of last word returned by readtoken */	95	char wordtext; / text of last word returned by readtoken */
96	MKINIT int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */	96	MKINIT int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
97	struct nodelist *backquotelist;	97	struct nodelist *backquotelist;
98	union node *redirnode;	98	union node *redirnode;
99	struct heredoc *heredoc;	99	struct heredoc *heredoc;
100	int quoteflag; /* set if (part of) last token was quoted */	100	int quoteflag; /* set if (part of) last token was quoted */
101	int startlinno; /* line # where last token started */	101	int startlinno; /* line # where last token started */
102		102
103		103
104	STATIC union node *list (int);	104	STATIC union node *list (int);
105	STATIC union node *andor (void);	105	STATIC union node *andor (void);
106	STATIC union node *pipeline (void);	106	STATIC union node *pipeline (void);
107	STATIC union node *command (void);	107	STATIC union node *command (void);
108	STATIC union node simplecmd (union node , union node );	108	STATIC union node simplecmd (union node , union node );
109	STATIC union node *makename (void);	109	STATIC union node *makename (void);
110	STATIC void parsefname (void);	110	STATIC void parsefname (void);
111	STATIC void parseheredoc (void);	111	STATIC void parseheredoc (void);
112	STATIC int peektoken (void);	112	STATIC int peektoken (void);
113	STATIC int readtoken (void);	113	STATIC int readtoken (void);
114	STATIC int xxreadtoken (void);	114	STATIC int xxreadtoken (void);
115	STATIC int readtoken1 (int, char const , char , int);	115	STATIC int readtoken1 (int, char const , char , int);
116	STATIC int noexpand (char *);	116	STATIC int noexpand (char *);
117	STATIC void synexpect (int) __attribute__((noreturn));	117	STATIC void synexpect (int) __attribute__((noreturn));
118	STATIC void synerror (const char *) __attribute__((noreturn));	118	STATIC void synerror (const char *) __attribute__((noreturn));
119	STATIC void setprompt (int);	119	STATIC void setprompt (int);
120		120
121		121
122	/*	122	/*
123	* Read and parse a command. Returns NEOF on end of file. (NULL is a	123	* Read and parse a command. Returns NEOF on end of file. (NULL is a
124	* valid parse tree indicating a blank line.)	124	* valid parse tree indicating a blank line.)
125	*/	125	*/
126		126
127	union node *	127	union node *
128	parsecmd(int interact)	128	parsecmd(int interact)
129	{	129	{
130	int t;	130	int t;
131		131
132	doprompt = interact;	132	doprompt = interact;
133	if (doprompt)	133	if (doprompt)
134	setprompt(1);	134	setprompt(1);
135	else	135	else
136	setprompt(0);	136	setprompt(0);
137	needprompt = 0;	137	needprompt = 0;
138	t = readtoken();	138	t = readtoken();
139	if (t == TEOF)	139	if (t == TEOF)
140	return NEOF;	140	return NEOF;
141	if (t == TNL)	141	if (t == TNL)
142	return NULL;	142	return NULL;
143	tokpushback++;	143	tokpushback++;
144	return list(1);	144	return list(1);
145	}	145	}
146		146
147		147
148	STATIC union node *	148	STATIC union node *
149	list(nlflag)	149	list(nlflag)
150	int nlflag;	150	int nlflag;
151	{	151	{
152	union node n1, n2, *n3;	152	union node n1, n2, *n3;
153	int tok;	153	int tok;
154		154
155	checkkwd = 2;	155	checkkwd = 2;
156	if (nlflag == 0 && tokendlist[peektoken()])	156	if (nlflag == 0 && tokendlist[peektoken()])
157	return NULL;	157	return NULL;
158	n1 = NULL;	158	n1 = NULL;
159	for (;;) {	159	for (;;) {
160	n2 = andor();	160	n2 = andor();
161	tok = readtoken();	161	tok = readtoken();
162	if (tok == TBACKGND) {	162	if (tok == TBACKGND) {
163	if (n2->type == NCMD \|\| n2->type == NPIPE) {	163	if (n2->type == NCMD \|\| n2->type == NPIPE) {
164	n2->ncmd.backgnd = 1;	164	n2->ncmd.backgnd = 1;
165	} else if (n2->type == NREDIR) {	165	} else if (n2->type == NREDIR) {
166	n2->type = NBACKGND;	166	n2->type = NBACKGND;
167	} else {	167	} else {
168	n3 = (union node *)stalloc(sizeof (struct nredir));	168	n3 = (union node *)stalloc(sizeof (struct nredir));
169	n3->type = NBACKGND;	169	n3->type = NBACKGND;
170	n3->nredir.n = n2;	170	n3->nredir.n = n2;
171	n3->nredir.redirect = NULL;	171	n3->nredir.redirect = NULL;
172	n2 = n3;	172	n2 = n3;
173	}	173	}
174	}	174	}
175	if (n1 == NULL) {	175	if (n1 == NULL) {
176	n1 = n2;	176	n1 = n2;
177	}	177	}
178	else {	178	else {
179	n3 = (union node *)stalloc(sizeof (struct nbinary));	179	n3 = (union node *)stalloc(sizeof (struct nbinary));
180	n3->type = NSEMI;	180	n3->type = NSEMI;
181	n3->nbinary.ch1 = n1;	181	n3->nbinary.ch1 = n1;
182	n3->nbinary.ch2 = n2;	182	n3->nbinary.ch2 = n2;
183	n1 = n3;	183	n1 = n3;
184	}	184	}
185	switch (tok) {	185	switch (tok) {
186	case TBACKGND:	186	case TBACKGND:
187	case TSEMI:	187	case TSEMI:
188	tok = readtoken();	188	tok = readtoken();
189	/* fall through */	189	/* fall through */
190	case TNL:	190	case TNL:
191	if (tok == TNL) {	191	if (tok == TNL) {
192	parseheredoc();	192	parseheredoc();
193	if (nlflag)	193	if (nlflag)
194	return n1;	194	return n1;
195	} else {	195	} else {
196	tokpushback++;	196	tokpushback++;
197	}	197	}
198	checkkwd = 2;	198	checkkwd = 2;
199	if (tokendlist[peektoken()])	199	if (tokendlist[peektoken()])
200	return n1;	200	return n1;
201	break;	201	break;
202	case TEOF:	202	case TEOF:
203	if (heredoclist)	203	if (heredoclist)
204	parseheredoc();	204	parseheredoc();
205	else	205	else
206	pungetc(); /* push back EOF on input */	206	pungetc(); /* push back EOF on input */
207	return n1;	207	return n1;
208	default:	208	default:
209	if (nlflag)	209	if (nlflag)
210	synexpect(-1);	210	synexpect(-1);
211	tokpushback++;	211	tokpushback++;
212	return n1;	212	return n1;
213	}	213	}
214	}	214	}
215	}	215	}
216		216
217		217
218		218
219	STATIC union node *	219	STATIC union node *
220	andor() {	220	andor() {
221	union node n1, n2, *n3;	221	union node n1, n2, *n3;
222	int t;	222	int t;
223		223
224	checkkwd = 1;	224	checkkwd = 1;
225	n1 = pipeline();	225	n1 = pipeline();
226	for (;;) {	226	for (;;) {
227	if ((t = readtoken()) == TAND) {	227	if ((t = readtoken()) == TAND) {
228	t = NAND;	228	t = NAND;
229	} else if (t == TOR) {	229	} else if (t == TOR) {
230	t = NOR;	230	t = NOR;
231	} else {	231	} else {
232	tokpushback++;	232	tokpushback++;
233	return n1;	233	return n1;
234	}	234	}
235	checkkwd = 2;	235	checkkwd = 2;
236	n2 = pipeline();	236	n2 = pipeline();
237	n3 = (union node *)stalloc(sizeof (struct nbinary));	237	n3 = (union node *)stalloc(sizeof (struct nbinary));
238	n3->type = t;	238	n3->type = t;
239	n3->nbinary.ch1 = n1;	239	n3->nbinary.ch1 = n1;
240	n3->nbinary.ch2 = n2;	240	n3->nbinary.ch2 = n2;
241	n1 = n3;	241	n1 = n3;
242	}	242	}
243	}	243	}
244		244
245		245
246		246
247	STATIC union node *	247	STATIC union node *
248	pipeline() {	248	pipeline() {
249	union node n1, n2, *pipenode;	249	union node n1, n2, *pipenode;
250	struct nodelist lp, prev;	250	struct nodelist lp, prev;
251	int negate;	251	int negate;
252		252
253	negate = 0;	253	negate = 0;
254	TRACE(("pipeline: entered\n"));	254	TRACE(("pipeline: entered\n"));
255	if (readtoken() == TNOT) {	255	if (readtoken() == TNOT) {
256	negate = !negate;	256	negate = !negate;
257	checkkwd = 1;	257	checkkwd = 1;
258	} else	258	} else
259	tokpushback++;	259	tokpushback++;
260	n1 = command();	260	n1 = command();
261	if (readtoken() == TPIPE) {	261	if (readtoken() == TPIPE) {
262	pipenode = (union node *)stalloc(sizeof (struct npipe));	262	pipenode = (union node *)stalloc(sizeof (struct npipe));
263	pipenode->type = NPIPE;	263	pipenode->type = NPIPE;
264	pipenode->npipe.backgnd = 0;	264	pipenode->npipe.backgnd = 0;
265	lp = (struct nodelist *)stalloc(sizeof (struct nodelist));	265	lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
266	pipenode->npipe.cmdlist = lp;	266	pipenode->npipe.cmdlist = lp;
267	lp->n = n1;	267	lp->n = n1;
268	do {	268	do {
269	prev = lp;	269	prev = lp;
270	lp = (struct nodelist *)stalloc(sizeof (struct nodelist));	270	lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
271	checkkwd = 2;	271	checkkwd = 2;
272	lp->n = command();	272	lp->n = command();
273	prev->next = lp;	273	prev->next = lp;
274	} while (readtoken() == TPIPE);	274	} while (readtoken() == TPIPE);
275	lp->next = NULL;	275	lp->next = NULL;
276	n1 = pipenode;	276	n1 = pipenode;
277	}	277	}
278	tokpushback++;	278	tokpushback++;
279	if (negate) {	279	if (negate) {
280	n2 = (union node *)stalloc(sizeof (struct nnot));	280	n2 = (union node *)stalloc(sizeof (struct nnot));
281	n2->type = NNOT;	281	n2->type = NNOT;
282	n2->nnot.com = n1;	282	n2->nnot.com = n1;
283	return n2;	283	return n2;
284	} else	284	} else
285	return n1;	285	return n1;
286	}	286	}
287		287
288		288
289		289
290	STATIC union node *	290	STATIC union node *
291	command() {	291	command() {
292	union node n1, n2;	292	union node n1, n2;
293	union node ap, *app;	293	union node ap, *app;
294	union node cp, *cpp;	294	union node cp, *cpp;
295	union node redir, *rpp;	295	union node redir, *rpp;
296	int t;	296	int t;
297		297
298	redir = NULL;	298	redir = NULL;
299	n1 = NULL;	299	n1 = NULL;
300	rpp = &redir;	300	rpp = &redir;
301		301
302	/* Check for redirection which may precede command */	302	/* Check for redirection which may precede command */
303	while (readtoken() == TREDIR) {	303	while (readtoken() == TREDIR) {
304	*rpp = n2 = redirnode;	304	*rpp = n2 = redirnode;
305	rpp = &n2->nfile.next;	305	rpp = &n2->nfile.next;
306	parsefname();	306	parsefname();
307	}	307	}
308	tokpushback++;	308	tokpushback++;
309		309
310	switch (readtoken()) {	310	switch (readtoken()) {
311	case TIF:	311	case TIF:
312	n1 = (union node *)stalloc(sizeof (struct nif));	312	n1 = (union node *)stalloc(sizeof (struct nif));
313	n1->type = NIF;	313	n1->type = NIF;
314	n1->nif.test = list(0);	314	n1->nif.test = list(0);
315	if (readtoken() != TTHEN)	315	if (readtoken() != TTHEN)
316	synexpect(TTHEN);	316	synexpect(TTHEN);
317	n1->nif.ifpart = list(0);	317	n1->nif.ifpart = list(0);
318	n2 = n1;	318	n2 = n1;
319	while (readtoken() == TELIF) {	319	while (readtoken() == TELIF) {
320	n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));	320	n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
321	n2 = n2->nif.elsepart;	321	n2 = n2->nif.elsepart;
322	n2->type = NIF;	322	n2->type = NIF;
323	n2->nif.test = list(0);	323	n2->nif.test = list(0);
324	if (readtoken() != TTHEN)	324	if (readtoken() != TTHEN)
325	synexpect(TTHEN);	325	synexpect(TTHEN);
326	n2->nif.ifpart = list(0);	326	n2->nif.ifpart = list(0);
327	}	327	}
328	if (lasttoken == TELSE)	328	if (lasttoken == TELSE)
329	n2->nif.elsepart = list(0);	329	n2->nif.elsepart = list(0);
330	else {	330	else {
331	n2->nif.elsepart = NULL;	331	n2->nif.elsepart = NULL;
332	tokpushback++;	332	tokpushback++;
333	}	333	}
334	if (readtoken() != TFI)	334	if (readtoken() != TFI)
335	synexpect(TFI);	335	synexpect(TFI);
336	checkkwd = 1;	336	checkkwd = 1;
337	break;	337	break;
338	case TWHILE:	338	case TWHILE:
339	case TUNTIL: {	339	case TUNTIL: {
340	int got;	340	int got;
341	n1 = (union node *)stalloc(sizeof (struct nbinary));	341	n1 = (union node *)stalloc(sizeof (struct nbinary));
342	n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;	342	n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
343	n1->nbinary.ch1 = list(0);	343	n1->nbinary.ch1 = list(0);
344	if ((got=readtoken()) != TDO) {	344	if ((got=readtoken()) != TDO) {
345	TRACE(("expecting DO got %s %s\n", tokname[got], got == TWORD ? wordtext : ""));	345	TRACE(("expecting DO got %s %s\n", tokname[got], got == TWORD ? wordtext : ""));
346	synexpect(TDO);	346	synexpect(TDO);
347	}	347	}
348	n1->nbinary.ch2 = list(0);	348	n1->nbinary.ch2 = list(0);
349	if (readtoken() != TDONE)	349	if (readtoken() != TDONE)
350	synexpect(TDONE);	350	synexpect(TDONE);
351	checkkwd = 1;	351	checkkwd = 1;
352	break;	352	break;
353	}	353	}
354	case TFOR:	354	case TFOR:
355	if (readtoken() != TWORD \|\| quoteflag \|\| ! goodname(wordtext))	355	if (readtoken() != TWORD \|\| quoteflag \|\| ! goodname(wordtext))
356	synerror("Bad for loop variable");	356	synerror("Bad for loop variable");
357	n1 = (union node *)stalloc(sizeof (struct nfor));	357	n1 = (union node *)stalloc(sizeof (struct nfor));
358	n1->type = NFOR;	358	n1->type = NFOR;
359	n1->nfor.var = wordtext;	359	n1->nfor.var = wordtext;
360	if (readtoken() == TWORD && ! quoteflag && equal(wordtext, "in")) {	360	if (readtoken() == TWORD && ! quoteflag && equal(wordtext, "in")) {
361	app = ≈	361	app = ≈
362	while (readtoken() == TWORD) {	362	while (readtoken() == TWORD) {
363	n2 = (union node *)stalloc(sizeof (struct narg));	363	n2 = (union node *)stalloc(sizeof (struct narg));
364	n2->type = NARG;	364	n2->type = NARG;
365	n2->narg.text = wordtext;	365	n2->narg.text = wordtext;
366	n2->narg.backquote = backquotelist;	366	n2->narg.backquote = backquotelist;
367	*app = n2;	367	*app = n2;
368	app = &n2->narg.next;	368	app = &n2->narg.next;
369	}	369	}
370	*app = NULL;	370	*app = NULL;
371	n1->nfor.args = ap;	371	n1->nfor.args = ap;
372	if (lasttoken != TNL && lasttoken != TSEMI)	372	if (lasttoken != TNL && lasttoken != TSEMI)
373	synexpect(-1);	373	synexpect(-1);
374	} else {	374	} else {
375	static char argvars[5] = {CTLVAR, VSNORMAL\|VSQUOTE,	375	static char argvars[5] = {CTLVAR, VSNORMAL\|VSQUOTE,
376	'@', '=', '\0'};	376	'@', '=', '\0'};
377	n2 = (union node *)stalloc(sizeof (struct narg));	377	n2 = (union node *)stalloc(sizeof (struct narg));
378	n2->type = NARG;	378	n2->type = NARG;
379	n2->narg.text = argvars;	379	n2->narg.text = argvars;
380	n2->narg.backquote = NULL;	380	n2->narg.backquote = NULL;
381	n2->narg.next = NULL;	381	n2->narg.next = NULL;
382	n1->nfor.args = n2;	382	n1->nfor.args = n2;
383	/*	383	/*
384	* Newline or semicolon here is optional (but note	384	* Newline or semicolon here is optional (but note
385	* that the original Bourne shell only allowed NL).	385	* that the original Bourne shell only allowed NL).
386	*/	386	*/
387	if (lasttoken != TNL && lasttoken != TSEMI)	387	if (lasttoken != TNL && lasttoken != TSEMI)
388	tokpushback++;	388	tokpushback++;
389	}	389	}
390	checkkwd = 2;	390	checkkwd = 2;
391	if ((t = readtoken()) == TDO)	391	if ((t = readtoken()) == TDO)
392	t = TDONE;	392	t = TDONE;
393	else if (t == TBEGIN)	393	else if (t == TBEGIN)
394	t = TEND;	394	t = TEND;
395	else	395	else
396	synexpect(-1);	396	synexpect(-1);
397	n1->nfor.body = list(0);	397	n1->nfor.body = list(0);
398	if (readtoken() != t)	398	if (readtoken() != t)
399	synexpect(t);	399	synexpect(t);
400	checkkwd = 1;	400	checkkwd = 1;
401	break;	401	break;
402	case TCASE:	402	case TCASE:
403	n1 = (union node *)stalloc(sizeof (struct ncase));	403	n1 = (union node *)stalloc(sizeof (struct ncase));
404	n1->type = NCASE;	404	n1->type = NCASE;
405	if (readtoken() != TWORD)	405	if (readtoken() != TWORD)
406	synexpect(TWORD);	406	synexpect(TWORD);
407	n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));	407	n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
408	n2->type = NARG;	408	n2->type = NARG;
409	n2->narg.text = wordtext;	409	n2->narg.text = wordtext;
410	n2->narg.backquote = backquotelist;	410	n2->narg.backquote = backquotelist;
411	n2->narg.next = NULL;	411	n2->narg.next = NULL;
412	while (readtoken() == TNL);	412	while (readtoken() == TNL);
413	if (lasttoken != TWORD \|\| ! equal(wordtext, "in"))	413	if (lasttoken != TWORD \|\| ! equal(wordtext, "in"))
414	synerror("expecting \"in\"");	414	synerror("expecting \"in\"");
415	cpp = &n1->ncase.cases;	415	cpp = &n1->ncase.cases;
416	checkkwd = 2, readtoken();	416	checkkwd = 2, readtoken();
417	do {	417	do {
418	if (lasttoken == TLP)	418	if (lasttoken == TLP)
419	readtoken();	419	readtoken();
420	cpp = cp = (union node )stalloc(sizeof (struct nclist));	420	cpp = cp = (union node )stalloc(sizeof (struct nclist));
421	cp->type = NCLIST;	421	cp->type = NCLIST;
422	app = &cp->nclist.pattern;	422	app = &cp->nclist.pattern;
423	for (;;) {	423	for (;;) {
424	app = ap = (union node )stalloc(sizeof (struct narg));	424	app = ap = (union node )stalloc(sizeof (struct narg));
425	ap->type = NARG;	425	ap->type = NARG;
426	ap->narg.text = wordtext;	426	ap->narg.text = wordtext;
427	ap->narg.backquote = backquotelist;	427	ap->narg.backquote = backquotelist;
428	if (checkkwd = 2, readtoken() != TPIPE)	428	if (checkkwd = 2, readtoken() != TPIPE)
429	break;	429	break;
430	app = &ap->narg.next;	430	app = &ap->narg.next;
431	readtoken();	431	readtoken();
432	}	432	}
433	ap->narg.next = NULL;	433	ap->narg.next = NULL;
434	if (lasttoken != TRP)	434	if (lasttoken != TRP)
435	synexpect(TRP);	435	synexpect(TRP);
436	cp->nclist.body = list(0);	436	cp->nclist.body = list(0);
437		437
438	checkkwd = 2;	438	checkkwd = 2;
439	if ((t = readtoken()) != TESAC) {	439	if ((t = readtoken()) != TESAC) {
440	if (t != TENDCASE)	440	if (t != TENDCASE)
441	synexpect(TENDCASE);	441	synexpect(TENDCASE);
442	else	442	else
443	checkkwd = 2, readtoken();	443	checkkwd = 2, readtoken();
444	}	444	}
445	cpp = &cp->nclist.next;	445	cpp = &cp->nclist.next;
446	} while(lasttoken != TESAC);	446	} while(lasttoken != TESAC);
447	*cpp = NULL;	447	*cpp = NULL;
448	checkkwd = 1;	448	checkkwd = 1;
449	break;	449	break;
450	case TLP:	450	case TLP:
451	n1 = (union node *)stalloc(sizeof (struct nredir));	451	n1 = (union node *)stalloc(sizeof (struct nredir));
452	n1->type = NSUBSHELL;	452	n1->type = NSUBSHELL;
453	n1->nredir.n = list(0);	453	n1->nredir.n = list(0);
454	n1->nredir.redirect = NULL;	454	n1->nredir.redirect = NULL;
455	if (readtoken() != TRP)	455	if (readtoken() != TRP)
456	synexpect(TRP);	456	synexpect(TRP);
457	checkkwd = 1;	457	checkkwd = 1;
458	break;	458	break;
459	case TBEGIN:	459	case TBEGIN:
460	n1 = list(0);	460	n1 = list(0);
461	if (readtoken() != TEND)	461	if (readtoken() != TEND)
462	synexpect(TEND);	462	synexpect(TEND);
463	checkkwd = 1;	463	checkkwd = 1;
464	break;	464	break;
465	/* Handle an empty command like other simple commands. */	465	/* Handle an empty command like other simple commands. */
466	case TSEMI:	466	case TSEMI:
467	case TAND:	467	case TAND:
468	case TOR:	468	case TOR:
469	case TNL:	469	case TNL:
470	case TEOF:	470	case TEOF:
471	case TRP:	471	case TRP:
472	case TBACKGND:	472	case TBACKGND:
473	/*	473	/*
474	* An empty command before a ; doesn't make much sense, and	474	* An empty command before a ; doesn't make much sense, and
475	* should certainly be disallowed in the case of `if ;'.	475	* should certainly be disallowed in the case of `if ;'.
476	*/	476	*/
477	if (!redir)	477	if (!redir)
478	synexpect(-1);	478	synexpect(-1);
479	case TWORD:	479	case TWORD:
480	tokpushback++;	480	tokpushback++;
481	n1 = simplecmd(rpp, redir);	481	n1 = simplecmd(rpp, redir);
482	return n1;	482	return n1;
483	default:	483	default:
484	synexpect(-1);	484	synexpect(-1);
485	/* NOTREACHED */	485	/* NOTREACHED */
486	}	486	}
487		487
488	/* Now check for redirection which may follow command */	488	/* Now check for redirection which may follow command */
489	while (readtoken() == TREDIR) {	489	while (readtoken() == TREDIR) {
490	*rpp = n2 = redirnode;	490	*rpp = n2 = redirnode;
491	rpp = &n2->nfile.next;	491	rpp = &n2->nfile.next;
492	parsefname();	492	parsefname();
493	}	493	}
494	tokpushback++;	494	tokpushback++;
495	*rpp = NULL;	495	*rpp = NULL;
496	if (redir) {	496	if (redir) {
497	if (n1->type != NSUBSHELL) {	497	if (n1->type != NSUBSHELL) {
498	n2 = (union node *)stalloc(sizeof (struct nredir));	498	n2 = (union node *)stalloc(sizeof (struct nredir));
499	n2->type = NREDIR;	499	n2->type = NREDIR;
500	n2->nredir.n = n1;	500	n2->nredir.n = n1;

Subversion Repositories HelenOS

(root)/branches/shell/uspace/app/ash/parser.c @ 3341 – Rev 2714 → 3241