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

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley Software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char *sccsid = "@(#)parse.c	5.3 (Berkeley) %G%";
#endif

#include "sh.h"

/*
 * C shell
 */

/*
 * 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.
 */
alias(lex)
	register struct wordent *lex;
{
	int aleft = 21;
	jmp_buf osetexit;

	getexit(osetexit);
	setexit();
	if (haderr) {
		resexit(osetexit);
		reset();
	}
	if (--aleft == 0)
		error("Alias loop");
	asyntax(lex->next, lex);
	resexit(osetexit);
}

asyntax(p1, p2)
	register struct wordent *p1, *p2;
{

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

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)
				error("Too many )'s");
			continue;

		case '>':
			if (p->next != p2 && eq(p->next->word, "&"))
				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);
}

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 (err) {
		freelex(&alout);
		error(err);
	}
	if (p1->word[0] && eq(p1->word, alout.next->word)) {
		char *cp = alout.next->word;

		alout.next->word = strspl("\200", cp);
		XFREE(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(alout.prev->word)
		XFREE((char *)alout.prev)
	}
	reset();		/* throw! */
}

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

	while (p1 != p2) {
		XFREE(p1->word)
		p1 = p1->next;
		XFREE((char *)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(p1->word[0], ";&\n"))
			p1 = p1->next;
		else
			return (syn0(p1, p2, flags));
	return (0);
}

/*
 * syn0
 *	syn1
 *	syn1 & syntax
 */
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)
				seterr("Too many )'s");
			continue;

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

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

		case '&':
			if (l != 0)
				break;
			if (p->word[1] == '&')
				continue;
			t1 = syn1(p1, p, flags);
    			if (t1->t_dtyp == TLST ||
    			    t1->t_dtyp == TAND ||
    			    t1->t_dtyp == TOR) {
				t = (struct command *) calloc(1, sizeof (*t));
				t->t_dtyp = TPAR;
				t->t_dflg = FAND|FINT;
				t->t_dspr = t1;
				t1 = t;
			} else
				t1->t_dflg |= FAND|FINT;
			t = (struct command *) calloc(1, sizeof (*t));
			t->t_dtyp = TLST;
			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));
	seterr("Too many ('s");
	return (0);
}

/*
 * syn1
 *	syn1a
 *	syn1a ; syntax
 */
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 *) calloc(1, sizeof (*t));
			t->t_dtyp = TLST;
			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
 */
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 *) calloc(1, sizeof (*t));
				t->t_dtyp = TOR;
				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
 */
struct command *
syn1b(p1, p2, flags)
	struct wordent *p1, *p2;
	int flags;
{
	register struct wordent *p;
	register struct command *t;
	register int l = 0;

	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 *) calloc(1, sizeof (*t));
				t->t_dtyp = TAND;
				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
 */
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 *) calloc(1, sizeof (*t));
			f = flags | POUT;
			pn = p->next;
			if (pn != p2 && pn->word[0] == '&') {
				f |= PDIAG;
				t->t_dflg |= FDIAG;
			}
			t->t_dtyp = TFIL;
			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));
}

char	*RELPAR =	"<>()";

/*
 * syn3
 *	( syn0 ) [ < in  ] [ > out ]
 *	word word* [ < in ] [ > out ]
 *	KEYWORD ( word* ) word* [ < in ] [ > out ]
 *
 *	KEYWORD = (@ exit foreach if set switch test while)
 */
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 ZELSE:
			p = p->next;
			if (p != p2)
				goto again;
			break;

		case ZEXIT:
		case ZFOREACH:
		case ZIF:
		case ZLET:
		case ZSET:
		case ZSWITCH:
		case ZWHILE:
			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(p->next->word[0], RELPAR))
				continue;
			n--;
			continue;

		default:
			if (!specp && l != 0)
				continue;
			n++;
			continue;
		}
	if (n < 0)
		n = 0;
	t = (struct command *) calloc(1, sizeof (*t));
	av = (char **) calloc((unsigned) (n + 1), sizeof (char **));
	t->t_dcom = av;
	n = 0;
	if (p2->word[0] == ')')
		t->t_dflg = FPAR;
	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)
					seterr("Badly placed (");
				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 |= FCAT;
			if (p->next != p2 && eq(p->next->word, "&")) {
				t->t_dflg |= FDIAG, p = p->next;
				if (flags & (POUT|PDIAG))
					goto badout;
			}
			if (p->next != p2 && eq(p->next->word, "!"))
				t->t_dflg |= FANY, p = p->next;
			if (p->next == p2) {
missfile:
				seterr("Missing name for redirect");
				continue;
			}
			p = p->next;
			if (any(p->word[0], RELPAR))
				goto missfile;
			if ((flags & POUT) && (flags & PDIAG) == 0 || t->t_drit)
