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

static	char *sccsid = "@(#)exp.c 4.1 %G%";

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