[dragonfly.git] / bin / test / test.c

/*	$NetBSD: test.c,v 1.21 1999/04/05 09:48:38 kleink Exp $	*/

/*-
 * test(1); version 7-like  --  author Erik Baalbergen
 * modified by Eric Gisin to be used as built-in.
 * modified by Arnold Robbins to add SVR3 compatibility
 * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
 * modified by J.T. Conklin for NetBSD.
 *
 * This program is in the Public Domain.
 *
 * $FreeBSD: src/bin/test/test.c,v 1.55 2010/03/28 13:16:08 ed Exp $
 */

#include <sys/types.h>
#include <sys/stat.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#ifdef SHELL
#define main testcmd
#include "bltin/bltin.h"
#include "error.h"
#else
#include <locale.h>

static void error(const char *, ...) __dead2 __printf0like(1, 2);

static void
error(const char *msg, ...)
{
	va_list ap;

	va_start(ap, msg);
	verrx(2, msg, ap);
	/*NOTREACHED*/
	va_end(ap);
}
#endif

/* test(1) accepts the following grammar:
	oexpr	::= aexpr | aexpr "-o" oexpr ;
	aexpr	::= nexpr | nexpr "-a" aexpr ;
	nexpr	::= primary | "!" primary
	primary	::= unary-operator operand
		| operand binary-operator operand
		| operand
		| "(" oexpr ")"
		;
	unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
		"-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";

	binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
			"-nt"|"-ot"|"-ef";
	operand ::= <any legal UNIX file name>
*/

enum token {
	EOI,
	FILRD,
	FILWR,
	FILEX,
	FILEXIST,
	FILREG,
	FILDIR,
	FILCDEV,
	FILBDEV,
	FILFIFO,
	FILSOCK,
	FILSYM,
	FILGZ,
	FILTT,
	FILSUID,
	FILSGID,
	FILSTCK,
	FILNT,
	FILOT,
	FILEQ,
	FILUID,
	FILGID,
	STREZ,
	STRNZ,
	STREQ,
	STRNE,
	STRLT,
	STRGT,
	INTEQ,
	INTNE,
	INTGE,
	INTGT,
	INTLE,
	INTLT,
	UNOT,
	BAND,
	BOR,
	LPAREN,
	RPAREN,
	OPERAND
};

enum token_types {
	UNOP,
	BINOP,
	BUNOP,
	BBINOP,
	PAREN
};

struct t_op {
	const char *op_text;
	short op_num, op_type;
} const ops [] = {
	{"-r",	FILRD,	UNOP},
	{"-w",	FILWR,	UNOP},
	{"-x",	FILEX,	UNOP},
	{"-e",	FILEXIST,UNOP},
	{"-f",	FILREG,	UNOP},
	{"-d",	FILDIR,	UNOP},
	{"-c",	FILCDEV,UNOP},
	{"-b",	FILBDEV,UNOP},
	{"-p",	FILFIFO,UNOP},
	{"-u",	FILSUID,UNOP},
	{"-g",	FILSGID,UNOP},
	{"-k",	FILSTCK,UNOP},
	{"-s",	FILGZ,	UNOP},
	{"-t",	FILTT,	UNOP},
	{"-z",	STREZ,	UNOP},
	{"-n",	STRNZ,	UNOP},
	{"-h",	FILSYM,	UNOP},		/* for backwards compat */
	{"-O",	FILUID,	UNOP},
	{"-G",	FILGID,	UNOP},
	{"-L",	FILSYM,	UNOP},
	{"-S",	FILSOCK,UNOP},
	{"=",	STREQ,	BINOP},
	{"!=",	STRNE,	BINOP},
	{"<",	STRLT,	BINOP},
	{">",	STRGT,	BINOP},
	{"-eq",	INTEQ,	BINOP},
	{"-ne",	INTNE,	BINOP},
	{"-ge",	INTGE,	BINOP},
	{"-gt",	INTGT,	BINOP},
	{"-le",	INTLE,	BINOP},
	{"-lt",	INTLT,	BINOP},
	{"-nt",	FILNT,	BINOP},
	{"-ot",	FILOT,	BINOP},
	{"-ef",	FILEQ,	BINOP},
	{"!",	UNOT,	BUNOP},
	{"-a",	BAND,	BBINOP},
	{"-o",	BOR,	BBINOP},
	{"(",	LPAREN,	PAREN},
	{")",	RPAREN,	PAREN},
	{0,	0,	0}
};

