[unix-history] / usr / src / bin / csh / parse.c

/*-
 * Copyright (c) 1980, 1991 The Regents of the University of California.
 * All rights reserved.
 *
 * 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.
 */

#ifndef lint
static char sccsid[] = "@(#)parse.c	5.11 (Berkeley) 6/8/91";
#endif /* not lint */

#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#if __STDC__
# include <stdarg.h>
#else
# include <varargs.h>
#endif

#include "csh.h"
#include "extern.h"

static void	 asyntax __P((struct wordent *, struct wordent *));
static void	 asyn0 __P((struct wordent *, struct wordent *));
static void	 asyn3 __P((struct wordent *, struct wordent *));
static struct wordent 
		*freenod __P((struct wordent *, struct wordent *));
static struct command 
		*syn0 __P((struct wordent *, struct wordent *, int));
static struct command 
		*syn1 __P((struct wordent *, struct wordent *, int));
static struct command 
		*syn1a __P((struct wordent *, struct wordent *, int));
static struct command 
		*syn1b __P((struct wordent *, struct wordent *, int));
static struct command 
		*syn2 __P((struct wordent *, struct wordent *, int));
static struct command 
		*syn3 __P((struct wordent *, struct wordent *, int));

#define ALEFT	21		/* max of 20 alias expansions	 */
#define HLEFT	11		/* max of 10 history expansions	 */
/*
 * Perform aliasing on the word list lex
 * Do a (very rudimentary) parse to separate into commands.
 * If word 0 of a command has an alias, do it.
 * Repeat a maximum of 20 times.
 */
static int aleft;
extern int hleft;
void
alias(lex)
    register struct wordent *lex;
{
    jmp_buf osetexit;

    aleft = ALEFT;
    hleft = HLEFT;
    getexit(osetexit);
    (void) setexit();
    if (haderr) {
	resexit(osetexit);
	reset();
    }
    if (--aleft == 0)
	stderror(ERR_ALIASLOOP);
    asyntax(lex->next, lex);
    resexit(osetexit);
}

static void
asyntax(p1, p2)
    register struct wordent *p1, *p2;
{
    while (p1 != p2)
	if (any(";&\n", p1->word[0]))
	    p1 = p1->next;
	else {
	    asyn0(p1, p2);
	    return;
	}
}

static void
asyn0(p1, p2)
    struct wordent *p1;
    register struct wordent *p2;
{
    register struct wordent *p;
    register int l = 0;

    for (p = p1; p != p2; p = p->next)
	switch (p->word[0]) {

	case '(':
	    l++;
	    continue;

	case ')':
	    l--;
	    if (l < 0)
		stderror(ERR_TOOMANYRP);
	    continue;

	case '>':
	    if (p->next != p2 && eq(p->next->word, STRand))
		p = p->next;
	    continue;

	case '&':
	case '|':
	case ';':
	case '\n':
	    if (l != 0)
		continue;
	    asyn3(p1, p);
	    asyntax(p->next, p2);
	    return;
	}
    if (l == 0)
	asyn3(p1, p2);
}

static void
asyn3(p1, p2)
    struct wordent *p1;
    register struct wordent *p2;
{
    register struct varent *ap;
    struct wordent alout;
    register bool redid;

    if (p1 == p2)
	return;
    if (p1->word[0] == '(') {
	for (p2 = p2->prev; p2->word[0] != ')'; p2 = p2->prev)
	    if (p2 == p1)
		return;
	if (p2 == p1->next)
	    return;
	asyn0(p1->next, p2);
	return;
    }
    ap = adrof1(p1->word, &aliases);
    if (ap == 0)
	return;
    alhistp = p1->prev;
    alhistt = p2;
    alvec = ap->vec;
    redid = lex(&alout);
    alhistp = alhistt = 0;
    alvec = 0;
    if (seterr) {
	freelex(&alout);
	stderror(ERR_OLD);
    }
    if (p1->word[0] && eq(p1->word, alout.next->word)) {
	Char   *cp = alout.next->word;

	alout.next->word = Strspl(STRQNULL, cp);
	xfree((ptr_t) cp);
    }
    p1 = freenod(p1, redid ? p2 : p1->next);
    if (alout.next != &alout) {
	p1->next->prev = alout.prev->prev;
	alout.prev->prev->next = p1->next;
	alout.next->prev = p1;
	p1->next = alout.next;
	xfree((ptr_t) alout.prev->word);
	xfree((ptr_t) (alout.prev));
    }
    reset();			/* throw! */
}

