[unix-history] / usr / src / bin / csh / exp.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 = "@(#)exp.c	5.3 (Berkeley) %G%";
#endif

#include "sh.h"

/*
 * C shell
 */

#define IGNORE	1	/* in ignore, it means to ignore value, just parse */
#define NOGLOB	2	/* in ignore, it means not to globone */

#define	ADDOP	1
#define	MULOP	2
#define	EQOP	4
#define	RELOP	8
#define	RESTOP	16
#define	ANYOP	31

#define	EQEQ	1
#define	GTR	2
#define	LSS	4
#define	NOTEQ	6
#define EQMATCH 7
#define NOTEQMATCH 8

exp(vp)
	register char ***vp;
{

	return (exp0(vp, 0));
}

exp0(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register int p1 = exp1(vp, ignore);
	
#ifdef EDEBUG
	etraci("exp0 p1", p1, vp);
#endif
	if (**vp && eq(**vp, "||")) {
		register int p2;

		(*vp)++;
		p2 = exp0(vp, (ignore&IGNORE) || p1);
#ifdef EDEBUG
		etraci("exp0 p2", p2, vp);
#endif
		return (p1 || p2);
	}
	return (p1);
}

exp1(vp, ignore)
	register char ***vp;
{
	register int p1 = exp2(vp, ignore);

#ifdef EDEBUG
	etraci("exp1 p1", p1, vp);
#endif
	if (**vp && eq(**vp, "&&")) {
		register int p2;

		(*vp)++;
		p2 = exp1(vp, (ignore&IGNORE) || !p1);
#ifdef EDEBUG
		etraci("exp1 p2", p2, vp);
#endif
		return (p1 && p2);
	}
	return (p1);
}

exp2(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register int p1 = exp2a(vp, ignore);

#ifdef EDEBUG
	etraci("exp3 p1", p1, vp);
#endif
	if (**vp && eq(**vp, "|")) {
		register int p2;

		(*vp)++;
		p2 = exp2(vp, ignore);
#ifdef EDEBUG
		etraci("exp3 p2", p2, vp);
#endif
		return (p1 | p2);
	}
	return (p1);
}

exp2a(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register int p1 = exp2b(vp, ignore);

#ifdef EDEBUG
	etraci("exp2a p1", p1, vp);
#endif
	if (**vp && eq(**vp, "^")) {
		register int p2;

		(*vp)++;
		p2 = exp2a(vp, ignore);
#ifdef EDEBUG
		etraci("exp2a p2", p2, vp);
#endif
		return (p1 ^ p2);
	}
	return (p1);
}

exp2b(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register int p1 = exp2c(vp, ignore);

#ifdef EDEBUG
	etraci("exp2b p1", p1, vp);
#endif
	if (**vp && eq(**vp, "&")) {
		register int p2;

		(*vp)++;
		p2 = exp2b(vp, ignore);
#ifdef EDEBUG
		etraci("exp2b p2", p2, vp);
#endif
		return (p1 & p2);
	}
	return (p1);
}

exp2c(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register char *p1 = exp3(vp, ignore);
	register char *p2;
	register int i;

#ifdef EDEBUG
	etracc("exp2c p1", p1, vp);
#endif
	if (i = isa(**vp, EQOP)) {
		(*vp)++;
		if (i == EQMATCH || i == NOTEQMATCH)
			ignore |= NOGLOB;
		p2 = exp3(vp, ignore);
#ifdef EDEBUG
		etracc("exp2c p2", p2, vp);
#endif
		if (!(ignore&IGNORE)) switch (i) {

		case EQEQ:
			i = eq(p1, p2);
			break;

		case NOTEQ:
			i = !eq(p1, p2);
			break;

		case EQMATCH:
			i = Gmatch(p1, p2);
			break;

		case NOTEQMATCH:
			i = !Gmatch(p1, p2);
			break;
		}
		xfree(p1), xfree(p2);
		return (i);
	}
	i = egetn(p1);
	xfree(p1);
	return (i);
}