struct t_op const *t_wp_op;
int nargc;
char **t_wp;
int parenlevel;

static int	aexpr(enum token);
static int	binop(void);
static int	equalf(const char *, const char *);
static int	filstat(char *, enum token);
static int	getn(const char *);
static intmax_t	getq(const char *);
static int	intcmp(const char *, const char *);
static int	isunopoperand(void);
static int	islparenoperand(void);
static int	isrparenoperand(void);
static int	newerf(const char *, const char *);
static int	nexpr(enum token);
static int	oexpr(enum token);
static int	olderf(const char *, const char *);
static int	primary(enum token);
static void	syntax(const char *, const char *);
static enum	token t_lex(char *);

int
main(int argc, char **argv)
{
	gid_t	egid, gid;
	uid_t	euid, uid;
	int	res;
	char	*p;

	if ((p = strrchr(argv[0], '/')) == NULL)
		p = argv[0];
	else
		p++;
	if (strcmp(p, "[") == 0) {
		if (strcmp(argv[--argc], "]") != 0)
			error("missing ]");
		argv[argc] = NULL;
	}

	/* no expression => false */
	if (--argc <= 0)
		return 1;

#ifndef SHELL
	setlocale(LC_CTYPE, "");
#endif
	/* XXX work around the absence of an eaccess(2) syscall */
	egid = getegid();
	euid = geteuid();
	gid = getgid();
	uid = getuid();
	setregid(egid, gid);
	setreuid(euid, uid);

	nargc = argc;
	t_wp = &argv[1];
	parenlevel = 0;
	if (nargc == 4 && strcmp(*t_wp, "!") == 0) {
		/* Things like ! "" -o x do not fit in the normal grammar. */
		--nargc;
		++t_wp;
		res = oexpr(t_lex(*t_wp));
	} else
		res = !oexpr(t_lex(*t_wp));

	if (--nargc > 0)
		syntax(*t_wp, "unexpected operator");
	setregid(gid, egid);
	setreuid(uid, euid);

	return res;
}

static void
syntax(const char *op, const char *msg)
{

	if (op && *op)
		error("%s: %s", op, msg);
	else
		error("%s", msg);
}

static int
oexpr(enum token n)
{
	int res;

	res = aexpr(n);
	if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BOR)
		return oexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) ||
		    res;
	t_wp--;
	nargc++;
	return res;
}

static int
aexpr(enum token n)
{
	int res;

	res = nexpr(n);
	if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BAND)
		return aexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) &&
		    res;
	t_wp--;
	nargc++;
	return res;
}

static int
nexpr(enum token n)
{
	if (n == UNOT)
		return !nexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL));
	return primary(n);
}

static int
primary(enum token n)
{
	enum token nn;
	int res;

	if (n == EOI)
		return 0;		/* missing expression */
	if (n == LPAREN) {
		parenlevel++;
		if ((nn = t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) ==
		    RPAREN) {
			parenlevel--;
			return 0;	/* missing expression */
		}
		res = oexpr(nn);
		if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) != RPAREN)
			syntax(NULL, "closing paren expected");
		parenlevel--;
		return res;
	}
	if (t_wp_op && t_wp_op->op_type == UNOP) {
		/* unary expression */
		if (--nargc == 0)
			syntax(t_wp_op->op_text, "argument expected");
		switch (n) {
		case STREZ:
			return strlen(*++t_wp) == 0;
		case STRNZ:
			return strlen(*++t_wp) != 0;
		case FILTT:
			return isatty(getn(*++t_wp));
		default:
			return filstat(*++t_wp, n);
		}
	}

	if (t_lex(nargc > 0 ? t_wp[1] : NULL), t_wp_op && t_wp_op->op_type ==
	    BINOP) {
		return binop();
	}

	return strlen(*t_wp) > 0;
}