static struct wordent *
freenod(p1, p2)
    register struct wordent *p1, *p2;
{
    register struct wordent *retp = p1->prev;

    while (p1 != p2) {
	xfree((ptr_t) p1->word);
	p1 = p1->next;
	xfree((ptr_t) (p1->prev));
    }
    retp->next = p2;
    p2->prev = retp;
    return (retp);
}

#define	PHERE	1
#define	PIN	2
#define	POUT	4
#define	PDIAG	8

/*
 * syntax
 *	empty
 *	syn0
 */
struct command *
syntax(p1, p2, flags)
    register struct wordent *p1, *p2;
    int     flags;
{

    while (p1 != p2)
	if (any(";&\n", p1->word[0]))
	    p1 = p1->next;
	else
	    return (syn0(p1, p2, flags));
    return (0);
}

/*
 * syn0
 *	syn1
 *	syn1 & syntax
 */
static struct command *
syn0(p1, p2, flags)
    struct wordent *p1, *p2;
    int     flags;
{
    register struct wordent *p;
    register struct command *t, *t1;
    int     l;

    l = 0;
    for (p = p1; p != p2; p = p->next)
	switch (p->word[0]) {

	case '(':
	    l++;
	    continue;

	case ')':
	    l--;
	    if (l < 0)
		seterror(ERR_TOOMANYRP);
	    continue;

	case '|':
	    if (p->word[1] == '|')
		continue;
	    /* fall into ... */

	case '>':
	    if (p->next != p2 && eq(p->next->word, STRand))
		p = p->next;
	    continue;

	case '&':
	    if (l != 0)
		break;
	    if (p->word[1] == '&')
		continue;
	    t1 = syn1(p1, p, flags);
	    if (t1->t_dtyp == NODE_LIST ||
		t1->t_dtyp == NODE_AND ||
		t1->t_dtyp == NODE_OR) {
		t = (struct command *) xcalloc(1, sizeof(*t));
		t->t_dtyp = NODE_PAREN;
		t->t_dflg = F_AMPERSAND | F_NOINTERRUPT;
		t->t_dspr = t1;
		t1 = t;
	    }
	    else
		t1->t_dflg |= F_AMPERSAND | F_NOINTERRUPT;
	    t = (struct command *) xcalloc(1, sizeof(*t));
	    t->t_dtyp = NODE_LIST;
	    t->t_dflg = 0;
	    t->t_dcar = t1;
	    t->t_dcdr = syntax(p, p2, flags);
	    return (t);
	}
    if (l == 0)
	return (syn1(p1, p2, flags));
    seterror(ERR_TOOMANYLP);
    return (0);
}

/*
 * syn1
 *	syn1a
 *	syn1a ; syntax
 */
static struct command *
syn1(p1, p2, flags)
    struct wordent *p1, *p2;
    int     flags;
{
    register struct wordent *p;
    register struct command *t;
    int     l;

    l = 0;
    for (p = p1; p != p2; p = p->next)
	switch (p->word[0]) {

	case '(':
	    l++;
	    continue;

	case ')':
	    l--;
	    continue;

	case ';':
	case '\n':
	    if (l != 0)
		break;
	    t = (struct command *) xcalloc(1, sizeof(*t));
	    t->t_dtyp = NODE_LIST;
	    t->t_dcar = syn1a(p1, p, flags);
	    t->t_dcdr = syntax(p->next, p2, flags);
	    if (t->t_dcdr == 0)
		t->t_dcdr = t->t_dcar, t->t_dcar = 0;
	    return (t);
	}
    return (syn1a(p1, p2, flags));
}

/*
 * syn1a
 *	syn1b
 *	syn1b || syn1a
 */
static struct command *
syn1a(p1, p2, flags)
    struct wordent *p1, *p2;
    int     flags;
{
    register struct wordent *p;
    register struct command *t;
    register int l = 0;

    for (p = p1; p != p2; p = p->next)
	switch (p->word[0]) {

	case '(':
	    l++;
	    continue;

	case ')':
	    l--;
	    continue;

	case '|':
	    if (p->word[1] != '|')
		continue;
	    if (l == 0) {
		t = (struct command *) xcalloc(1, sizeof(*t));
		t->t_dtyp = NODE_OR;
		t->t_dcar = syn1b(p1, p, flags);
		t->t_dcdr = syn1a(p->next, p2, flags);
		t->t_dflg = 0;
		return (t);
	    }
	    continue;
	}
    return (syn1b(p1, p2, flags));
}