char *
exp3(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register char *p1, *p2;
	register int i;

	p1 = exp3a(vp, ignore);
#ifdef EDEBUG
	etracc("exp3 p1", p1, vp);
#endif
	if (i = isa(**vp, RELOP)) {
		(*vp)++;
		if (**vp && eq(**vp, "="))
			i |= 1, (*vp)++;
		p2 = exp3(vp, ignore);
#ifdef EDEBUG
		etracc("exp3 p2", p2, vp);
#endif
		if (!(ignore&IGNORE)) switch (i) {

		case GTR:
			i = egetn(p1) > egetn(p2);
			break;

		case GTR|1:
			i = egetn(p1) >= egetn(p2);
			break;

		case LSS:
			i = egetn(p1) < egetn(p2);
			break;

		case LSS|1:
			i = egetn(p1) <= egetn(p2);
			break;
		}
		xfree(p1), xfree(p2);
		return (putn(i));
	}
	return (p1);
}

char *
exp3a(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register char *p1, *p2, *op;
	register int i;

	p1 = exp4(vp, ignore);
#ifdef EDEBUG
	etracc("exp3a p1", p1, vp);
#endif
	op = **vp;
	if (op && any(op[0], "<>") && op[0] == op[1]) {
		(*vp)++;
		p2 = exp3a(vp, ignore);
#ifdef EDEBUG
		etracc("exp3a p2", p2, vp);
#endif
		if (op[0] == '<')
			i = egetn(p1) << egetn(p2);
		else
			i = egetn(p1) >> egetn(p2);
		xfree(p1), xfree(p2);
		return (putn(i));
	}
	return (p1);
}

char *
exp4(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register char *p1, *p2;
	register int i = 0;

	p1 = exp5(vp, ignore);
#ifdef EDEBUG
	etracc("exp4 p1", p1, vp);
#endif
	if (isa(**vp, ADDOP)) {
		register char *op = *(*vp)++;

		p2 = exp4(vp, ignore);
#ifdef EDEBUG
		etracc("exp4 p2", p2, vp);
#endif
		if (!(ignore&IGNORE)) switch (op[0]) {

		case '+':
			i = egetn(p1) + egetn(p2);
			break;

		case '-':
			i = egetn(p1) - egetn(p2);
			break;
		}
		xfree(p1), xfree(p2);
		return (putn(i));
	}
	return (p1);
}

char *
exp5(vp, ignore)
	register char ***vp;
	bool ignore;
{
	register char *p1, *p2;
	register int i = 0;

	p1 = exp6(vp, ignore);
#ifdef EDEBUG
	etracc("exp5 p1", p1, vp);
#endif
	if (isa(**vp, MULOP)) {
		register char *op = *(*vp)++;

		p2 = exp5(vp, ignore);
#ifdef EDEBUG
		etracc("exp5 p2", p2, vp);
#endif
		if (!(ignore&IGNORE)) switch (op[0]) {

		case '*':
			i = egetn(p1) * egetn(p2);
			break;

		case '/':
			i = egetn(p2);
			if (i == 0)
				error("Divide by 0");
			i = egetn(p1) / i;
			break;

		case '%':
			i = egetn(p2);
			if (i == 0)
				error("Mod by 0");
			i = egetn(p1) % i;
			break;
		}
		xfree(p1), xfree(p2);
		return (putn(i));
	}
	return (p1);
}