static int
binop(void)
{
	const char *opnd1, *opnd2;
	struct t_op const *op;

	opnd1 = *t_wp;
	t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL);
	op = t_wp_op;

	if ((opnd2 = nargc > 0 ? (--nargc, *++t_wp) : NULL) == NULL)
		syntax(op->op_text, "argument expected");

	switch (op->op_num) {
	case STREQ:
		return strcmp(opnd1, opnd2) == 0;
	case STRNE:
		return strcmp(opnd1, opnd2) != 0;
	case STRLT:
		return strcmp(opnd1, opnd2) < 0;
	case STRGT:
		return strcmp(opnd1, opnd2) > 0;
	case INTEQ:
		return intcmp(opnd1, opnd2) == 0;
	case INTNE:
		return intcmp(opnd1, opnd2) != 0;
	case INTGE:
		return intcmp(opnd1, opnd2) >= 0;
	case INTGT:
		return intcmp(opnd1, opnd2) > 0;
	case INTLE:
		return intcmp(opnd1, opnd2) <= 0;
	case INTLT:
		return intcmp(opnd1, opnd2) < 0;
	case FILNT:
		return newerf (opnd1, opnd2);
	case FILOT:
		return olderf (opnd1, opnd2);
	case FILEQ:
		return equalf (opnd1, opnd2);
	default:
		abort();
		/* NOTREACHED */
	}
}

static int
filstat(char *nm, enum token mode)
{
	struct stat s;

	if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s))
		return 0;

	switch (mode) {
	case FILRD:
		return access(nm, R_OK) == 0;
	case FILWR:
		return access(nm, W_OK) == 0;
	case FILEX:
		/* XXX work around access(2) false positives for superuser */
		if (access(nm, X_OK) != 0)
			return 0;
		if (S_ISDIR(s.st_mode) || getuid() != 0)
			return 1;
		return (s.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0;
	case FILEXIST:
		return access(nm, F_OK) == 0;
	case FILREG:
		return S_ISREG(s.st_mode);
	case FILDIR:
		return S_ISDIR(s.st_mode);
	case FILCDEV:
		return S_ISCHR(s.st_mode);
	case FILBDEV:
		return S_ISBLK(s.st_mode);
	case FILFIFO:
		return S_ISFIFO(s.st_mode);
	case FILSOCK:
		return S_ISSOCK(s.st_mode);
	case FILSYM:
		return S_ISLNK(s.st_mode);
	case FILSUID:
		return (s.st_mode & S_ISUID) != 0;
	case FILSGID:
		return (s.st_mode & S_ISGID) != 0;
	case FILSTCK:
		return (s.st_mode & S_ISVTX) != 0;
	case FILGZ:
		return s.st_size > (off_t)0;
	case FILUID:
		return s.st_uid == geteuid();
	case FILGID:
		return s.st_gid == getegid();
	default:
		return 1;
	}
}

static enum token
t_lex(char *s)
{
	struct t_op const *op = ops;

	if (s == 0) {
		t_wp_op = NULL;
		return EOI;
	}
	while (op->op_text) {
		if (strcmp(s, op->op_text) == 0) {
			if (((op->op_type == UNOP || op->op_type == BUNOP)
						&& isunopoperand()) ||
			    (op->op_num == LPAREN && islparenoperand()) ||
			    (op->op_num == RPAREN && isrparenoperand()))
				break;
			t_wp_op = op;
			return op->op_num;
		}
		op++;
	}
	t_wp_op = NULL;
	return OPERAND;
}

static int
isunopoperand(void)
{
	struct t_op const *op = ops;
	char *s;
	char *t;

	if (nargc == 1)
		return 1;
	s = *(t_wp + 1);
	if (nargc == 2)
		return parenlevel == 1 && strcmp(s, ")") == 0;
	t = *(t_wp + 2);
	while (op->op_text) {
		if (strcmp(s, op->op_text) == 0)
			return op->op_type == BINOP &&
			    (parenlevel == 0 || t[0] != ')' || t[1] != '\0');
		op++;
	}
	return 0;
}

static int
islparenoperand(void)
{
	struct t_op const *op = ops;
	char *s;

	if (nargc == 1)
		return 1;
	s = *(t_wp + 1);
	if (nargc == 2)
		return parenlevel == 1 && strcmp(s, ")") == 0;
	if (nargc != 3)
		return 0;
	while (op->op_text) {
		if (strcmp(s, op->op_text) == 0)
			return op->op_type == BINOP;
		op++;
	}
	return 0;
}

static int
isrparenoperand(void)
{
	char *s;

	if (nargc == 1)
		return 0;
	s = *(t_wp + 1);
	if (nargc == 2)
		return parenlevel == 1 && strcmp(s, ")") == 0;
	return 0;
}

/* atoi with error detection */
static int
getn(const char *s)
{
	char *p;
	long r;

	errno = 0;
	r = strtol(s, &p, 10);

	if (s == p)
		error("%s: bad number", s);

	if (errno != 0)
		error((errno == EINVAL) ? "%s: bad number" :
					  "%s: out of range", s);

	while (isspace((unsigned char)*p))
		p++;

	if (*p)
		error("%s: bad number", s);

	return (int) r;
}