badout:
				seterr("Ambiguous output redirect");
			else
				t->t_drit = savestr(p->word);
			continue;

		case '<':
			if (l != 0)
				goto savep;
			if (p->word[1] == '<')
				t->t_dflg |= FHERE;
			if (p->next == p2)
				goto missfile;
			p = p->next;
			if (any(p->word[0], RELPAR))
				goto missfile;
			if ((flags & PHERE) && (t->t_dflg & FHERE))
				seterr("Can't << within ()'s");
			else if ((flags & PIN) || t->t_dlef)
				seterr("Ambiguous input redirect");
			else
				t->t_dlef = savestr(p->word);
			continue;

savep:
			if (!specp)
				continue;
		default:
			if (l != 0 && !specp)
				continue;
			if (err == 0)
				av[n] = savestr(p->word);
			n++;
			continue;
		}
	}
	if (lp != 0 && !specp) {
		if (n != 0)
			seterr("Badly placed ()'s");
		t->t_dtyp = TPAR;
		t->t_dspr = syn0(lp, rp, PHERE);
	} else {
		if (n == 0)
			seterr("Invalid null command");
		t->t_dtyp = TCOM;
	}
	return (t);
}

freesyn(t)
	register struct command *t;
{
	register char **v;

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

	case TCOM:
		for (v = t->t_dcom; *v; v++)
			XFREE(*v)
		XFREE((char *)t->t_dcom)
		goto lr;

	case TPAR:
		freesyn(t->t_dspr);
		/* fall into ... */

lr:
		XFREE(t->t_dlef)
		XFREE(t->t_drit)
		break;

	case TAND:
	case TOR:
	case TFIL:
	case TLST:
		freesyn(t->t_dcar), freesyn(t->t_dcdr);
		break;
	}
	XFREE((char *)t)
}
Commit	Line	Data
b79f4fa9 DF	1	/*
b79f4fa9 DF	2	* Copyright (c) 1980 Regents of the University of California.
094e80ed	3	* All rights reserved. The Berkeley Software License Agreement
b79f4fa9 DF	4	* specifies the terms and conditions for redistribution.
	5	*/
	6