/*
 * syn1b
 *	syn2
 *	syn2 && syn1b
 */
static struct command *
syn1b(p1, p2, flags)
    struct wordent *p1, *p2;
    int     flags;
{
    register struct wordent *p;
    register struct command *t;
    register int l = 0;

    for (p = p1; p != p2; p = p->next)
	switch (p->word[0]) {

	case '(':
	    l++;
	    continue;

	case ')':
	    l--;
	    continue;

	case '&':
	    if (p->word[1] == '&' && l == 0) {
		t = (struct command *) xcalloc(1, sizeof(*t));
		t->t_dtyp = NODE_AND;
		t->t_dcar = syn2(p1, p, flags);
		t->t_dcdr = syn1b(p->next, p2, flags);
		t->t_dflg = 0;
		return (t);
	    }
	    continue;
	}
    return (syn2(p1, p2, flags));
}

/*
 * syn2
 *	syn3
 *	syn3 | syn2
 *	syn3 |& syn2
 */
static struct command *
syn2(p1, p2, flags)
    struct wordent *p1, *p2;
    int     flags;
{
    register struct wordent *p, *pn;
    register struct command *t;
    register int l = 0;
    int     f;

    for (p = p1; p != p2; p = p->next)
	switch (p->word[0]) {

	case '(':
	    l++;
	    continue;

	case ')':
	    l--;
	    continue;

	case '|':
	    if (l != 0)
		continue;
	    t = (struct command *) xcalloc(1, sizeof(*t));
	    f = flags | POUT;
	    pn = p->next;
	    if (pn != p2 && pn->word[0] == '&') {
		f |= PDIAG;
		t->t_dflg |= F_STDERR;
	    }
	    t->t_dtyp = NODE_PIPE;
	    t->t_dcar = syn3(p1, p, f);
	    if (pn != p2 && pn->word[0] == '&')
		p = pn;
	    t->t_dcdr = syn2(p->next, p2, flags | PIN);
	    return (t);
	}
    return (syn3(p1, p2, flags));
}

static char RELPAR[] = {'<', '>', '(', ')', '\0'};

/*
 * syn3
 *	( syn0 ) [ < in  ] [ > out ]
 *	word word* [ < in ] [ > out ]
 *	KEYWORD ( word* ) word* [ < in ] [ > out ]
 *
 *	KEYWORD = (@ exit foreach if set switch test while)
 */