char *
exp6(vp, ignore)
	register char ***vp;
{
	int ccode, i;
	register char *cp, *dp, *ep;

	if (**vp == 0)
		bferr("Expression syntax");
	if (eq(**vp, "!")) {
		(*vp)++;
		cp = exp6(vp, ignore);
#ifdef EDEBUG
		etracc("exp6 ! cp", cp, vp);
#endif
		i = egetn(cp);
		xfree(cp);
		return (putn(!i));
	}
	if (eq(**vp, "~")) {
		(*vp)++;
		cp = exp6(vp, ignore);
#ifdef EDEBUG
		etracc("exp6 ~ cp", cp, vp);
#endif
		i = egetn(cp);
		xfree(cp);
		return (putn(~i));
	}
	if (eq(**vp, "(")) {
		(*vp)++;
		ccode = exp0(vp, ignore);
#ifdef EDEBUG
		etraci("exp6 () ccode", ccode, vp);
#endif
		if (*vp == 0 || **vp == 0 || ***vp != ')')
			bferr("Expression syntax");
		(*vp)++;
		return (putn(ccode));
	}
	if (eq(**vp, "{")) {
		register char **v;
		struct command faket;
		char *fakecom[2];

		faket.t_dtyp = TCOM;
		faket.t_dflg = 0;
		faket.t_dcar = faket.t_dcdr = faket.t_dspr = (struct command *)0;
		faket.t_dcom = fakecom;
		fakecom[0] = "{ ... }";
		fakecom[1] = NOSTR;
		(*vp)++;
		v = *vp;
		for (;;) {
			if (!**vp)
				bferr("Missing }");
			if (eq(*(*vp)++, "}"))
				break;
		}
		if (ignore&IGNORE)
			return ("");
		psavejob();
		if (pfork(&faket, -1) == 0) {
			*--(*vp) = 0;
			evalav(v);
			exitstat();
		}
		pwait();
		prestjob();
#ifdef EDEBUG
		etraci("exp6 {} status", egetn(value("status")), vp);
#endif
		return (putn(egetn(value("status")) == 0));
	}
	if (isa(**vp, ANYOP))
		return ("");
	cp = *(*vp)++;
	if (*cp == '-' && any(cp[1], "erwxfdzo")) {
		struct stat stb;

		if (isa(**vp, ANYOP))
			bferr("Missing file name");
		dp = *(*vp)++;
		if (ignore&IGNORE)
			return ("");
		ep = globone(dp);
		switch (cp[1]) {

		case 'r':
			i = !access(ep, 4);
			break;

		case 'w':
			i = !access(ep, 2);
			break;

		case 'x':
			i = !access(ep, 1);
			break;

		default:
			if (stat(ep, &stb)) {
				xfree(ep);
				return ("0");
			}
			switch (cp[1]) {

			case 'f':
				i = (stb.st_mode & S_IFMT) == S_IFREG;
				break;

			case 'd':
				i = (stb.st_mode & S_IFMT) == S_IFDIR;
				break;

			case 'z':
				i = stb.st_size == 0;
				break;

			case 'e':
				i = 1;
				break;

			case 'o':
				i = stb.st_uid == uid;
				break;
			}
		}
#ifdef EDEBUG
		etraci("exp6 -? i", i, vp);
#endif
		xfree(ep);
		return (putn(i));
	}
#ifdef EDEBUG
	etracc("exp6 default", cp, vp);
#endif
	return (ignore&NOGLOB ? savestr(cp) : globone(cp));
}

evalav(v)
	register char **v;
{
	struct wordent paraml;
	register struct wordent *hp = &paraml;
	struct command *t;
	register struct wordent *wdp = hp;
	
	set("status", "0");
	hp->prev = hp->next = hp;
	hp->word = "";
	while (*v) {
		register struct wordent *new = (struct wordent *) calloc(1, sizeof *wdp);

		new->prev = wdp;
		new->next = hp;
		wdp->next = new;
		wdp = new;
		wdp->word = savestr(*v++);
	}
	hp->prev = wdp;
	alias(&paraml);
	t = syntax(paraml.next, &paraml, 0);
	if (err)
		error(err);
	execute(t, -1);
	freelex(&paraml), freesyn(t);
}

isa(cp, what)
	register char *cp;
	register int what;
{

	if (cp == 0)
		return ((what & RESTOP) != 0);
	if (cp[1] == 0) {
		if (what & ADDOP && (*cp == '+' || *cp == '-'))
			return (1);
		if (what & MULOP && (*cp == '*' || *cp == '/' || *cp == '%'))
			return (1);
		if (what & RESTOP && (*cp == '(' || *cp == ')' || *cp == '!' ||
				      *cp == '~' || *cp == '^' || *cp == '"'))
			return (1);
	} else if (cp[2] == 0) {
		if (what & RESTOP) {
			if (cp[0] == '|' && cp[1] == '&')
				return (1);
			if (cp[0] == '<' && cp[1] == '<')
				return (1);
			if (cp[0] == '>' && cp[1] == '>')
				return (1);
		}
		if (what & EQOP) {
			if (cp[0] == '=') {
				if (cp[1] == '=')
					return (EQEQ);
				if (cp[1] == '~')
					return (EQMATCH);
			} else if (cp[0] == '!') {
				if (cp[1] == '=')
					return (NOTEQ);
				if (cp[1] == '~')
					return (NOTEQMATCH);
			}
		}
	}
	if (what & RELOP) {
		if (*cp == '<')
			return (LSS);
		if (*cp == '>')
			return (GTR);
	}
	return (0);
}

egetn(cp)
	register char *cp;
{

	if (*cp && *cp != '-' && !digit(*cp))
		bferr("Expression syntax");
	return (getn(cp));
}