/* atoi with error detection and 64 bit range */
static intmax_t
getq(const char *s)
{
	char *p;
	intmax_t r;

	errno = 0;
	r = strtoimax(s, &p, 10);

	if (s == p)
		error("%s: bad number", s);

	if (errno != 0)
		error((errno == EINVAL) ? "%s: bad number" :
					  "%s: out of range", s);

	while (isspace((unsigned char)*p))
		p++;

	if (*p)
		error("%s: bad number", s);

	return r;
}

static int
intcmp (const char *s1, const char *s2)
{
	intmax_t q1, q2;


	q1 = getq(s1);
	q2 = getq(s2);

	if (q1 > q2)
		return 1;

	if (q1 < q2)
		return -1;

	return 0;
}

static int
newerf (const char *f1, const char *f2)
{
	struct stat b1, b2;

	if (stat(f1, &b1) != 0 || stat(f2, &b2) != 0)
		return 0;

	if (b1.st_mtim.tv_sec > b2.st_mtim.tv_sec)
		return 1;
	if (b1.st_mtim.tv_sec < b2.st_mtim.tv_sec)
		return 0;

       return (b1.st_mtim.tv_nsec > b2.st_mtim.tv_nsec);
}

static int
olderf (const char *f1, const char *f2)
{
	return (newerf(f2, f1));
}

static int
equalf (const char *f1, const char *f2)
{
	struct stat b1, b2;

	return (stat (f1, &b1) == 0 &&
		stat (f2, &b2) == 0 &&
		b1.st_dev == b2.st_dev &&
		b1.st_ino == b2.st_ino);
}
Commit	Line	Data
984263bc MD	1	/* $NetBSD: test.c,v 1.21 1999/04/05 09:48:38 kleink Exp $ */
984263bc MD	2
b3967821	3	/*-
984263bc MD	4	* test(1); version 7-like -- author Erik Baalbergen
	5	* modified by Eric Gisin to be used as built-in.
	6	* modified by Arnold Robbins to add SVR3 compatibility
	7	* (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
	8	* modified by J.T. Conklin for NetBSD.
	9	*
	10	* This program is in the Public Domain.
1de703da	11	*
b3967821	12	* $FreeBSD: src/bin/test/test.c,v 1.55 2010/03/28 13:16:08 ed Exp $
984263bc MD	13	*/
984263bc MD	14
984263bc MD	15	#include <sys/types.h>
	16	#include <sys/stat.h>
	17
	18	#include <ctype.h>
	19	#include <err.h>
	20	#include <errno.h>
b3967821	21	#include <inttypes.h>
984263bc MD	22	#include <limits.h>
	23	#include <stdarg.h>
	24	#include <stdio.h>
	25	#include <stdlib.h>
	26	#include <string.h>
	27	#include <unistd.h>
	28
	29	#ifdef SHELL
	30	#define main testcmd
	31	#include "bltin/bltin.h"
99512ac4	32	#include "error.h"
984263bc	33	#else
b3967821 PA	34	#include <locale.h>
	35
	36	static void error(const char *, ...) __dead2 __printf0like(1, 2);