static struct command *
syn3(p1, p2, flags)
    struct wordent *p1, *p2;
    int     flags;
{
    register struct wordent *p;
    struct wordent *lp, *rp;
    register struct command *t;
    register int l;
    Char  **av;
    int     n, c;
    bool    specp = 0;

    if (p1 != p2) {
	p = p1;
again:
	switch (srchx(p->word)) {

	case T_ELSE:
	    p = p->next;
	    if (p != p2)
		goto again;
	    break;

	case T_EXIT:
	case T_FOREACH:
	case T_IF:
	case T_LET:
	case T_SET:
	case T_SWITCH:
	case T_WHILE:
	    specp = 1;
	    break;
	}
    }
    n = 0;
    l = 0;
    for (p = p1; p != p2; p = p->next)
	switch (p->word[0]) {

	case '(':
	    if (specp)
		n++;
	    l++;
	    continue;

	case ')':
	    if (specp)
		n++;
	    l--;
	    continue;

	case '>':
	case '<':
	    if (l != 0) {
		if (specp)
		    n++;
		continue;
	    }
	    if (p->next == p2)
		continue;
	    if (any(RELPAR, p->next->word[0]))
		continue;
	    n--;
	    continue;

	default:
	    if (!specp && l != 0)
		continue;
	    n++;
	    continue;
	}
    if (n < 0)
	n = 0;
    t = (struct command *) xcalloc(1, sizeof(*t));
    av = (Char **) xcalloc((size_t) (n + 1), sizeof(Char **));
    t->t_dcom = av;
    n = 0;
    if (p2->word[0] == ')')
	t->t_dflg = F_NOFORK;
    lp = 0;
    rp = 0;
    l = 0;
    for (p = p1; p != p2; p = p->next) {
	c = p->word[0];
	switch (c) {

	case '(':
	    if (l == 0) {
		if (lp != 0 && !specp)
		    seterror(ERR_BADPLP);
		lp = p->next;
	    }
	    l++;
	    goto savep;

	case ')':
	    l--;
	    if (l == 0)
		rp = p;
	    goto savep;

	case '>':
	    if (l != 0)
		goto savep;
	    if (p->word[1] == '>')
		t->t_dflg |= F_APPEND;
	    if (p->next != p2 && eq(p->next->word, STRand)) {
		t->t_dflg |= F_STDERR, p = p->next;
		if (flags & (POUT | PDIAG)) {
		    seterror(ERR_OUTRED);
		    continue;
		}
	    }
	    if (p->next != p2 && eq(p->next->word, STRbang))
		t->t_dflg |= F_OVERWRITE, p = p->next;
	    if (p->next == p2) {
		seterror(ERR_MISRED);
		continue;
	    }
	    p = p->next;
	    if (any(RELPAR, p->word[0])) {
		seterror(ERR_MISRED);
		continue;
	    }
	    if ((flags & POUT) && (flags & PDIAG) == 0 || t->t_drit)
		seterror(ERR_OUTRED);
	    else
		t->t_drit = Strsave(p->word);
	    continue;

	case '<':
	    if (l != 0)
		goto savep;
	    if (p->word[1] == '<')
		t->t_dflg |= F_READ;
	    if (p->next == p2) {
		seterror(ERR_MISRED);
		continue;
	    }
	    p = p->next;
	    if (any(RELPAR, p->word[0])) {
		seterror(ERR_MISRED);
		continue;
	    }
	    if ((flags & PHERE) && (t->t_dflg & F_READ))
		seterror(ERR_REDPAR);
	    else if ((flags & PIN) || t->t_dlef)
		seterror(ERR_INRED);
	    else
		t->t_dlef = Strsave(p->word);
	    continue;

    savep:
	    if (!specp)
		continue;
	default:
	    if (l != 0 && !specp)
		continue;
	    if (seterr == 0)
		av[n] = Strsave(p->word);
	    n++;
	    continue;
	}
    }
    if (lp != 0 && !specp) {
	if (n != 0)
	    seterror(ERR_BADPLPS);
	t->t_dtyp = NODE_PAREN;
	t->t_dspr = syn0(lp, rp, PHERE);
    }
    else {
	if (n == 0)
	    seterror(ERR_NULLCOM);
	t->t_dtyp = NODE_COMMAND;
    }
    return (t);
}

void
freesyn(t)
    register struct command *t;
{
    register Char **v;

    if (t == 0)
	return;
    switch (t->t_dtyp) {

    case NODE_COMMAND:
	for (v = t->t_dcom; *v; v++)
	    xfree((ptr_t) * v);
	xfree((ptr_t) (t->t_dcom));
	xfree((ptr_t) t->t_dlef);
	xfree((ptr_t) t->t_drit);
	break;
    case NODE_PAREN:
	freesyn(t->t_dspr);
	xfree((ptr_t) t->t_dlef);
	xfree((ptr_t) t->t_drit);
	break;

    case NODE_AND:
    case NODE_OR:
    case NODE_PIPE:
    case NODE_LIST:
	freesyn(t->t_dcar), freesyn(t->t_dcdr);
	break;
    }
    xfree((ptr_t) t);
}
Commit	Line	Data
5a9d2163 WJ	1	/*-
	2	* Copyright (c) 1980, 1991 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34	#ifndef lint
	35	static char sccsid[] = "@(#)parse.c 5.11 (Berkeley) 6/8/91";
	36	#endif /* not lint */
	37
	38	#include <sys/types.h>
	39	#include <stdlib.h>
	40	#include <string.h>
	41	#if __STDC__
	42	# include <stdarg.h>
	43	#else
	44	# include <varargs.h>
	45	#endif
	46
	47	#include "csh.h"
	48	#include "extern.h"
	49
	50	static void asyntax __P((struct wordent , struct wordent ));
	51	static void asyn0 __P((struct wordent , struct wordent ));
	52	static void asyn3 __P((struct wordent , struct wordent ));
	53	static struct wordent
	54	freenod __P((struct wordent , struct wordent *));
	55	static struct command
	56	syn0 __P((struct wordent , struct wordent *, int));
	57	static struct command
	58	syn1 __P((struct wordent , struct wordent *, int));
	59	static struct command
	60	syn1a __P((struct wordent , struct wordent *, int));
	61	static struct command
	62	syn1b __P((struct wordent , struct wordent *, int));
	63	static struct command
	64	syn2 __P((struct wordent , struct wordent *, int));