/* Phew! */

#ifdef EDEBUG
etraci(str, i, vp)
	char *str;
	int i;
	char ***vp;
{

	printf("%s=%d\t", str, i);
	blkpr(*vp);
	printf("\n");
}

etracc(str, cp, vp)
	char *str, *cp;
	char ***vp;
{

	printf("%s=%s\t", str, cp);
	blkpr(*vp);
	printf("\n");
}
#endif
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
24f22c48	8	static char *sccsid = "@(#)exp.c 5.3 (Berkeley) %G%";
094e80ed	9	#endif
843d5d49 BJ	10
	11	#include "sh.h"
	12
	13	/*
	14	* C shell
	15	*/
	16
	17	#define IGNORE 1 /* in ignore, it means to ignore value, just parse */
	18	#define NOGLOB 2 /* in ignore, it means not to globone */
	19
	20	#define ADDOP 1
	21	#define MULOP 2
	22	#define EQOP 4
	23	#define RELOP 8
	24	#define RESTOP 16
	25	#define ANYOP 31
	26
	27	#define EQEQ 1
	28	#define GTR 2
	29	#define LSS 4
	30	#define NOTEQ 6
	31	#define EQMATCH 7
	32	#define NOTEQMATCH 8
	33
	34	exp(vp)
	35	register char ***vp;
	36	{
	37
	38	return (exp0(vp, 0));
	39	}
	40
	41	exp0(vp, ignore)
	42	register char ***vp;
	43	bool ignore;
	44	{
	45	register int p1 = exp1(vp, ignore);
	46
	47	#ifdef EDEBUG
	48	etraci("exp0 p1", p1, vp);
	49	#endif
	50	if (vp && eq(vp, "\|\|")) {
	51	register int p2;
	52
	53	(*vp)++;
	54	p2 = exp0(vp, (ignore&IGNORE) \|\| p1);
	55	#ifdef EDEBUG
	56	etraci("exp0 p2", p2, vp);
	57	#endif
	58	return (p1 \|\| p2);
	59	}
	60	return (p1);
	61	}
	62
	63	exp1(vp, ignore)
	64	register char ***vp;
	65	{
	66	register int p1 = exp2(vp, ignore);
	67
	68	#ifdef EDEBUG
	69	etraci("exp1 p1", p1, vp);
	70	#endif
	71	if (vp && eq(vp, "&&")) {
	72	register int p2;
	73
74	(*vp)++;
75	p2 = exp1(vp, (ignore&IGNORE) \|\| !p1);
76	#ifdef EDEBUG
77	etraci("exp1 p2", p2, vp);
78	#endif
79	return (p1 && p2);
80	}
81	return (p1);
82	}
83
84	exp2(vp, ignore)
85	register char ***vp;
86	bool ignore;
87	{
88	register int p1 = exp2a(vp, ignore);
89
90	#ifdef EDEBUG
91	etraci("exp3 p1", p1, vp);
92	#endif
93	if (vp && eq(vp, "\|")) {
94	register int p2;
95
96	(*vp)++;
97	p2 = exp2(vp, ignore);
98	#ifdef EDEBUG
99	etraci("exp3 p2", p2, vp);
100	#endif
101	return (p1 \| p2);
102	}
103	return (p1);
104	}
105
106	exp2a(vp, ignore)
107	register char ***vp;
108	bool ignore;
109	{
110	register int p1 = exp2b(vp, ignore);
111
112	#ifdef EDEBUG
113	etraci("exp2a p1", p1, vp);
114	#endif
115	if (vp && eq(vp, "^")) {
116	register int p2;
117
118	(*vp)++;
119	p2 = exp2a(vp, ignore);
120	#ifdef EDEBUG
121	etraci("exp2a p2", p2, vp);
122	#endif
123	return (p1 ^ p2);
124	}
125	return (p1);
126	}
127
128	exp2b(vp, ignore)
129	register char ***vp;
130	bool ignore;
131	{
132	register int p1 = exp2c(vp, ignore);
133
134	#ifdef EDEBUG
135	etraci("exp2b p1", p1, vp);
136	#endif
137	if (vp && eq(vp, "&")) {
138	register int p2;
139
140	(*vp)++;
141	p2 = exp2b(vp, ignore);
142	#ifdef EDEBUG
143	etraci("exp2b p2", p2, vp);
144	#endif
145	return (p1 & p2);
146	}
147	return (p1);
148	}
149
150	exp2c(vp, ignore)
151	register char ***vp;
152	bool ignore;
153	{
154	register char *p1 = exp3(vp, ignore);
155	register char *p2;
156	register int i;
157
158	#ifdef EDEBUG
159	etracc("exp2c p1", p1, vp);
160	#endif
161	if (i = isa(**vp, EQOP)) {
162	(*vp)++;
163	if (i == EQMATCH \|\| i == NOTEQMATCH)
164	ignore \|= NOGLOB;
165	p2 = exp3(vp, ignore);
166	#ifdef EDEBUG
167	etracc("exp2c p2", p2, vp);
168	#endif
169	if (!(ignore&IGNORE)) switch (i) {
170
171	case EQEQ:
172	i = eq(p1, p2);
173	break;
174
175	case NOTEQ:
176	i = !eq(p1, p2);
177	break;
178
179	case EQMATCH:
180	i = Gmatch(p1, p2);
181	break;
182
183	case NOTEQMATCH:
184	i = !Gmatch(p1, p2);
185	break;
186	}
187	xfree(p1), xfree(p2);
188	return (i);
189	}
190	i = egetn(p1);
191	xfree(p1);
192	return (i);
193	}
194
195	char *
196	exp3(vp, ignore)
197	register char ***vp;
198	bool ignore;
199	{
200	register char p1, p2;
201	register int i;
202
203	p1 = exp3a(vp, ignore);
204	#ifdef EDEBUG
205	etracc("exp3 p1", p1, vp);
206	#endif
207	if (i = isa(**vp, RELOP)) {
208	(*vp)++;
209	if (vp && eq(vp, "="))
210	i \|= 1, (*vp)++;
211	p2 = exp3(vp, ignore);
212	#ifdef EDEBUG
213	etracc("exp3 p2", p2, vp);
214	#endif
215	if (!(ignore&IGNORE)) switch (i) {
216
217	case GTR:
218	i = egetn(p1) > egetn(p2);
219	break;
220
221	case GTR\|1:
222	i = egetn(p1) >= egetn(p2);
223	break;
224
225	case LSS:
226	i = egetn(p1) < egetn(p2);
227	break;
228
229	case LSS\|1:
230	i = egetn(p1) <= egetn(p2);
231	break;
232	}
233	xfree(p1), xfree(p2);
234	return (putn(i));
235	}
236	return (p1);
237	}
238
239	char *
240	exp3a(vp, ignore)
241	register char ***vp;
242	bool ignore;
243	{
244	register char p1, p2, *op;
245	register int i;
246
247	p1 = exp4(vp, ignore);
248	#ifdef EDEBUG
249	etracc("exp3a p1", p1, vp);
250	#endif
251	op = **vp;
252	if (op && any(op[0], "<>") && op[0] == op[1]) {
253	(*vp)++;
254	p2 = exp3a(vp, ignore);
255	#ifdef EDEBUG
256	etracc("exp3a p2", p2, vp);
257	#endif
258	if (op[0] == '<')
259	i = egetn(p1) << egetn(p2);
260	else
261	i = egetn(p1) >> egetn(p2);
262	xfree(p1), xfree(p2);
263	return (putn(i));
264	}
265	return (p1);
266	}
267
268	char *
269	exp4(vp, ignore)
270	register char ***vp;
271	bool ignore;
272	{
273	register char p1, p2;
274	register int i = 0;
275
276	p1 = exp5(vp, ignore);
277	#ifdef EDEBUG
278	etracc("exp4 p1", p1, vp);
279	#endif
280	if (isa(**vp, ADDOP)) {
281	register char op = (*vp)++;
282
283	p2 = exp4(vp, ignore);
284	#ifdef EDEBUG
285	etracc("exp4 p2", p2, vp);
286	#endif
287	if (!(ignore&IGNORE)) switch (op[0]) {
288
289	case '+':
290	i = egetn(p1) + egetn(p2);
291	break;
292
293	case '-':
294	i = egetn(p1) - egetn(p2);
295	break;
296	}
297	xfree(p1), xfree(p2);
298	return (putn(i));
299	}
300	return (p1);
301	}
302
303	char *
304	exp5(vp, ignore)
305	register char ***vp;
306	bool ignore;
307	{
308	register char p1, p2;
309	register int i = 0;
310
311	p1 = exp6(vp, ignore);
312	#ifdef EDEBUG
313	etracc("exp5 p1", p1, vp);
314	#endif
315	if (isa(**vp, MULOP)) {
316	register char op = (*vp)++;
317
318	p2 = exp5(vp, ignore);
319	#ifdef EDEBUG
320	etracc("exp5 p2", p2, vp);
321	#endif
322	if (!(ignore&IGNORE)) switch (op[0]) {
323
324	case '*':
325	i = egetn(p1) * egetn(p2);
326	break;
327
328	case '/':
329	i = egetn(p2);
330	if (i == 0)
331	error("Divide by 0");
332	i = egetn(p1) / i;
333	break;
334
335	case '%':
336	i = egetn(p2);
337	if (i == 0)
338	error("Mod by 0");
339	i = egetn(p1) % i;
340	break;
341	}
342	xfree(p1), xfree(p2);
343	return (putn(i));
344	}
345	return (p1);
346	}
347
348	char *
349	exp6(vp, ignore)
350	register char ***vp;
351	{
352	int ccode, i;
353	register char cp, dp, *ep;
354
220a00f7 KM	355	if (**vp == 0)
220a00f7 KM	356	bferr("Expression syntax");
843d5d49 BJ	357	if (eq(**vp, "!")) {
	358	(*vp)++;
	359	cp = exp6(vp, ignore);
	360	#ifdef EDEBUG
	361	etracc("exp6 ! cp", cp, vp);
	362	#endif
	363	i = egetn(cp);
	364	xfree(cp);
	365	return (putn(!i));
	366	}
	367	if (eq(**vp, "~")) {
	368	(*vp)++;
	369	cp = exp6(vp, ignore);
	370	#ifdef EDEBUG
	371	etracc("exp6 ~ cp", cp, vp);
	372	#endif
	373	i = egetn(cp);
	374	xfree(cp);
	375	return (putn(~i));
	376	}
	377	if (eq(**vp, "(")) {
	378	(*vp)++;
	379	ccode = exp0(vp, ignore);
	380	#ifdef EDEBUG
	381	etraci("exp6 () ccode", ccode, vp);
	382	#endif
	383	if (vp == 0 \|\| vp == 0 \|\| **vp != ')')
	384	bferr("Expression syntax");
	385	(*vp)++;
	386	return (putn(ccode));
	387	}
	388	if (eq(**vp, "{")) {
	389	register char **v;
	390	struct command faket;
	391	char *fakecom[2];
	392
	393	faket.t_dtyp = TCOM;
	394	faket.t_dflg = 0;
	395	faket.t_dcar = faket.t_dcdr = faket.t_dspr = (struct command *)0;
	396	faket.t_dcom = fakecom;
	397	fakecom[0] = "{ ... }";
	398	fakecom[1] = NOSTR;
	399	(*vp)++;
	400	v = *vp;
	401	for (;;) {
	402	if (!**vp)
	403	bferr("Missing }");
	404	if (eq((vp)++, "}"))
	405	break;
	406	}
	407	if (ignore&IGNORE)
	408	return ("");
	409	psavejob();
	410	if (pfork(&faket, -1) == 0) {
	411	--(vp) = 0;
	412	evalav(v);
	413	exitstat();
	414	}
	415	pwait();
	416	prestjob();
	417	#ifdef EDEBUG
	418	etraci("exp6 {} status", egetn(value("status")), vp);
	419	#endif
	420	return (putn(egetn(value("status")) == 0));
421	}
422	if (isa(**vp, ANYOP))
423	return ("");
424	cp = (vp)++;
425	if (*cp == '-' && any(cp[1], "erwxfdzo")) {
426	struct stat stb;
427
428	if (isa(**vp, ANYOP))
429	bferr("Missing file name");
430	dp = (vp)++;
431	if (ignore&IGNORE)
432	return ("");
433	ep = globone(dp);
434	switch (cp[1]) {
435
436	case 'r':
437	i = !access(ep, 4);
438	break;
439
440	case 'w':
441	i = !access(ep, 2);
442	break;
443
444	case 'x':
445	i = !access(ep, 1);
446	break;
447
448	default:
449	if (stat(ep, &stb)) {
450	xfree(ep);
451	return ("0");
452	}
453	switch (cp[1]) {
454
455	case 'f':
456	i = (stb.st_mode & S_IFMT) == S_IFREG;
457	break;
458
459	case 'd':
460	i = (stb.st_mode & S_IFMT) == S_IFDIR;
461	break;
462
463	case 'z':
464	i = stb.st_size == 0;
465	break;
466
467	case 'e':
468	i = 1;
469	break;
470
471	case 'o':
472	i = stb.st_uid == uid;
473	break;
474	}
475	}
476	#ifdef EDEBUG
477	etraci("exp6 -? i", i, vp);
478	#endif
479	xfree(ep);
480	return (putn(i));
481	}
482	#ifdef EDEBUG
483	etracc("exp6 default", cp, vp);
484	#endif
24f22c48	485	return (ignore&NOGLOB ? savestr(cp) : globone(cp));
843d5d49 BJ	486	}
	487
	488	evalav(v)
	489	register char **v;
	490	{
	491	struct wordent paraml;
	492	register struct wordent *hp = &paraml;
	493	struct command *t;
	494	register struct wordent *wdp = hp;
	495
	496	set("status", "0");
	497	hp->prev = hp->next = hp;
	498	hp->word = "";
	499	while (*v) {
	500	register struct wordent new = (struct wordent ) calloc(1, sizeof *wdp);
	501
	502	new->prev = wdp;
	503	new->next = hp;
	504	wdp->next = new;
	505	wdp = new;
	506	wdp->word = savestr(*v++);
	507	}
	508	hp->prev = wdp;
	509	alias(&paraml);
	510	t = syntax(paraml.next, &paraml, 0);
	511	if (err)
	512	error(err);
	513	execute(t, -1);
	514	freelex(&paraml), freesyn(t);
	515	}
	516
	517	isa(cp, what)
	518	register char *cp;
	519	register int what;
	520	{
	521
	522	if (cp == 0)
	523	return ((what & RESTOP) != 0);
	524	if (cp[1] == 0) {
35371dec	525	if (what & ADDOP && (cp == '+' \|\| cp == '-'))
843d5d49	526	return (1);
35371dec	527	if (what & MULOP && (cp == '' \|\| cp == '/' \|\| cp == '%'))
843d5d49	528	return (1);
35371dec EW	529	if (what & RESTOP && (cp == '(' \|\| cp == ')' \|\| *cp == '!' \|\|
35371dec EW	530	cp == '~' \|\| cp == '^' \|\| *cp == '"'))
843d5d49	531	return (1);
35371dec EW	532	} else if (cp[2] == 0) {
	533	if (what & RESTOP) {
	534	if (cp[0] == '\|' && cp[1] == '&')
	535	return (1);
	536	if (cp[0] == '<' && cp[1] == '<')
	537	return (1);
	538	if (cp[0] == '>' && cp[1] == '>')
	539	return (1);
	540	}
	541	if (what & EQOP) {
	542	if (cp[0] == '=') {
	543	if (cp[1] == '=')
	544	return (EQEQ);
	545	if (cp[1] == '~')
	546	return (EQMATCH);
	547	} else if (cp[0] == '!') {
	548	if (cp[1] == '=')
	549	return (NOTEQ);
	550	if (cp[1] == '~')
	551	return (NOTEQMATCH);
	552	}
	553	}
843d5d49	554	}
35371dec EW	555	if (what & RELOP) {
	556	if (*cp == '<')
	557	return (LSS);
	558	if (*cp == '>')
	559	return (GTR);
843d5d49	560	}
843d5d49 BJ	561	return (0);
	562	}
	563
	564	egetn(cp)
	565	register char *cp;
	566	{
	567
	568	if (cp && cp != '-' && !digit(*cp))
	569	bferr("Expression syntax");
	570	return (getn(cp));
	571	}
	572
	573	/* Phew! */
	574
	575	#ifdef EDEBUG
	576	etraci(str, i, vp)
	577	char *str;
	578	int i;
	579	char ***vp;
	580	{
	581
	582	printf("%s=%d\t", str, i);
	583	blkpr(*vp);
	584	printf("\n");
	585	}
	586
	587	etracc(str, cp, vp)
	588	char str, cp;
	589	char ***vp;
	590	{
	591
	592	printf("%s=%s\t", str, cp);
	593	blkpr(*vp);
	594	printf("\n");
	595	}
	596	#endif