Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	bin/csh/exp.c	Lines:	0	268	0.0 %
Date:	2017-11-07	Branches:	0	216	0.0 %


/*	$OpenBSD: exp.c,v 1.16 2015/12/26 13:48:38 mestre Exp $	*/
/*	$NetBSD: exp.c,v 1.6 1995/03/21 09:02:51 cgd Exp $	*/

/*-
 * Copyright (c) 1980, 1991, 1993
 *	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. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>

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

#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

static int	exp1(Char ***, bool);
static int	exp2_(Char ***, bool);
static int	exp2a(Char ***, bool);
static int	exp2b(Char ***, bool);
static int	exp2c(Char ***, bool);
static Char *	exp3(Char ***, bool);
static Char *	exp3a(Char ***, bool);
static Char *	exp4(Char ***, bool);
static Char *	exp5(Char ***, bool);
static Char *	exp6(Char ***, bool);
static void	evalav(Char **);
static int	isa(Char *, int);
static int	egetn(Char *);

int
expr(Char ***vp)
{
    return (exp0(vp, 0));
}

int
exp0(Char ***vp, bool ignore)
{
    int p1 = exp1(vp, ignore);

    if (**vp && eq(**vp, STRor2)) {
	int p2;

	(*vp)++;
	p2 = exp0(vp, (ignore & IGNORE) || p1);
	return (p1 || p2);
    }
    return (p1);
}

static int
exp1(Char ***vp, bool ignore)
{
    int p1 = exp2_(vp, ignore);

    if (**vp && eq(**vp, STRand2)) {
	int p2;

	(*vp)++;
	p2 = exp1(vp, (ignore & IGNORE) || !p1);
	return (p1 && p2);
    }
    return (p1);
}

static int
exp2_(Char ***vp, bool ignore)
{
    int p1 = exp2a(vp, ignore);

    if (**vp && eq(**vp, STRor)) {
	int p2;

	(*vp)++;
	p2 = exp2_(vp, ignore);
	return (p1 | p2);
    }
    return (p1);
}

static int
exp2a(Char ***vp, bool ignore)
{
    int p1 = exp2b(vp, ignore);

    if (**vp && eq(**vp, STRcaret)) {
	int p2;

	(*vp)++;
	p2 = exp2a(vp, ignore);
	return (p1 ^ p2);
    }
    return (p1);
}

static int
exp2b(Char ***vp, bool ignore)
{
    int p1 = exp2c(vp, ignore);

    if (**vp && eq(**vp, STRand)) {
	int p2;

	(*vp)++;
	p2 = exp2b(vp, ignore);
	return (p1 & p2);
    }
    return (p1);
}

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

    if ((i = isa(**vp, EQOP)) != 0) {
	(*vp)++;
	if (i == EQMATCH || i == NOTEQMATCH)
	    ignore |= NOGLOB;
	p2 = exp3(vp, ignore);
	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;
	    }
	free(p1);
	free(p2);
	return (i);
    }
    i = egetn(p1);
    free(p1);
    return (i);
}

static Char *
exp3(Char ***vp, bool ignore)
{
    Char *p1, *p2;
    int i;

    p1 = exp3a(vp, ignore);
    if ((i = isa(**vp, RELOP)) != 0) {
	(*vp)++;
	if (**vp && eq(**vp, STRequal))
	    i |= 1, (*vp)++;
	p2 = exp3(vp, ignore);
	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;
	    }
	free(p1);
	free(p2);
	return (putn(i));
    }
    return (p1);
}

static Char *
exp3a(Char ***vp, bool ignore)
{
    Char *p1, *p2, *op;
    int i;

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

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

    p1 = exp5(vp, ignore);
    if (isa(**vp, ADDOP)) {
	Char *op = *(*vp)++;

	p2 = exp4(vp, ignore);
	if (!(ignore & IGNORE))
	    switch (op[0]) {

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

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

static Char *
exp5(Char ***vp, bool ignore)
{
    Char *p1, *p2;
    int i = 0, l;

    p1 = exp6(vp, ignore);
    if (isa(**vp, MULOP)) {
	Char *op = *(*vp)++;

	p2 = exp5(vp, ignore);
	if (!(ignore & IGNORE))
	    switch (op[0]) {

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

	    case '/':
		i = egetn(p2);
		if (i == 0)
		    stderror(ERR_DIV0);
		l = egetn(p1);
		if (l == INT_MIN && i == -1)
			i = INT_MIN;
		else
			i = l / i;
		break;

	    case '%':
		i = egetn(p2);
		if (i == 0)
		    stderror(ERR_MOD0);
		l = egetn(p1);
		if (l == INT_MIN && i == -1)
			i = 0;
		else
			i = l % i;
		break;
	    }
	free(p1);
	free(p2);
	return (putn(i));
    }
    return (p1);
}

static Char *
exp6(Char ***vp, bool ignore)
{
    int     ccode, i = 0;
    Char *cp, *dp, *ep;

    if (**vp == 0)
	stderror(ERR_NAME | ERR_EXPRESSION);
    if (eq(**vp, STRbang)) {
	(*vp)++;
	cp = exp6(vp, ignore);
	i = egetn(cp);
	free(cp);
	return (putn(!i));
    }
    if (eq(**vp, STRtilde)) {
	(*vp)++;
	cp = exp6(vp, ignore);
	i = egetn(cp);
	free(cp);
	return (putn(~i));
    }
    if (eq(**vp, STRLparen)) {
	(*vp)++;
	ccode = exp0(vp, ignore);
	if (*vp == 0 || **vp == 0 || ***vp != ')')
	    stderror(ERR_NAME | ERR_EXPRESSION);
	(*vp)++;
	return (putn(ccode));
    }
    if (eq(**vp, STRLbrace)) {
	Char **v;
	struct command faket;
	Char   *fakecom[2];

	faket.t_dtyp = NODE_COMMAND;
	faket.t_dflg = 0;
	faket.t_dcar = faket.t_dcdr = faket.t_dspr = NULL;
	faket.t_dcom = fakecom;
	fakecom[0] = STRfakecom;
	fakecom[1] = NULL;
	(*vp)++;
	v = *vp;
	for (;;) {
	    if (!**vp)
		stderror(ERR_NAME | ERR_MISSING, '}');
	    if (eq(*(*vp)++, STRRbrace))
		break;
	}
	if (ignore & IGNORE)
	    return (Strsave(STRNULL));
	psavejob();
	if (pfork(&faket, -1) == 0) {
	    *--(*vp) = 0;
	    evalav(v);
	    exitstat();
	}
	pwait();
	prestjob();
	return (putn(egetn(value(STRstatus)) == 0));
    }
    if (isa(**vp, ANYOP))
	return (Strsave(STRNULL));
    cp = *(*vp)++;
    if (*cp == '-' && any("erwxfdzopls", cp[1])) {
	struct stat stb;

	if (cp[2] != '\0')
	    stderror(ERR_NAME | ERR_FILEINQ);
	/*
	 * Detect missing file names by checking for operator in the file name
	 * position.  However, if an operator name appears there, we must make
	 * sure that there's no file by that name (e.g., "/") before announcing
	 * an error.  Even this check isn't quite right, since it doesn't take
	 * globbing into account.
	 */
	if (isa(**vp, ANYOP) && stat(short2str(**vp), &stb))
	    stderror(ERR_NAME | ERR_FILENAME);

	dp = *(*vp)++;
	if (ignore & IGNORE)
	    return (Strsave(STRNULL));
	ep = globone(dp, G_ERROR);
	switch (cp[1]) {

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

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

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

	default:
	    if (cp[1] == 'l' ? lstat(short2str(ep), &stb) :
		stat(short2str(ep), &stb)) {
		free(ep);
		return (Strsave(STR0));
	    }
	    switch (cp[1]) {

	    case 'f':
		i = S_ISREG(stb.st_mode);
		break;

	    case 'd':
		i = S_ISDIR(stb.st_mode);
		break;

	    case 'p':
		i = S_ISFIFO(stb.st_mode);
		break;

	    case 'l':
		i = S_ISLNK(stb.st_mode);
		break;

	    case 's':
		i = S_ISSOCK(stb.st_mode);
		break;

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

	    case 'e':
		i = 1;
		break;

	    case 'o':
		i = stb.st_uid == uid;
		break;
	    }
	}
	free(ep);
	return (putn(i));
    }
    return (ignore & NOGLOB ? Strsave(cp) : globone(cp, G_ERROR));
}