984263bc MD	37
984263bc MD	38	static void
984263bc	39	error(const char *msg, ...)
984263bc MD	40	{
984263bc MD	41	va_list ap;
984263bc	42
984263bc	43	va_start(ap, msg);
984263bc MD	44	verrx(2, msg, ap);
	45	/NOTREACHED/
	46	va_end(ap);
	47	}
	48	#endif
	49
	50	/* test(1) accepts the following grammar:
	51	oexpr ::= aexpr \| aexpr "-o" oexpr ;
	52	aexpr ::= nexpr \| nexpr "-a" aexpr ;
	53	nexpr ::= primary \| "!" primary
	54	primary ::= unary-operator operand
	55	\| operand binary-operator operand
	56	\| operand
	57	\| "(" oexpr ")"
	58	;
	59	unary-operator ::= "-r"\|"-w"\|"-x"\|"-f"\|"-d"\|"-c"\|"-b"\|"-p"\|
	60	"-u"\|"-g"\|"-k"\|"-s"\|"-t"\|"-z"\|"-n"\|"-o"\|"-O"\|"-G"\|"-L"\|"-S";
	61
	62	binary-operator ::= "="\|"!="\|"-eq"\|"-ne"\|"-ge"\|"-gt"\|"-le"\|"-lt"\|
	63	"-nt"\|"-ot"\|"-ef";
	64	operand ::= <any legal UNIX file name>
	65	*/
	66
	67	enum token {
	68	EOI,
	69	FILRD,
	70	FILWR,
	71	FILEX,
	72	FILEXIST,
	73	FILREG,
	74	FILDIR,
	75	FILCDEV,
	76	FILBDEV,
	77	FILFIFO,
	78	FILSOCK,
	79	FILSYM,
	80	FILGZ,
	81	FILTT,
	82	FILSUID,
	83	FILSGID,
	84	FILSTCK,
	85	FILNT,
	86	FILOT,
	87	FILEQ,
	88	FILUID,
	89	FILGID,
	90	STREZ,
	91	STRNZ,
	92	STREQ,
	93	STRNE,
	94	STRLT,
	95	STRGT,
	96	INTEQ,
	97	INTNE,
	98	INTGE,
	99	INTGT,
	100	INTLE,
	101	INTLT,
	102	UNOT,
	103	BAND,
	104	BOR,
	105	LPAREN,
	106	RPAREN,
	107	OPERAND
108	};
109
110	enum token_types {
111	UNOP,
112	BINOP,
113	BUNOP,
114	BBINOP,
115	PAREN
116	};
117
118	struct t_op {
119	const char *op_text;
120	short op_num, op_type;
121	} const ops [] = {
122	{"-r", FILRD, UNOP},
123	{"-w", FILWR, UNOP},
124	{"-x", FILEX, UNOP},
125	{"-e", FILEXIST,UNOP},
126	{"-f", FILREG, UNOP},
127	{"-d", FILDIR, UNOP},
128	{"-c", FILCDEV,UNOP},
129	{"-b", FILBDEV,UNOP},
130	{"-p", FILFIFO,UNOP},
131	{"-u", FILSUID,UNOP},
132	{"-g", FILSGID,UNOP},
133	{"-k", FILSTCK,UNOP},
134	{"-s", FILGZ, UNOP},
135	{"-t", FILTT, UNOP},
136	{"-z", STREZ, UNOP},
137	{"-n", STRNZ, UNOP},
138	{"-h", FILSYM, UNOP}, /* for backwards compat */
139	{"-O", FILUID, UNOP},
140	{"-G", FILGID, UNOP},
141	{"-L", FILSYM, UNOP},
142	{"-S", FILSOCK,UNOP},
143	{"=", STREQ, BINOP},
144	{"!=", STRNE, BINOP},
145	{"<", STRLT, BINOP},
146	{">", STRGT, BINOP},
147	{"-eq", INTEQ, BINOP},
148	{"-ne", INTNE, BINOP},
149	{"-ge", INTGE, BINOP},
150	{"-gt", INTGT, BINOP},
151	{"-le", INTLE, BINOP},
152	{"-lt", INTLT, BINOP},
153	{"-nt", FILNT, BINOP},
154	{"-ot", FILOT, BINOP},
155	{"-ef", FILEQ, BINOP},
156	{"!", UNOT, BUNOP},
157	{"-a", BAND, BBINOP},
158	{"-o", BOR, BBINOP},
159	{"(", LPAREN, PAREN},
160	{")", RPAREN, PAREN},
161	{0, 0, 0}
162	};
163
164	struct t_op const *t_wp_op;
165	int nargc;
166	char **t_wp;
b3967821 PA	167	int parenlevel;
	168
	169	static int aexpr(enum token);
	170	static int binop(void);
	171	static int equalf(const char , const char );
	172	static int filstat(char *, enum token);
	173	static int getn(const char *);
	174	static intmax_t getq(const char *);
	175	static int intcmp(const char , const char );
	176	static int isunopoperand(void);
	177	static int islparenoperand(void);
	178	static int isrparenoperand(void);
	179	static int newerf(const char , const char );
	180	static int nexpr(enum token);
	181	static int oexpr(enum token);
	182	static int olderf(const char , const char );
	183	static int primary(enum token);
	184	static void syntax(const char , const char );
	185	static enum token t_lex(char *);