35371dec	7	#ifndef lint
c741e0c0	8	static char *sccsid = "@(#)parse.c 5.3 (Berkeley) %G%";
094e80ed	9	#endif
0d061c44 BJ	10
	11	#include "sh.h"
	12
	13	/*
	14	* C shell
	15	*/
	16
	17	/*
	18	* Perform aliasing on the word list lex
	19	* Do a (very rudimentary) parse to separate into commands.
	20	* If word 0 of a command has an alias, do it.
	21	* Repeat a maximum of 20 times.
	22	*/
	23	alias(lex)
	24	register struct wordent *lex;
	25	{
	26	int aleft = 21;
	27	jmp_buf osetexit;
	28
	29	getexit(osetexit);
	30	setexit();
	31	if (haderr) {
	32	resexit(osetexit);
	33	reset();
	34	}
	35	if (--aleft == 0)
	36	error("Alias loop");
	37	asyntax(lex->next, lex);
	38	resexit(osetexit);
	39	}
	40
	41	asyntax(p1, p2)
	42	register struct wordent p1, p2;
	43	{
	44
	45	while (p1 != p2)
	46	if (any(p1->word[0], ";&\n"))
	47	p1 = p1->next;
	48	else {
	49	asyn0(p1, p2);
	50	return;
	51	}
	52	}
	53
	54	asyn0(p1, p2)
	55	struct wordent *p1;
	56	register struct wordent *p2;
	57	{
	58	register struct wordent *p;
	59	register int l = 0;
	60
	61	for (p = p1; p != p2; p = p->next)
	62	switch (p->word[0]) {
	63
	64	case '(':
	65	l++;
	66	continue;
	67
	68	case ')':
	69	l--;
	70	if (l < 0)
	71	error("Too many )'s");
	72	continue;
	73
74	case '>':
75	if (p->next != p2 && eq(p->next->word, "&"))
76	p = p->next;
77	continue;
78
79	case '&':
80	case '\|':
81	case ';':
82	case '\n':
83	if (l != 0)
84	continue;
85	asyn3(p1, p);
86	asyntax(p->next, p2);
87	return;
88	}
89	if (l == 0)
90	asyn3(p1, p2);
91	}
92
93	asyn3(p1, p2)
94	struct wordent *p1;
95	register struct wordent *p2;
96	{
97	register struct varent *ap;
98	struct wordent alout;
99	register bool redid;
100
101	if (p1 == p2)
102	return;
103	if (p1->word[0] == '(') {
104	for (p2 = p2->prev; p2->word[0] != ')'; p2 = p2->prev)
105	if (p2 == p1)
106	return;
107	if (p2 == p1->next)
108	return;
109	asyn0(p1->next, p2);
110	return;
111	}
112	ap = adrof1(p1->word, &aliases);
113	if (ap == 0)
114	return;
115	alhistp = p1->prev;
116	alhistt = p2;
117	alvec = ap->vec;
118	redid = lex(&alout);
119	alhistp = alhistt = 0;
120	alvec = 0;
121	if (err) {
122	freelex(&alout);
123	error(err);
124	}
125	if (p1->word[0] && eq(p1->word, alout.next->word)) {
126	char *cp = alout.next->word;
127
128	alout.next->word = strspl("\200", cp);
35371dec	129	XFREE(cp)
0d061c44 BJ	130	}
	131	p1 = freenod(p1, redid ? p2 : p1->next);
	132	if (alout.next != &alout) {
	133	p1->next->prev = alout.prev->prev;
	134	alout.prev->prev->next = p1->next;
	135	alout.next->prev = p1;
	136	p1->next = alout.next;
35371dec EW	137	XFREE(alout.prev->word)
35371dec EW	138	XFREE((char *)alout.prev)
0d061c44 BJ	139	}
	140	reset(); /* throw! */
	141	}
	142
	143	struct wordent *
	144	freenod(p1, p2)
	145	register struct wordent p1, p2;
	146	{
	147	register struct wordent *retp = p1->prev;
	148
	149	while (p1 != p2) {
35371dec	150	XFREE(p1->word)
0d061c44	151	p1 = p1->next;
35371dec	152	XFREE((char *)p1->prev)
0d061c44 BJ	153	}
	154	retp->next = p2;
	155	p2->prev = retp;
	156	return (retp);
	157	}
	158
	159	#define PHERE 1
	160	#define PIN 2
	161	#define POUT 4
	162	#define PDIAG 8
	163
	164	/*
	165	* syntax
	166	* empty
	167	* syn0
	168	*/
	169	struct command *
	170	syntax(p1, p2, flags)
	171	register struct wordent p1, p2;
	172	int flags;
	173	{
	174
	175	while (p1 != p2)
	176	if (any(p1->word[0], ";&\n"))
	177	p1 = p1->next;
	178	else
	179	return (syn0(p1, p2, flags));
	180	return (0);
	181	}
	182
	183	/*
	184	* syn0
	185	* syn1
	186	* syn1 & syntax
	187	*/
	188	struct command *
	189	syn0(p1, p2, flags)
	190	struct wordent p1, p2;
	191	int flags;
	192	{
	193	register struct wordent *p;
	194	register struct command t, t1;
	195	int l;
	196
	197	l = 0;
	198	for (p = p1; p != p2; p = p->next)
	199	switch (p->word[0]) {
	200
	201	case '(':
	202	l++;
	203	continue;
	204
	205	case ')':
	206	l--;
	207	if (l < 0)
	208	seterr("Too many )'s");
	209	continue;
	210
	211	case '\|':
	212	if (p->word[1] == '\|')
	213	continue;
	214	/* fall into ... */
	215
	216	case '>':
217	if (p->next != p2 && eq(p->next->word, "&"))
218	p = p->next;
219	continue;
220
221	case '&':
222	if (l != 0)
223	break;
224	if (p->word[1] == '&')
225	continue;
226	t1 = syn1(p1, p, flags);
c741e0c0 JL	227	if (t1->t_dtyp == TLST \|\|
	228	t1->t_dtyp == TAND \|\|
	229	t1->t_dtyp == TOR) {
0d061c44 BJ	230	t = (struct command ) calloc(1, sizeof (t));
	231	t->t_dtyp = TPAR;
	232	t->t_dflg = FAND\|FINT;
	233	t->t_dspr = t1;
	234	t1 = t;
	235	} else
	236	t1->t_dflg \|= FAND\|FINT;
	237	t = (struct command ) calloc(1, sizeof (t));
	238	t->t_dtyp = TLST;
	239	t->t_dflg = 0;
	240	t->t_dcar = t1;
	241	t->t_dcdr = syntax(p, p2, flags);
	242	return(t);
	243	}
	244	if (l == 0)
	245	return (syn1(p1, p2, flags));
	246	seterr("Too many ('s");
	247	return (0);
	248	}
	249
	250	/*
	251	* syn1
	252	* syn1a
	253	* syn1a ; syntax
	254	*/
	255	struct command *
	256	syn1(p1, p2, flags)
	257	struct wordent p1, p2;
	258	int flags;
	259	{
	260	register struct wordent *p;
	261	register struct command *t;
	262	int l;
	263
	264	l = 0;
	265	for (p = p1; p != p2; p = p->next)
	266	switch (p->word[0]) {
	267
	268	case '(':
	269	l++;
	270	continue;
	271
	272	case ')':
	273	l--;
	274	continue;
	275
	276	case ';':
	277	case '\n':
	278	if (l != 0)
	279	break;
	280	t = (struct command ) calloc(1, sizeof (t));
	281	t->t_dtyp = TLST;
	282	t->t_dcar = syn1a(p1, p, flags);
	283	t->t_dcdr = syntax(p->next, p2, flags);
	284	if (t->t_dcdr == 0)
	285	t->t_dcdr = t->t_dcar, t->t_dcar = 0;
	286	return (t);
	287	}
	288	return (syn1a(p1, p2, flags));
	289	}
	290
	291	/*
	292	* syn1a
	293	* syn1b
294	* syn1b \|\| syn1a
295	*/
296	struct command *
297	syn1a(p1, p2, flags)
298	struct wordent p1, p2;
299	int flags;
300	{
301	register struct wordent *p;
302	register struct command *t;
303	register int l = 0;
304
305	for (p = p1; p != p2; p = p->next)
306	switch (p->word[0]) {
307
308	case '(':
309	l++;
310	continue;
311
312	case ')':
313	l--;
314	continue;
315
316	case '\|':
317	if (p->word[1] != '\|')
318	continue;
319	if (l == 0) {
320	t = (struct command ) calloc(1, sizeof (t));
321	t->t_dtyp = TOR;
322	t->t_dcar = syn1b(p1, p, flags);
323	t->t_dcdr = syn1a(p->next, p2, flags);
324	t->t_dflg = 0;
325	return (t);
326	}
327	continue;
328	}
329	return (syn1b(p1, p2, flags));
330	}
331
332	/*
333	* syn1b
334	* syn2
335	* syn2 && syn1b
336	*/
337	struct command *
338	syn1b(p1, p2, flags)
339	struct wordent p1, p2;
340	int flags;
341	{
342	register struct wordent *p;
343	register struct command *t;
344	register int l = 0;
345
346	l = 0;
347	for (p = p1; p != p2; p = p->next)
348	switch (p->word[0]) {
349
350	case '(':
351	l++;
352	continue;
353
354	case ')':
355	l--;
356	continue;
357
358	case '&':
359	if (p->word[1] == '&' && l == 0) {
360	t = (struct command ) calloc(1, sizeof (t));
361	t->t_dtyp = TAND;
362	t->t_dcar = syn2(p1, p, flags);
363	t->t_dcdr = syn1b(p->next, p2, flags);
364	t->t_dflg = 0;
365	return (t);
366	}
367	continue;
368	}
369	return (syn2(p1, p2, flags));
370	}
371
372	/*
373	* syn2
374	* syn3
375	* syn3 \| syn2
376	* syn3 \|& syn2
377	*/
378	struct command *
379	syn2(p1, p2, flags)
380	struct wordent p1, p2;
381	int flags;
382	{
383	register struct wordent p, pn;
384	register struct command *t;
385	register int l = 0;
386	int f;
387
388	for (p = p1; p != p2; p = p->next)
389	switch (p->word[0]) {
390
391	case '(':
392	l++;
393	continue;
394
395	case ')':
396	l--;
397	continue;
398
399	case '\|':
400	if (l != 0)
401	continue;
402	t = (struct command ) calloc(1, sizeof (t));
403	f = flags \| POUT;
404	pn = p->next;
405	if (pn != p2 && pn->word[0] == '&') {
406	f \|= PDIAG;
407	t->t_dflg \|= FDIAG;
408	}
409	t->t_dtyp = TFIL;
410	t->t_dcar = syn3(p1, p, f);
411	if (pn != p2 && pn->word[0] == '&')
412	p = pn;
413	t->t_dcdr = syn2(p->next, p2, flags \| PIN);
414	return (t);
415	}
416	return (syn3(p1, p2, flags));
417	}
418
419	char *RELPAR = "<>()";
420
421	/*
422	* syn3
423	* ( syn0 ) [ < in ] [ > out ]
424	* word word* [ < in ] [ > out ]
425	* KEYWORD ( word* ) word* [ < in ] [ > out ]
426	*
427	* KEYWORD = (@ exit foreach if set switch test while)
428	*/
429	struct command *
430	syn3(p1, p2, flags)
431	struct wordent p1, p2;
432	int flags;
433	{
434	register struct wordent *p;
435	struct wordent lp, rp;
436	register struct command *t;
437	register int l;
438	char **av;
439	int n, c;
440	bool specp = 0;
441
442	if (p1 != p2) {
443	p = p1;
444	again:
445	switch (srchx(p->word)) {
446
447	case ZELSE:
448	p = p->next;
449	if (p != p2)
450	goto again;
451	break;
452
453	case ZEXIT:
454	case ZFOREACH:
455	case ZIF:
456	case ZLET:
457	case ZSET:
458	case ZSWITCH:
459	case ZWHILE:
460	specp = 1;
461	break;
462	}
463	}
464	n = 0;
465	l = 0;
466	for (p = p1; p != p2; p = p->next)
467	switch (p->word[0]) {
468
469	case '(':
470	if (specp)
471	n++;
472	l++;
473	continue;
474
475	case ')':
476	if (specp)
477	n++;
478	l--;
479	continue;
480
481	case '>':
482	case '<':
483	if (l != 0) {
484	if (specp)
485	n++;
486	continue;
487	}
488	if (p->next == p2)
489	continue;
490	if (any(p->next->word[0], RELPAR))
491	continue;
492	n--;
493	continue;
494
495	default:
496	if (!specp && l != 0)
497	continue;
498	n++;
499	continue;
500	}
501	if (n < 0)
502	n = 0;
503	t = (struct command ) calloc(1, sizeof (t));
35371dec	504	av = (char ) calloc((unsigned) (n + 1), sizeof (char ));
0d061c44 BJ	505	t->t_dcom = av;
	506	n = 0;
	507	if (p2->word[0] == ')')
	508	t->t_dflg = FPAR;
	509	lp = 0;
	510	rp = 0;
	511	l = 0;
	512	for (p = p1; p != p2; p = p->next) {
	513	c = p->word[0];
	514	switch (c) {
	515
	516	case '(':
	517	if (l == 0) {
	518	if (lp != 0 && !specp)
	519	seterr("Badly placed (");
	520	lp = p->next;
	521	}
	522	l++;
	523	goto savep;
	524
	525	case ')':
	526	l--;
	527	if (l == 0)
	528	rp = p;
	529	goto savep;
	530
	531	case '>':
	532	if (l != 0)
	533	goto savep;
	534	if (p->word[1] == '>')
	535	t->t_dflg \|= FCAT;
	536	if (p->next != p2 && eq(p->next->word, "&")) {
	537	t->t_dflg \|= FDIAG, p = p->next;
	538	if (flags & (POUT\|PDIAG))
	539	goto badout;
	540	}
	541	if (p->next != p2 && eq(p->next->word, "!"))
	542	t->t_dflg \|= FANY, p = p->next;
	543	if (p->next == p2) {
	544	missfile:
	545	seterr("Missing name for redirect");
	546	continue;
	547	}
	548	p = p->next;
	549	if (any(p->word[0], RELPAR))
	550	goto missfile;
	551	if ((flags & POUT) && (flags & PDIAG) == 0 \|\| t->t_drit)
	552	badout:
	553	seterr("Ambiguous output redirect");
	554	else
	555	t->t_drit = savestr(p->word);
	556	continue;
	557
	558	case '<':
	559	if (l != 0)
	560	goto savep;
	561	if (p->word[1] == '<')
	562	t->t_dflg \|= FHERE;
	563	if (p->next == p2)
	564	goto missfile;
	565	p = p->next;
	566	if (any(p->word[0], RELPAR))
	567	goto missfile;
	568	if ((flags & PHERE) && (t->t_dflg & FHERE))
569	seterr("Can't << within ()'s");
570	else if ((flags & PIN) \|\| t->t_dlef)
571	seterr("Ambiguous input redirect");
572	else
573	t->t_dlef = savestr(p->word);
574	continue;
575
576	savep:
577	if (!specp)
578	continue;
579	default:
580	if (l != 0 && !specp)
581	continue;
582	if (err == 0)
583	av[n] = savestr(p->word);
584	n++;
585	continue;
586	}
587	}
588	if (lp != 0 && !specp) {
589	if (n != 0)
590	seterr("Badly placed ()'s");
591	t->t_dtyp = TPAR;
592	t->t_dspr = syn0(lp, rp, PHERE);
593	} else {
594	if (n == 0)
595	seterr("Invalid null command");
596	t->t_dtyp = TCOM;
597	}
598	return (t);
599	}
600
601	freesyn(t)
602	register struct command *t;
603	{
604	register char **v;
605
606	if (t == 0)
607	return;
608	switch (t->t_dtyp) {
609
610	case TCOM:
611	for (v = t->t_dcom; *v; v++)
35371dec EW	612	XFREE(*v)
35371dec EW	613	XFREE((char *)t->t_dcom)
0d061c44 BJ	614	goto lr;
	615
	616	case TPAR:
	617	freesyn(t->t_dspr);
	618	/* fall into ... */
	619
	620	lr:
35371dec EW	621	XFREE(t->t_dlef)
35371dec EW	622	XFREE(t->t_drit)
0d061c44 BJ	623	break;
	624
	625	case TAND:
	626	case TOR:
	627	case TFIL:
	628	case TLST:
	629	freesyn(t->t_dcar), freesyn(t->t_dcdr);
	630	break;
	631	}
35371dec	632	XFREE((char *)t)
0d061c44	633	}