static void
evalav(Char **v)
{
    struct wordent paraml1;
    struct wordent *hp = &paraml1;
    struct command *t;
    struct wordent *wdp = hp;

    set(STRstatus, Strsave(STR0));
    hp->prev = hp->next = hp;
    hp->word = STRNULL;
    while (*v) {
	struct wordent *new = xcalloc(1, sizeof *wdp);

	new->prev = wdp;
	new->next = hp;
	wdp->next = new;
	wdp = new;
	wdp->word = Strsave(*v++);
    }
    hp->prev = wdp;
    alias(&paraml1);
    t = syntax(paraml1.next, &paraml1, 0);
    if (seterr)
	stderror(ERR_OLD);
    execute(t, -1, NULL, NULL);
    freelex(&paraml1), freesyn(t);
}

static int
isa(Char *cp, 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);
}

static int
egetn(Char *cp)
{
    if (*cp && *cp != '-' && !Isdigit(*cp))
	stderror(ERR_NAME | ERR_EXPRESSION);
    return (getn(cp));
}

/* Phew! */


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: exp.c,v 1.16 2015/12/26 13:48:38 mestre Exp $ */
2			/* $NetBSD: exp.c,v 1.6 1995/03/21 09:02:51 cgd Exp $ */
3
4			/*-
5			* Copyright (c) 1980, 1991, 1993
6			* The Regents of the University of California. All rights reserved.
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			* 3. Neither the name of the University nor the names of its contributors
17			* may be used to endorse or promote products derived from this software
18			* without specific prior written permission.
19			*
20			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30			* SUCH DAMAGE.
31			*/
32
33			#include <sys/types.h>
34			#include <sys/stat.h>
35			#include <limits.h>
36			#include <stdlib.h>
37			#include <unistd.h>
38			#include <stdarg.h>
39
40			#include "csh.h"
41			#include "extern.h"
42
43			#define IGNORE 1 /* in ignore, it means to ignore value, just parse */
44			#define NOGLOB 2 /* in ignore, it means not to globone */
45
46			#define ADDOP 1
47			#define MULOP 2
48			#define EQOP 4
49			#define RELOP 8
50			#define RESTOP 16
51			#define ANYOP 31
52
53			#define EQEQ 1
54			#define GTR 2
55			#define LSS 4
56			#define NOTEQ 6
57			#define EQMATCH 7
58			#define NOTEQMATCH 8
59
60			static int exp1(Char ***, bool);
61			static int exp2_(Char ***, bool);
62			static int exp2a(Char ***, bool);
63			static int exp2b(Char ***, bool);
64			static int exp2c(Char ***, bool);
65			static Char * exp3(Char ***, bool);
66			static Char * exp3a(Char ***, bool);
67			static Char * exp4(Char ***, bool);
68			static Char * exp5(Char ***, bool);
69			static Char * exp6(Char ***, bool);
70			static void evalav(Char **);
71			static int isa(Char *, int);
72			static int egetn(Char *);
73
74			int
75			expr(Char ***vp)
76			{
77			return (exp0(vp, 0));
78			}
79
80			int
81			exp0(Char ***vp, bool ignore)
82			{
83			int p1 = exp1(vp, ignore);
84
85			if (vp && eq(vp, STRor2)) {
86			int p2;
87
88			(*vp)++;
89			p2 = exp0(vp, (ignore & IGNORE) \|\| p1);
90			return (p1 \|\| p2);
91			}
92			return (p1);
93			}
94
95			static int
96			exp1(Char ***vp, bool ignore)
97			{
98			int p1 = exp2_(vp, ignore);
99
100			if (vp && eq(vp, STRand2)) {
101			int p2;
102
103			(*vp)++;
104			p2 = exp1(vp, (ignore & IGNORE) \|\| !p1);
105			return (p1 && p2);
106			}
107			return (p1);
108			}
109
110			static int
111			exp2_(Char ***vp, bool ignore)
112			{
113			int p1 = exp2a(vp, ignore);
114
115			if (vp && eq(vp, STRor)) {
116			int p2;
117
118			(*vp)++;
119			p2 = exp2_(vp, ignore);
120			return (p1 \| p2);
121			}
122			return (p1);
123			}
124
125			static int
126			exp2a(Char ***vp, bool ignore)
127			{
128			int p1 = exp2b(vp, ignore);
129
130			if (vp && eq(vp, STRcaret)) {
131			int p2;
132
133			(*vp)++;
134			p2 = exp2a(vp, ignore);
135			return (p1 ^ p2);
136			}
137			return (p1);
138			}
139
140			static int
141			exp2b(Char ***vp, bool ignore)
142			{
143			int p1 = exp2c(vp, ignore);
144
145			if (vp && eq(vp, STRand)) {
146			int p2;
147
148			(*vp)++;
149			p2 = exp2b(vp, ignore);
150			return (p1 & p2);
151			}
152			return (p1);
153			}
154
155			static int
156			exp2c(Char ***vp, bool ignore)
157			{
158			Char *p1 = exp3(vp, ignore);
159			Char *p2;
160			int i;
161
162			if ((i = isa(**vp, EQOP)) != 0) {
163			(*vp)++;
164			if (i == EQMATCH \|\| i == NOTEQMATCH)
165			ignore \|= NOGLOB;
166			p2 = exp3(vp, ignore);
167			if (!(ignore & IGNORE))
168			switch (i) {
169
170			case EQEQ:
171			i = eq(p1, p2);
172			break;
173
174			case NOTEQ:
175			i = !eq(p1, p2);
176			break;
177
178			case EQMATCH:
179			i = Gmatch(p1, p2);
180			break;
181
182			case NOTEQMATCH:
183			i = !Gmatch(p1, p2);
184			break;
185			}
186			free(p1);
187			free(p2);
188			return (i);
189			}
190			i = egetn(p1);
191			free(p1);
192			return (i);
193			}
194
195			static Char *
196			exp3(Char ***vp, bool ignore)
197			{
198			Char p1, p2;
199			int i;
200
201			p1 = exp3a(vp, ignore);
202			if ((i = isa(**vp, RELOP)) != 0) {
203			(*vp)++;
204			if (vp && eq(vp, STRequal))
205			i \|= 1, (*vp)++;
206			p2 = exp3(vp, ignore);
207			if (!(ignore & IGNORE))
208			switch (i) {
209
210			case GTR:
211			i = egetn(p1) > egetn(p2);
212			break;
213
214			case GTR \| 1:
215			i = egetn(p1) >= egetn(p2);
216			break;
217
218			case LSS:
219			i = egetn(p1) < egetn(p2);
220			break;
221
222			case LSS \| 1:
223			i = egetn(p1) <= egetn(p2);
224			break;
225			}
226			free(p1);
227			free(p2);
228			return (putn(i));
229			}
230			return (p1);
231			}
232
233			static Char *
234			exp3a(Char ***vp, bool ignore)
235			{
236			Char p1, p2, *op;
237			int i;
238
239			p1 = exp4(vp, ignore);
240			op = **vp;
241			if (op && any("<>", op[0]) && op[0] == op[1]) {
242			(*vp)++;
243			p2 = exp3a(vp, ignore);
244			if (op[0] == '<')
245			i = egetn(p1) << egetn(p2);
246			else
247			i = egetn(p1) >> egetn(p2);
248			free(p1);
249			free(p2);
250			return (putn(i));
251			}
252			return (p1);
253			}
254
255			static Char *
256			exp4(Char ***vp, bool ignore)
257			{
258			Char p1, p2;
259			int i = 0;
260
261			p1 = exp5(vp, ignore);
262			if (isa(**vp, ADDOP)) {
263			Char op = (*vp)++;
264
265			p2 = exp4(vp, ignore);
266			if (!(ignore & IGNORE))
267			switch (op[0]) {
268
269			case '+':
270			i = egetn(p1) + egetn(p2);
271			break;
272
273			case '-':
274			i = egetn(p1) - egetn(p2);
275			break;
276			}
277			free(p1);
278			free(p2);
279			return (putn(i));
280			}
281			return (p1);
282			}
283
284			static Char *
285			exp5(Char ***vp, bool ignore)
286			{
287			Char p1, p2;
288			int i = 0, l;
289
290			p1 = exp6(vp, ignore);
291			if (isa(**vp, MULOP)) {
292			Char op = (*vp)++;
293
294			p2 = exp5(vp, ignore);
295			if (!(ignore & IGNORE))
296			switch (op[0]) {
297
298			case '*':
299			i = egetn(p1) * egetn(p2);
300			break;
301
302			case '/':
303			i = egetn(p2);
304			if (i == 0)
305			stderror(ERR_DIV0);
306			l = egetn(p1);
307			if (l == INT_MIN && i == -1)
308			i = INT_MIN;
309			else
310			i = l / i;
311			break;
312
313			case '%':
314			i = egetn(p2);
315			if (i == 0)
316			stderror(ERR_MOD0);
317			l = egetn(p1);
318			if (l == INT_MIN && i == -1)
319			i = 0;
320			else
321			i = l % i;
322			break;
323			}
324			free(p1);
325			free(p2);
326			return (putn(i));
327			}
328			return (p1);
329			}
330
331			static Char *
332			exp6(Char ***vp, bool ignore)
333			{
334			int ccode, i = 0;
335			Char cp, dp, *ep;
336
337			if (**vp == 0)
338			stderror(ERR_NAME \| ERR_EXPRESSION);
339			if (eq(**vp, STRbang)) {
340			(*vp)++;
341			cp = exp6(vp, ignore);
342			i = egetn(cp);
343			free(cp);
344			return (putn(!i));
345			}
346			if (eq(**vp, STRtilde)) {
347			(*vp)++;
348			cp = exp6(vp, ignore);
349			i = egetn(cp);
350			free(cp);
351			return (putn(~i));
352			}
353			if (eq(**vp, STRLparen)) {
354			(*vp)++;
355			ccode = exp0(vp, ignore);
356			if (vp == 0 \|\| vp == 0 \|\| **vp != ')')
357			stderror(ERR_NAME \| ERR_EXPRESSION);
358			(*vp)++;
359			return (putn(ccode));
360			}
361			if (eq(**vp, STRLbrace)) {
362			Char **v;
363			struct command faket;
364			Char *fakecom[2];
365
366			faket.t_dtyp = NODE_COMMAND;
367			faket.t_dflg = 0;
368			faket.t_dcar = faket.t_dcdr = faket.t_dspr = NULL;
369			faket.t_dcom = fakecom;
370			fakecom[0] = STRfakecom;
371			fakecom[1] = NULL;
372			(*vp)++;
373			v = *vp;
374			for (;;) {
375			if (!**vp)
376			stderror(ERR_NAME \| ERR_MISSING, '}');
377			if (eq((vp)++, STRRbrace))
378			break;
379			}
380			if (ignore & IGNORE)
381			return (Strsave(STRNULL));
382			psavejob();
383			if (pfork(&faket, -1) == 0) {
384			--(vp) = 0;
385			evalav(v);
386			exitstat();
387			}
388			pwait();
389			prestjob();
390			return (putn(egetn(value(STRstatus)) == 0));
391			}
392			if (isa(**vp, ANYOP))
393			return (Strsave(STRNULL));
394			cp = (vp)++;
395			if (*cp == '-' && any("erwxfdzopls", cp[1])) {
396			struct stat stb;
397
398			if (cp[2] != '\0')
399			stderror(ERR_NAME \| ERR_FILEINQ);
400			/*
401			* Detect missing file names by checking for operator in the file name
402			* position. However, if an operator name appears there, we must make
403			* sure that there's no file by that name (e.g., "/") before announcing
404			* an error. Even this check isn't quite right, since it doesn't take
405			* globbing into account.
406			*/
407			if (isa(vp, ANYOP) && stat(short2str(vp), &stb))
408			stderror(ERR_NAME \| ERR_FILENAME);
409
410			dp = (vp)++;
411			if (ignore & IGNORE)
412			return (Strsave(STRNULL));
413			ep = globone(dp, G_ERROR);
414			switch (cp[1]) {
415
416			case 'r':
417			i = !access(short2str(ep), R_OK);
418			break;
419
420			case 'w':
421			i = !access(short2str(ep), W_OK);
422			break;
423
424			case 'x':
425			i = !access(short2str(ep), X_OK);
426			break;
427
428			default:
429			if (cp[1] == 'l' ? lstat(short2str(ep), &stb) :
430			stat(short2str(ep), &stb)) {
431			free(ep);
432			return (Strsave(STR0));
433			}
434			switch (cp[1]) {
435
436			case 'f':
437			i = S_ISREG(stb.st_mode);
438			break;
439
440			case 'd':
441			i = S_ISDIR(stb.st_mode);
442			break;
443
444			case 'p':
445			i = S_ISFIFO(stb.st_mode);
446			break;
447
448			case 'l':
449			i = S_ISLNK(stb.st_mode);
450			break;
451
452			case 's':
453			i = S_ISSOCK(stb.st_mode);
454			break;
455
456			case 'z':
457			i = stb.st_size == 0;
458			break;
459
460			case 'e':
461			i = 1;
462			break;
463
464			case 'o':
465			i = stb.st_uid == uid;
466			break;
467			}
468			}
469			free(ep);
470			return (putn(i));
471			}
472			return (ignore & NOGLOB ? Strsave(cp) : globone(cp, G_ERROR));
473			}
474
475			static void
476			evalav(Char **v)
477			{
478			struct wordent paraml1;
479			struct wordent *hp = &paraml1;
480			struct command *t;
481			struct wordent *wdp = hp;
482
483			set(STRstatus, Strsave(STR0));
484			hp->prev = hp->next = hp;
485			hp->word = STRNULL;
486			while (*v) {
487			struct wordent new = xcalloc(1, sizeof wdp);
488
489			new->prev = wdp;
490			new->next = hp;
491			wdp->next = new;
492			wdp = new;
493			wdp->word = Strsave(*v++);
494			}
495			hp->prev = wdp;
496			alias(&paraml1);
497			t = syntax(paraml1.next, &paraml1, 0);
498			if (seterr)
499			stderror(ERR_OLD);
500			execute(t, -1, NULL, NULL);
501			freelex(&paraml1), freesyn(t);
502			}
503
504			static int
505			isa(Char *cp, int what)
506			{
507			if (cp == 0)
508			return ((what & RESTOP) != 0);
509			if (cp[1] == 0) {
510			if (what & ADDOP && (cp == '+' \|\| cp == '-'))
511			return (1);
512			if (what & MULOP && (cp == '' \|\| cp == '/' \|\| cp == '%'))
513			return (1);
514			if (what & RESTOP && (cp == '(' \|\| cp == ')' \|\| *cp == '!' \|\|
515			cp == '~' \|\| cp == '^' \|\| *cp == '"'))
516			return (1);
517			}
518			else if (cp[2] == 0) {
519			if (what & RESTOP) {
520			if (cp[0] == '\|' && cp[1] == '&')
521			return (1);
522			if (cp[0] == '<' && cp[1] == '<')
523			return (1);
524			if (cp[0] == '>' && cp[1] == '>')
525			return (1);
526			}
527			if (what & EQOP) {
528			if (cp[0] == '=') {
529			if (cp[1] == '=')
530			return (EQEQ);
531			if (cp[1] == '~')
532			return (EQMATCH);
533			}
534			else if (cp[0] == '!') {
535			if (cp[1] == '=')
536			return (NOTEQ);
537			if (cp[1] == '~')
538			return (NOTEQMATCH);
539			}
540			}
541			}
542			if (what & RELOP) {
543			if (*cp == '<')
544			return (LSS);
545			if (*cp == '>')
546			return (GTR);
547			}
548			return (0);
549			}
550
551			static int
552			egetn(Char *cp)
553			{
554			if (cp && cp != '-' && !Isdigit(*cp))
555			stderror(ERR_NAME \| ERR_EXPRESSION);
556			return (getn(cp));
557			}
558
559			/* Phew! */