984263bc MD	186
984263bc MD	187	int
b5744197	188	main(int argc, char **argv)
984263bc MD	189	{
	190	gid_t egid, gid;
	191	uid_t euid, uid;
	192	int res;
	193	char *p;
	194
17b61719	195	if ((p = strrchr(argv[0], '/')) == NULL)
984263bc MD	196	p = argv[0];
	197	else
	198	p++;
	199	if (strcmp(p, "[") == 0) {
	200	if (strcmp(argv[--argc], "]") != 0)
	201	error("missing ]");
	202	argv[argc] = NULL;
	203	}
	204
	205	/* no expression => false */
	206	if (--argc <= 0)
	207	return 1;
	208
b3967821 PA	209	#ifndef SHELL
	210	setlocale(LC_CTYPE, "");
	211	#endif
984263bc MD	212	/* XXX work around the absence of an eaccess(2) syscall */
	213	egid = getegid();
	214	euid = geteuid();
	215	gid = getgid();
	216	uid = getuid();
461f8894 EN	217	setregid(egid, gid);
461f8894 EN	218	setreuid(euid, uid);
984263bc MD	219
	220	nargc = argc;
	221	t_wp = &argv[1];
b3967821 PA	222	parenlevel = 0;
	223	if (nargc == 4 && strcmp(*t_wp, "!") == 0) {
	224	/* Things like ! "" -o x do not fit in the normal grammar. */
	225	--nargc;
	226	++t_wp;
	227	res = oexpr(t_lex(*t_wp));
	228	} else
	229	res = !oexpr(t_lex(*t_wp));
984263bc MD	230
	231	if (--nargc > 0)
	232	syntax(*t_wp, "unexpected operator");
461f8894 EN	233	setregid(gid, egid);
461f8894 EN	234	setreuid(uid, euid);
984263bc MD	235
	236	return res;
	237	}
	238
	239	static void
b5744197	240	syntax(const char op, const char msg)
984263bc MD	241	{
	242
	243	if (op && *op)
	244	error("%s: %s", op, msg);
	245	else
	246	error("%s", msg);
	247	}
	248
	249	static int
b5744197	250	oexpr(enum token n)
984263bc MD	251	{
	252	int res;
	253
	254	res = aexpr(n);
	255	if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BOR)
	256	return oexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) \|\|
	257	res;
	258	t_wp--;
	259	nargc++;
	260	return res;
	261	}
	262
	263	static int
b5744197	264	aexpr(enum token n)
984263bc MD	265	{
	266	int res;
	267
	268	res = nexpr(n);
	269	if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BAND)
	270	return aexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) &&
	271	res;
	272	t_wp--;
	273	nargc++;
	274	return res;
	275	}
	276
	277	static int
b5744197	278	nexpr(enum token n)
984263bc MD	279	{
	280	if (n == UNOT)
	281	return !nexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL));
	282	return primary(n);
	283	}
	284
	285	static int
b5744197	286	primary(enum token n)
984263bc MD	287	{
	288	enum token nn;
	289	int res;
	290
	291	if (n == EOI)
	292	return 0; /* missing expression */
	293	if (n == LPAREN) {
b3967821	294	parenlevel++;
984263bc	295	if ((nn = t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) ==
b3967821 PA	296	RPAREN) {
b3967821 PA	297	parenlevel--;
984263bc	298	return 0; /* missing expression */
b3967821	299	}
984263bc MD	300	res = oexpr(nn);
	301	if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) != RPAREN)
	302	syntax(NULL, "closing paren expected");
b3967821	303	parenlevel--;
984263bc MD	304	return res;
	305	}
	306	if (t_wp_op && t_wp_op->op_type == UNOP) {
	307	/* unary expression */
	308	if (--nargc == 0)
	309	syntax(t_wp_op->op_text, "argument expected");
	310	switch (n) {
	311	case STREZ:
	312	return strlen(*++t_wp) == 0;
	313	case STRNZ:
	314	return strlen(*++t_wp) != 0;
	315	case FILTT:
	316	return isatty(getn(*++t_wp));
	317	default:
	318	return filstat(*++t_wp, n);
	319	}
	320	}
	321
	322	if (t_lex(nargc > 0 ? t_wp[1] : NULL), t_wp_op && t_wp_op->op_type ==
	323	BINOP) {
	324	return binop();
	325	}
	326
	327	return strlen(*t_wp) > 0;
	328	}
	329
	330	static int