65	static struct command
66	syn3 __P((struct wordent , struct wordent *, int));
67
68	#define ALEFT 21 /* max of 20 alias expansions */
69	#define HLEFT 11 /* max of 10 history expansions */
70	/*
71	* Perform aliasing on the word list lex
72	* Do a (very rudimentary) parse to separate into commands.
73	* If word 0 of a command has an alias, do it.
74	* Repeat a maximum of 20 times.
75	*/
76	static int aleft;
77	extern int hleft;
78	void
79	alias(lex)
80	register struct wordent *lex;
81	{
82	jmp_buf osetexit;
83
84	aleft = ALEFT;
85	hleft = HLEFT;
86	getexit(osetexit);
87	(void) setexit();
88	if (haderr) {
89	resexit(osetexit);
90	reset();
91	}
92	if (--aleft == 0)
93	stderror(ERR_ALIASLOOP);
94	asyntax(lex->next, lex);
95	resexit(osetexit);
96	}
97
98	static void
99	asyntax(p1, p2)
100	register struct wordent p1, p2;
101	{
102	while (p1 != p2)
103	if (any(";&\n", p1->word[0]))
104	p1 = p1->next;
105	else {
106	asyn0(p1, p2);
107	return;
108	}
109	}
110
111	static void
112	asyn0(p1, p2)
113	struct wordent *p1;
114	register struct wordent *p2;
115	{
116	register struct wordent *p;
117	register int l = 0;
118
119	for (p = p1; p != p2; p = p->next)
120	switch (p->word[0]) {
121
122	case '(':
123	l++;
124	continue;
125
126	case ')':
127	l--;
128	if (l < 0)
129	stderror(ERR_TOOMANYRP);
130	continue;
131
132	case '>':
133	if (p->next != p2 && eq(p->next->word, STRand))
134	p = p->next;
135	continue;
136
137	case '&':
138	case '\|':
139	case ';':
140	case '\n':
141	if (l != 0)
142	continue;
143	asyn3(p1, p);
144	asyntax(p->next, p2);
145	return;
146	}
147	if (l == 0)
148	asyn3(p1, p2);
149	}
150
151	static void
152	asyn3(p1, p2)
153	struct wordent *p1;
154	register struct wordent *p2;
155	{
156	register struct varent *ap;
157	struct wordent alout;
158	register bool redid;
159
160	if (p1 == p2)
161	return;
162	if (p1->word[0] == '(') {
163	for (p2 = p2->prev; p2->word[0] != ')'; p2 = p2->prev)
164	if (p2 == p1)
165	return;
166	if (p2 == p1->next)
167	return;
168	asyn0(p1->next, p2);
169	return;
170	}
171	ap = adrof1(p1->word, &aliases);
172	if (ap == 0)
173	return;
174	alhistp = p1->prev;
175	alhistt = p2;
176	alvec = ap->vec;
177	redid = lex(&alout);
178	alhistp = alhistt = 0;
179	alvec = 0;
180	if (seterr) {
181	freelex(&alout);
182	stderror(ERR_OLD);
183	}
184	if (p1->word[0] && eq(p1->word, alout.next->word)) {
185	Char *cp = alout.next->word;
186
187	alout.next->word = Strspl(STRQNULL, cp);
188	xfree((ptr_t) cp);
189	}
190	p1 = freenod(p1, redid ? p2 : p1->next);
191	if (alout.next != &alout) {
192	p1->next->prev = alout.prev->prev;
193	alout.prev->prev->next = p1->next;
194	alout.next->prev = p1;
195	p1->next = alout.next;
196	xfree((ptr_t) alout.prev->word);
197	xfree((ptr_t) (alout.prev));
198	}
199	reset(); /* throw! */
200	}
201
202	static struct wordent *
203	freenod(p1, p2)
204	register struct wordent p1, p2;
205	{
206	register struct wordent *retp = p1->prev;
207
208	while (p1 != p2) {
209	xfree((ptr_t) p1->word);
210	p1 = p1->next;
211	xfree((ptr_t) (p1->prev));
212	}
213	retp->next = p2;
214	p2->prev = retp;
215	return (retp);
216	}
217
218	#define PHERE 1
219	#define PIN 2
220	#define POUT 4
221	#define PDIAG 8
222
223	/*
224	* syntax
225	* empty
226	* syn0
227	*/
228	struct command *
229	syntax(p1, p2, flags)
230	register struct wordent p1, p2;
231	int flags;
232	{
233
234	while (p1 != p2)
235	if (any(";&\n", p1->word[0]))
236	p1 = p1->next;
237	else
238	return (syn0(p1, p2, flags));
239	return (0);
240	}
241
242	/*
243	* syn0
244	* syn1
245	* syn1 & syntax
246	*/
247	static struct command *
248	syn0(p1, p2, flags)
249	struct wordent p1, p2;
250	int flags;
251	{
252	register struct wordent *p;
253	register struct command t, t1;
254	int l;
255
256	l = 0;
257	for (p = p1; p != p2; p = p->next)
258	switch (p->word[0]) {
259
260	case '(':
261	l++;
262	continue;
263
264	case ')':
265	l--;
266	if (l < 0)
267	seterror(ERR_TOOMANYRP);
268	continue;
269
270	case '\|':
271	if (p->word[1] == '\|')
272	continue;
273	/* fall into ... */
274
275	case '>':
276	if (p->next != p2 && eq(p->next->word, STRand))
277	p = p->next;
278	continue;
279
280	case '&':
281	if (l != 0)
282	break;
283	if (p->word[1] == '&')
284	continue;
285	t1 = syn1(p1, p, flags);
286	if (t1->t_dtyp == NODE_LIST \|\|
287	t1->t_dtyp == NODE_AND \|\|
288	t1->t_dtyp == NODE_OR) {
289	t = (struct command ) xcalloc(1, sizeof(t));
290	t->t_dtyp = NODE_PAREN;
291	t->t_dflg = F_AMPERSAND \| F_NOINTERRUPT;
292	t->t_dspr = t1;
293	t1 = t;
294	}
295	else
296	t1->t_dflg \|= F_AMPERSAND \| F_NOINTERRUPT;
297	t = (struct command ) xcalloc(1, sizeof(t));
298	t->t_dtyp = NODE_LIST;
299	t->t_dflg = 0;
300	t->t_dcar = t1;
301	t->t_dcdr = syntax(p, p2, flags);
302	return (t);
303	}
304	if (l == 0)
305	return (syn1(p1, p2, flags));
306	seterror(ERR_TOOMANYLP);
307	return (0);
308	}
309
310	/*
311	* syn1
312	* syn1a
313	* syn1a ; syntax
314	*/
315	static struct command *
316	syn1(p1, p2, flags)
317	struct wordent p1, p2;
318	int flags;
319	{
320	register struct wordent *p;
321	register struct command *t;
322	int l;
323
324	l = 0;
325	for (p = p1; p != p2; p = p->next)
326	switch (p->word[0]) {
327
328	case '(':
329	l++;
330	continue;
331
332	case ')':
333	l--;
334	continue;
335
336	case ';':
337	case '\n':
338	if (l != 0)
339	break;
340	t = (struct command ) xcalloc(1, sizeof(t));
341	t->t_dtyp = NODE_LIST;
342	t->t_dcar = syn1a(p1, p, flags);
343	t->t_dcdr = syntax(p->next, p2, flags);
344	if (t->t_dcdr == 0)
345	t->t_dcdr = t->t_dcar, t->t_dcar = 0;
346	return (t);
347	}
348	return (syn1a(p1, p2, flags));
349	}
350
351	/*
352	* syn1a
353	* syn1b
354	* syn1b \|\| syn1a
355	*/
356	static struct command *
357	syn1a(p1, p2, flags)
358	struct wordent p1, p2;
359	int flags;
360	{
361	register struct wordent *p;
362	register struct command *t;
363	register int l = 0;
364
365	for (p = p1; p != p2; p = p->next)
366	switch (p->word[0]) {
367
368	case '(':
369	l++;
370	continue;
371
372	case ')':
373	l--;
374	continue;
375
376	case '\|':
377	if (p->word[1] != '\|')
378	continue;
379	if (l == 0) {
380	t = (struct command ) xcalloc(1, sizeof(t));
381	t->t_dtyp = NODE_OR;
382	t->t_dcar = syn1b(p1, p, flags);
383	t->t_dcdr = syn1a(p->next, p2, flags);
384	t->t_dflg = 0;
385	return (t);
386	}
387	continue;
388	}
389	return (syn1b(p1, p2, flags));
390	}
391
392	/*
393	* syn1b
394	* syn2
395	* syn2 && syn1b
396	*/
397	static struct command *
398	syn1b(p1, p2, flags)
399	struct wordent p1, p2;
400	int flags;
401	{
402	register struct wordent *p;
403	register struct command *t;
404	register int l = 0;
405
406	for (p = p1; p != p2; p = p->next)
407	switch (p->word[0]) {
408
409	case '(':
410	l++;
411	continue;
412
413	case ')':
414	l--;
415	continue;
416
417	case '&':
418	if (p->word[1] == '&' && l == 0) {
419	t = (struct command ) xcalloc(1, sizeof(t));
420	t->t_dtyp = NODE_AND;
421	t->t_dcar = syn2(p1, p, flags);
422	t->t_dcdr = syn1b(p->next, p2, flags);
423	t->t_dflg = 0;
424	return (t);
425	}
426	continue;
427	}
428	return (syn2(p1, p2, flags));
429	}
430
431	/*
432	* syn2
433	* syn3
434	* syn3 \| syn2
435	* syn3 \|& syn2
436	*/
437	static struct command *
438	syn2(p1, p2, flags)
439	struct wordent p1, p2;
440	int flags;
441	{
442	register struct wordent p, pn;
443	register struct command *t;
444	register int l = 0;
445	int f;
446
447	for (p = p1; p != p2; p = p->next)
448	switch (p->word[0]) {
449
450	case '(':
451	l++;
452	continue;
453
454	case ')':
455	l--;
456	continue;
457
458	case '\|':
459	if (l != 0)
460	continue;
461	t = (struct command ) xcalloc(1, sizeof(t));
462	f = flags \| POUT;
463	pn = p->next;
464	if (pn != p2 && pn->word[0] == '&') {
465	f \|= PDIAG;
466	t->t_dflg \|= F_STDERR;
467	}
468	t->t_dtyp = NODE_PIPE;
469	t->t_dcar = syn3(p1, p, f);
470	if (pn != p2 && pn->word[0] == '&')
471	p = pn;
472	t->t_dcdr = syn2(p->next, p2, flags \| PIN);
473	return (t);
474	}
475	return (syn3(p1, p2, flags));
476	}
477
478	static char RELPAR[] = {'<', '>', '(', ')', '\0'};
479
480	/*
481	* syn3
482	* ( syn0 ) [ < in ] [ > out ]
483	* word word* [ < in ] [ > out ]
484	* KEYWORD ( word* ) word* [ < in ] [ > out ]
485	*
486	* KEYWORD = (@ exit foreach if set switch test while)
487	*/
488	static struct command *
489	syn3(p1, p2, flags)
490	struct wordent p1, p2;
491	int flags;
492	{
493	register struct wordent *p;
494	struct wordent lp, rp;
495	register struct command *t;
496	register int l;
497	Char **av;
498	int n, c;
499	bool specp = 0;
500
501	if (p1 != p2) {
502	p = p1;
503	again:
504	switch (srchx(p->word)) {
505
506	case T_ELSE:
507	p = p->next;
508	if (p != p2)
509	goto again;
510	break;
511
512	case T_EXIT:
513	case T_FOREACH:
514	case T_IF:
515	case T_LET:
516	case T_SET:
517	case T_SWITCH:
518	case T_WHILE:
519	specp = 1;
520	break;
521	}
522	}
523	n = 0;
524	l = 0;
525	for (p = p1; p != p2; p = p->next)
526	switch (p->word[0]) {
527
528	case '(':
529	if (specp)
530	n++;
531	l++;
532	continue;
533
534	case ')':
535	if (specp)
536	n++;
537	l--;
538	continue;
539
540	case '>':
541	case '<':
542	if (l != 0) {
543	if (specp)
544	n++;
545	continue;
546	}
547	if (p->next == p2)
548	continue;
549	if (any(RELPAR, p->next->word[0]))
550	continue;
551	n--;
552	continue;
553
554	default:
555	if (!specp && l != 0)
556	continue;
557	n++;
558	continue;
559	}
560	if (n < 0)
561	n = 0;
562	t = (struct command ) xcalloc(1, sizeof(t));
563	av = (Char ) xcalloc((size_t) (n + 1), sizeof(Char ));
564	t->t_dcom = av;
565	n = 0;
566	if (p2->word[0] == ')')
567	t->t_dflg = F_NOFORK;
568	lp = 0;
569	rp = 0;
570	l = 0;
571	for (p = p1; p != p2; p = p->next) {
572	c = p->word[0];
573	switch (c) {
574
575	case '(':
576	if (l == 0) {
577	if (lp != 0 && !specp)
578	seterror(ERR_BADPLP);
579	lp = p->next;
580	}
581	l++;
582	goto savep;
583
584	case ')':
585	l--;
586	if (l == 0)
587	rp = p;
588	goto savep;
589
590	case '>':
591	if (l != 0)
592	goto savep;
593	if (p->word[1] == '>')
594	t->t_dflg \|= F_APPEND;
595	if (p->next != p2 && eq(p->next->word, STRand)) {
596	t->t_dflg \|= F_STDERR, p = p->next;
597	if (flags & (POUT \| PDIAG)) {
598	seterror(ERR_OUTRED);
599	continue;
600	}
601	}
602	if (p->next != p2 && eq(p->next->word, STRbang))
603	t->t_dflg \|= F_OVERWRITE, p = p->next;
604	if (p->next == p2) {
605	seterror(ERR_MISRED);
606	continue;
607	}
608	p = p->next;
609	if (any(RELPAR, p->word[0])) {
610	seterror(ERR_MISRED);
611	continue;
612	}
613	if ((flags & POUT) && (flags & PDIAG) == 0 \|\| t->t_drit)
614	seterror(ERR_OUTRED);
615	else
616	t->t_drit = Strsave(p->word);
617	continue;
618
619	case '<':
620	if (l != 0)
621	goto savep;
622	if (p->word[1] == '<')
623	t->t_dflg \|= F_READ;
624	if (p->next == p2) {
625	seterror(ERR_MISRED);
626	continue;
627	}
628	p = p->next;
629	if (any(RELPAR, p->word[0])) {
630	seterror(ERR_MISRED);
631	continue;
632	}
633	if ((flags & PHERE) && (t->t_dflg & F_READ))
634	seterror(ERR_REDPAR);
635	else if ((flags & PIN) \|\| t->t_dlef)
636	seterror(ERR_INRED);
637	else
638	t->t_dlef = Strsave(p->word);
639	continue;
640
641	savep:
642	if (!specp)
643	continue;
644	default:
645	if (l != 0 && !specp)
646	continue;
647	if (seterr == 0)
648	av[n] = Strsave(p->word);
649	n++;
650	continue;
651	}
652	}
653	if (lp != 0 && !specp) {
654	if (n != 0)
655	seterror(ERR_BADPLPS);
656	t->t_dtyp = NODE_PAREN;
657	t->t_dspr = syn0(lp, rp, PHERE);
658	}
659	else {
660	if (n == 0)
661	seterror(ERR_NULLCOM);
662	t->t_dtyp = NODE_COMMAND;
663	}
664	return (t);
665	}
666
667	void
668	freesyn(t)
669	register struct command *t;
670	{
671	register Char **v;
672
673	if (t == 0)
674	return;
675	switch (t->t_dtyp) {
676
677	case NODE_COMMAND:
678	for (v = t->t_dcom; *v; v++)
679	xfree((ptr_t) * v);
680	xfree((ptr_t) (t->t_dcom));
681	xfree((ptr_t) t->t_dlef);
682	xfree((ptr_t) t->t_drit);
683	break;
684	case NODE_PAREN:
685	freesyn(t->t_dspr);
686	xfree((ptr_t) t->t_dlef);
687	xfree((ptr_t) t->t_drit);
688	break;
689
690	case NODE_AND:
691	case NODE_OR:
692	case NODE_PIPE:
693	case NODE_LIST:
694	freesyn(t->t_dcar), freesyn(t->t_dcdr);
695	break;
696	}
697	xfree((ptr_t) t);
698	}