b5744197	331	binop(void)
984263bc MD	332	{
	333	const char opnd1, opnd2;
	334	struct t_op const *op;
	335
	336	opnd1 = *t_wp;
461f8894	337	t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL);
984263bc MD	338	op = t_wp_op;
	339
	340	if ((opnd2 = nargc > 0 ? (--nargc, *++t_wp) : NULL) == NULL)
	341	syntax(op->op_text, "argument expected");
	342
	343	switch (op->op_num) {
	344	case STREQ:
	345	return strcmp(opnd1, opnd2) == 0;
	346	case STRNE:
	347	return strcmp(opnd1, opnd2) != 0;
	348	case STRLT:
	349	return strcmp(opnd1, opnd2) < 0;
	350	case STRGT:
	351	return strcmp(opnd1, opnd2) > 0;
	352	case INTEQ:
	353	return intcmp(opnd1, opnd2) == 0;
	354	case INTNE:
	355	return intcmp(opnd1, opnd2) != 0;
	356	case INTGE:
	357	return intcmp(opnd1, opnd2) >= 0;
	358	case INTGT:
	359	return intcmp(opnd1, opnd2) > 0;
	360	case INTLE:
	361	return intcmp(opnd1, opnd2) <= 0;
	362	case INTLT:
	363	return intcmp(opnd1, opnd2) < 0;
	364	case FILNT:
	365	return newerf (opnd1, opnd2);
	366	case FILOT:
	367	return olderf (opnd1, opnd2);
	368	case FILEQ:
	369	return equalf (opnd1, opnd2);
	370	default:
	371	abort();
	372	/* NOTREACHED */
	373	}
	374	}
	375
	376	static int
b5744197	377	filstat(char *nm, enum token mode)
984263bc MD	378	{
	379	struct stat s;
	380
	381	if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s))
	382	return 0;
	383
	384	switch (mode) {
	385	case FILRD:
	386	return access(nm, R_OK) == 0;
	387	case FILWR:
	388	return access(nm, W_OK) == 0;
	389	case FILEX:
	390	/* XXX work around access(2) false positives for superuser */
	391	if (access(nm, X_OK) != 0)
	392	return 0;
	393	if (S_ISDIR(s.st_mode) \|\| getuid() != 0)
	394	return 1;
	395	return (s.st_mode & (S_IXUSR \| S_IXGRP \| S_IXOTH)) != 0;
	396	case FILEXIST:
	397	return access(nm, F_OK) == 0;
	398	case FILREG:
	399	return S_ISREG(s.st_mode);
	400	case FILDIR:
	401	return S_ISDIR(s.st_mode);
	402	case FILCDEV:
	403	return S_ISCHR(s.st_mode);
	404	case FILBDEV:
	405	return S_ISBLK(s.st_mode);
	406	case FILFIFO:
	407	return S_ISFIFO(s.st_mode);
	408	case FILSOCK:
	409	return S_ISSOCK(s.st_mode);
	410	case FILSYM:
	411	return S_ISLNK(s.st_mode);
	412	case FILSUID:
	413	return (s.st_mode & S_ISUID) != 0;
	414	case FILSGID:
	415	return (s.st_mode & S_ISGID) != 0;
	416	case FILSTCK:
	417	return (s.st_mode & S_ISVTX) != 0;
	418	case FILGZ:
	419	return s.st_size > (off_t)0;
	420	case FILUID:
	421	return s.st_uid == geteuid();
	422	case FILGID:
	423	return s.st_gid == getegid();
	424	default:
	425	return 1;
	426	}
	427	}
	428
	429	static enum token
b5744197	430	t_lex(char *s)
984263bc MD	431	{
	432	struct t_op const *op = ops;
	433
	434	if (s == 0) {
	435	t_wp_op = NULL;
	436	return EOI;
	437	}
	438	while (op->op_text) {
	439	if (strcmp(s, op->op_text) == 0) {
b3967821 PA	440	if (((op->op_type == UNOP \|\| op->op_type == BUNOP)
	441	&& isunopoperand()) \|\|
	442	(op->op_num == LPAREN && islparenoperand()) \|\|
	443	(op->op_num == RPAREN && isrparenoperand()))
984263bc MD	444	break;
	445	t_wp_op = op;
	446	return op->op_num;
	447	}
	448	op++;
	449	}
	450	t_wp_op = NULL;
	451	return OPERAND;
	452	}
	453
	454	static int
b3967821	455	isunopoperand(void)
984263bc MD	456	{
	457	struct t_op const *op = ops;
	458	char *s;
	459	char *t;
	460
	461	if (nargc == 1)
	462	return 1;
984263bc	463	s = *(t_wp + 1);
b3967821 PA	464	if (nargc == 2)
b3967821 PA	465	return parenlevel == 1 && strcmp(s, ")") == 0;
984263bc MD	466	t = *(t_wp + 2);
	467	while (op->op_text) {
	468	if (strcmp(s, op->op_text) == 0)
	469	return op->op_type == BINOP &&
b3967821	470	(parenlevel == 0 \|\| t[0] != ')' \|\| t[1] != '\0');
984263bc MD	471	op++;
	472	}
	473	return 0;
	474	}
	475
b3967821 PA	476	static int
	477	islparenoperand(void)
	478	{
	479	struct t_op const *op = ops;
	480	char *s;
	481
	482	if (nargc == 1)
	483	return 1;
	484	s = *(t_wp + 1);
	485	if (nargc == 2)
	486	return parenlevel == 1 && strcmp(s, ")") == 0;
	487	if (nargc != 3)
	488	return 0;
	489	while (op->op_text) {
	490	if (strcmp(s, op->op_text) == 0)
	491	return op->op_type == BINOP;
	492	op++;
	493	}
	494	return 0;
	495	}
	496
	497	static int
	498	isrparenoperand(void)
	499	{
	500	char *s;
	501
	502	if (nargc == 1)
	503	return 0;
	504	s = *(t_wp + 1);
	505	if (nargc == 2)
	506	return parenlevel == 1 && strcmp(s, ")") == 0;
	507	return 0;
	508	}
	509
984263bc MD	510	/* atoi with error detection */
984263bc MD	511	static int
b5744197	512	getn(const char *s)
984263bc MD	513	{
	514	char *p;
	515	long r;
	516
	517	errno = 0;
	518	r = strtol(s, &p, 10);
	519
b3967821 PA	520	if (s == p)
	521	error("%s: bad number", s);
	522
984263bc MD	523	if (errno != 0)
	524	error((errno == EINVAL) ? "%s: bad number" :
	525	"%s: out of range", s);
	526
	527	while (isspace((unsigned char)*p))
	528	p++;
	529
	530	if (*p)
	531	error("%s: bad number", s);
	532
	533	return (int) r;
	534	}
	535
	536	/* atoi with error detection and 64 bit range */
b3967821 PA	537	static intmax_t
b3967821 PA	538	getq(const char *s)
984263bc MD	539	{
984263bc MD	540	char *p;
b3967821	541	intmax_t r;
984263bc MD	542
984263bc MD	543	errno = 0;
b3967821 PA	544	r = strtoimax(s, &p, 10);
	545
	546	if (s == p)
	547	error("%s: bad number", s);
984263bc MD	548
	549	if (errno != 0)
	550	error((errno == EINVAL) ? "%s: bad number" :
	551	"%s: out of range", s);
	552
	553	while (isspace((unsigned char)*p))
	554	p++;
	555
	556	if (*p)
	557	error("%s: bad number", s);
	558
	559	return r;
	560	}
	561
	562	static int
b5744197	563	intcmp (const char s1, const char s2)
984263bc	564	{
b3967821	565	intmax_t q1, q2;
984263bc MD	566
984263bc MD	567
b3967821 PA	568	q1 = getq(s1);
b3967821 PA	569	q2 = getq(s2);
984263bc MD	570
	571	if (q1 > q2)
	572	return 1;
	573
	574	if (q1 < q2)
	575	return -1;
	576
	577	return 0;
	578	}
	579
	580	static int
b5744197	581	newerf (const char f1, const char f2)
984263bc MD	582	{
	583	struct stat b1, b2;
	584
	585	if (stat(f1, &b1) != 0 \|\| stat(f2, &b2) != 0)
	586	return 0;
	587
b3967821	588	if (b1.st_mtim.tv_sec > b2.st_mtim.tv_sec)
984263bc	589	return 1;
b3967821	590	if (b1.st_mtim.tv_sec < b2.st_mtim.tv_sec)
984263bc MD	591	return 0;
984263bc MD	592
b3967821	593	return (b1.st_mtim.tv_nsec > b2.st_mtim.tv_nsec);
984263bc MD	594	}
	595
	596	static int
b5744197	597	olderf (const char f1, const char f2)
984263bc MD	598	{
	599	return (newerf(f2, f1));
	600	}
	601
	602	static int
b5744197	603	equalf (const char f1, const char f2)
984263bc MD	604	{
	605	struct stat b1, b2;
	606
	607	return (stat (f1, &b1) == 0 &&
	608	stat (f2, &b2) == 0 &&
	609	b1.st_dev == b2.st_dev &&
	610	b1.st_ino == b2.st_ino);
	611	}