.Nm test

.Nm test ,

.Nm \&[

.Nm

.Nm test

.Nm

.Nm test

.Bl -tag -width indent

.Bl -tag -width Ar

.Ar file

.Ar file 

.It Fl t Ar [file_descriptor]

.It Fl t Op Ar file_descriptor

(default 1) is open and is

is open and is associated with a terminal.

associated with a terminal.

.Nm

.Nm test

.Nm

.Nm test

.Nm

.Nm test

function is expected to be

utility implements a superset of the

compatible.

specification.

/*-

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

 * Copyright (c) 1992, 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

/*

 *

 * test(1); version 7-like  --  author Erik Baalbergen

 * This code is derived from software contributed to Berkeley by

 * modified by Eric Gisin to be used as built-in.

 * Kenneth Almquist.

 * 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).

 * Redistribution and use in source and binary forms, with or without

 * modified by J.T. Conklin for NetBSD.

 * 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. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *	This product includes software developed by the University of

 *	California, Berkeley and its contributors.

 * 4. 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

 * This program is in the Public Domain.

 * 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/param.h>

#include <sys/types.h>

#define	STACKSIZE	12

/* test(1) accepts the following grammar:

#define	NESTINCR	16

	oexpr	::= aexpr | aexpr "-o" oexpr ;

	aexpr	::= nexpr | nexpr "-a" aexpr ;

/* data types */

	nexpr	::= primary | "!" primary

#define	STRING	0

	primary	::= unary-operator operand

#define	INTEGER	1

		| operand binary-operator operand

#define	BOOLEAN	2

		| operand

		| "(" oexpr ")"

		;

	unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|

		"-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";

#define	IS_BANG(s) (s[0] == '!' && s[1] == '\0')

	binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|

			"-nt"|"-ot"|"-ef";

	operand ::= <any legal UNIX file name>

*/

/*

enum token {

 * This structure hold a value.  The type keyword specifies the type of

	EOI,

 * the value, and the union u holds the value.  The value of a boolean

	FILRD,

 * is stored in u.num (1 = TRUE, 0 = FALSE).

	FILWR,

 */

	FILEX,

struct value {

	FILEXIST,

	int type;

	FILREG,

	union {

	FILDIR,

		char *string;

	FILCDEV,

		long num;

	FILBDEV,

	} u;

	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

struct operator {

enum token_types {

	short op;		/* Which operator. */

	UNOP,

	short pri;		/* Priority of operator. */

	BINOP,

	BUNOP,

	BBINOP,

	PAREN

struct filestat {

struct t_op {

	char *name;		/* Name of file. */

	const char *op_text;

	int rcode;		/* Return code from stat. */

	short op_num, op_type;

	struct stat stat;	/* Status info on file. */

} 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}

static int	expr_is_false __P((struct value *));

struct t_op const *t_wp_op;

static void	expr_operator __P((int, struct value *, struct filestat *));

char **t_wp;

static void	get_int __P((char *, long *));

static int	lookup_op __P((char *, const char *const *));

static void	overflow __P((void));

static int	posix_binary_op __P((char **));

static int	posix_unary_op __P((char **));

static void	syntax __P((void));

	struct operator opstack[STACKSIZE];

	int	res;

	struct operator *opsp;

	struct value valstack[STACKSIZE + 1];

	struct value *valsp;

	struct filestat fs;

	char  c, **ap, *opname, *p;

	int binary, nest, op = 0, pri, ret_val, skipping;

	if ((p = argv[0]) == NULL)

		errx(2, "test: argc is zero");

	if (*p != '\0' && p[strlen(p) - 1] == '[') {

	if (strcmp(argv[0], "[") == 0) {

	/*

	t_wp = &argv[1];

	 * Test(1) implements an inherently ambiguous grammar.  In order to

	res = !oexpr(t_lex(*t_wp));

	 * assure some degree of consistency, we special case the POSIX 1003.2

	 * requirements to assure correct evaluation for POSIX scripts.  The

	 * following special cases comply with POSIX P1003.2/D11.2 Section

	 * 4.62.4.

	 */

	switch(argc - 1) {

	case 0:				/* % test */

		return (1);

		break;

	case 1:				/* % test arg */

		return (argv[1] == NULL || *argv[1] == '\0') ? 1 : 0;

		break;

	case 2:				/* % test op arg */

		opname = argv[1];

		if (IS_BANG(opname))

			return (*argv[2] == '\0') ? 0 : 1;

		else {

			ret_val = posix_unary_op(&argv[1]);

			if (ret_val >= 0)

				return (ret_val);

		}

		break;

	case 3:				/* % test arg1 op arg2 */

		if (IS_BANG(argv[1])) {

			ret_val = posix_unary_op(&argv[1]);

			if (ret_val >= 0)

				return (!ret_val);

		} else if (lookup_op(argv[2], andor_op) < 0) {

			ret_val = posix_binary_op(&argv[1]);

			if (ret_val >= 0)

				return (ret_val);

		}

		break;

	case 4:				/* % test ! arg1 op arg2 */

		if (IS_BANG(argv[1]) && lookup_op(argv[3], andor_op) < 0 ) {

			ret_val = posix_binary_op(&argv[2]);

			if (ret_val >= 0)

				return (!ret_val);

		}

		break;

	default:

		break;

	}

	/*

	if (*t_wp != NULL && *++t_wp != NULL)

	 * We use operator precedence parsing, evaluating the expression as

		syntax(*t_wp, "unexpected operator");

	 * we parse it.  Parentheses are handled by bumping up the priority

	 * of operators using the variable "nest."  We use the variable

	return res;

	 * "skipping" to turn off evaluation temporarily for the short

}

	 * circuit boolean operators.  (It is important do the short circuit

	 * evaluation because under NFS a stat operation can take infinitely

static void

	 * long.)

syntax(op, msg)

	 */

	const char	*op;

	opsp = opstack + STACKSIZE;

	const char	*msg;

	valsp = valstack;

{

	nest = skipping = 0;

	if (op && *op)

	if (*ap == NULL) {

		errx(2, "%s: %s", op, msg);

		valstack[0].type = BOOLEAN;

	else

		valstack[0].u.num = 0;

		errx(2, "%s", msg);

		goto done;

	}

	for (;;) {

		opname = *ap++;

		if (opname == NULL)

			syntax();

		if (opname[0] == '(' && opname[1] == '\0') {

			nest += NESTINCR;

			continue;

		} else if (*ap && (op = lookup_op(opname, unary_op)) >= 0) {

			if (opsp == &opstack[0])

				overflow();

			--opsp;

			opsp->op = op;

			opsp->pri = op_priority[op] + nest;

			continue;

		} else {

			valsp->type = STRING;

			valsp->u.string = opname;

			valsp++;

		}

		for (;;) {

			opname = *ap++;

			if (opname == NULL) {

				if (nest != 0)

					syntax();

				pri = 0;

				break;

			}

			if (opname[0] != ')' || opname[1] != '\0') {

				if ((op = lookup_op(opname, binary_op)) < 0)

					syntax();

				op += FIRST_BINARY_OP;

				pri = op_priority[op] + nest;

				break;

			}

			if ((nest -= NESTINCR) < 0)

				syntax();

		}

		while (opsp < &opstack[STACKSIZE] && opsp->pri >= pri) {

			binary = opsp->op;

			for (;;) {

				valsp--;

				c = op_argflag[opsp->op];

				if (c == OP_INT) {

					if (valsp->type == STRING)

						get_int(valsp->u.string,

						    &valsp->u.num);

					valsp->type = INTEGER;

				} else if (c >= OP_STRING) {

					            /* OP_STRING or OP_FILE */

					if (valsp->type == INTEGER) {

						if ((p = malloc(32)) == NULL)

							err(2, NULL);

#ifdef SHELL

						fmtstr(p, 32, "%d",

						    valsp->u.num);

#else

						(void)sprintf(p,

						    "%ld", valsp->u.num);

#endif

						valsp->u.string = p;

					} else if (valsp->type == BOOLEAN) {

						if (valsp->u.num)

							valsp->u.string =

						            "true";

						else

							valsp->u.string = "";

					}

					valsp->type = STRING;

					if (c == OP_FILE && (fs.name == NULL ||

					    strcmp(fs.name, valsp->u.string))) {

						fs.name = valsp->u.string;

						fs.rcode =

						    stat(valsp->u.string,

                                                    &fs.stat);

					}

				}

				if (binary < FIRST_BINARY_OP)

					break;

				binary = 0;

			}

			if (!skipping)

				expr_operator(opsp->op, valsp, &fs);

			else if (opsp->op == AND1 || opsp->op == OR1)

				skipping--;

			valsp++;		/* push value */

			opsp++;			/* pop operator */

		}

		if (opname == NULL)

			break;

		if (opsp == &opstack[0])

			overflow();

		if (op == AND1 || op == AND2) {

			op = AND1;

			if (skipping || expr_is_false(valsp - 1))

				skipping++;

		}

		if (op == OR1 || op == OR2) {

			op = OR1;

			if (skipping || !expr_is_false(valsp - 1))

				skipping++;

		}

		opsp--;

		opsp->op = op;

		opsp->pri = pri;

	}

done:	return (expr_is_false(&valstack[0]));

expr_is_false(val)

oexpr(n)

	struct value *val;

	enum token n;

	if (val->type == STRING) {

	res = aexpr(n);

		if (val->u.string[0] == '\0')

	if (t_lex(*++t_wp) == BOR)

			return (1);

		return oexpr(t_lex(*++t_wp)) || res;

	} else {		/* INTEGER or BOOLEAN */

	t_wp--;

		if (val->u.num == 0)

	return res;

			return (1);

	}

	return (0);

/*

	res = nexpr(n);

 * Execute an operator.  Op is the operator.  Sp is the stack pointer;

	if (t_lex(*++t_wp) == BAND)

 * sp[0] refers to the first operand, sp[1] refers to the second operand

		return aexpr(t_lex(*++t_wp)) && res;

 * (if any), and the result is placed in sp[0].  The operands are converted

	t_wp--;

 * to the type expected by the operator before expr_operator is called.

	return res;

 * Fs is a pointer to a structure which holds the value of the last call

}

 * to stat, to avoid repeated stat calls on the same file.

 */

static int

static void

nexpr(n)

expr_operator(op, sp, fs)

	enum token n;			/* token */

	int op;

	struct value *sp;

	struct filestat *fs;

	int i;

	if (n == UNOT)

		return !nexpr(t_lex(*++t_wp));

	return primary(n);

}

	switch (op) {

static int

	case NOT:

primary(n)

		sp->u.num = expr_is_false(sp);

	enum token n;

		sp->type = BOOLEAN;

{

		break;

	enum token nn;

	case ISEXIST:

	int res;

exist:

		if (fs == NULL || fs->rcode == -1)

	if (n == EOI)

			goto false;

		return 0;		/* missing expression */

		else

	if (n == LPAREN) {

			goto true;

		if ((nn = t_lex(*++t_wp)) == RPAREN)

	case ISREAD:

			return 0;	/* missing expression */

		if (geteuid() == 0)

		res = oexpr(nn);

			goto exist;

		if (t_lex(*++t_wp) != RPAREN)

		i = S_IROTH;

			syntax(NULL, "closing paren expected");

		goto permission;

		return res;

	case ISWRITE:

	}

		if (geteuid() != 0)

	if (t_wp_op && t_wp_op->op_type == UNOP) {

			i = S_IWOTH;

		/* unary expression */

		else {

		if (*++t_wp == NULL)

			i = S_IWOTH|S_IWGRP|S_IWUSR;

			syntax(t_wp_op->op_text, "argument expected");

			goto filebit;

		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);

		goto permission;

	}

	case ISEXEC:

		if (geteuid() != 0) {

			i = S_IXOTH;

permission:		if (fs->stat.st_uid == geteuid())

				i <<= 6;

			else {

				gid_t grlist[NGROUPS];

				int ngroups, j;

				ngroups = getgroups(NGROUPS, grlist);

	if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) {

				for (j = 0; j < ngroups; j++)

		return binop();

					if (fs->stat.st_gid == grlist[j]) {

	}	  

						i <<= 3;

						goto filebit;

					}

			}

		} else

			i = S_IXOTH|S_IXGRP|S_IXUSR;

		goto filebit;	/* true if (stat.st_mode & i) != 0 */

	case ISFILE:

		i = S_IFREG;

		goto filetype;

	case ISDIR:

		i = S_IFDIR;

		goto filetype;

	case ISCHAR:

		i = S_IFCHR;

		goto filetype;

	case ISBLOCK:

		i = S_IFBLK;

		goto filetype;

	case ISSYMLINK:

		i = S_IFLNK;

		fs->rcode = lstat(sp->u.string, &fs->stat);

		goto filetype;

	case ISFIFO:

		i = S_IFIFO;

		goto filetype;

	case ISSOCK:

		i = S_IFSOCK;

		goto filetype;

filetype:	if ((fs->stat.st_mode & S_IFMT) == i && fs->rcode >= 0)

true:			sp->u.num = 1;

		else

false:			sp->u.num = 0;

		sp->type = BOOLEAN;

		break;

	case ISSETUID:

		i = S_ISUID;

		goto filebit;

	case ISSETGID:

		i = S_ISGID;

		goto filebit;

	case ISSTICKY:

		i = S_ISVTX;

filebit:	if (fs->stat.st_mode & i && fs->rcode >= 0)

			goto true;

		goto false;

	case ISSIZE:

		sp->u.num = fs->rcode >= 0 ? fs->stat.st_size : 0L;

		sp->type = INTEGER;

		break;

	case ISTTY:

		sp->u.num = isatty(sp->u.num);

		sp->type = BOOLEAN;

		break;

	case NULSTR:

		if (sp->u.string[0] == '\0')

			goto true;

		goto false;

	case STRLEN:

		sp->u.num = strlen(sp->u.string);

		sp->type = INTEGER;

		break;

	case OR1:

	case AND1:

		/*

		 * These operators are mostly handled by the parser.  If we

		 * get here it means that both operands were evaluated, so

		 * the value is the value of the second operand.

		 */

		*sp = *(sp + 1);

		break;

	case STREQ:

	case STRNE:

		i = 0;

		if (!strcmp(sp->u.string, (sp + 1)->u.string))

			i++;

		if (op == STRNE)

			i = 1 - i;

		sp->u.num = i;

		sp->type = BOOLEAN;

		break;

	case EQ:

		if (sp->u.num == (sp + 1)->u.num)

			goto true;

		goto false;

	case NE:

		if (sp->u.num != (sp + 1)->u.num)

			goto true;

		goto false;

	case GT:

		if (sp->u.num > (sp + 1)->u.num)

			goto true;

		goto false;

	case LT:

		if (sp->u.num < (sp + 1)->u.num)

			goto true;

		goto false;

	case LE:

		if (sp->u.num <= (sp + 1)->u.num)

			goto true;

		goto false;

	case GE:

		if (sp->u.num >= (sp + 1)->u.num)

			goto true;

		goto false;

	}

	return strlen(*t_wp) > 0;

lookup_op(name, table)

binop()

	char *name;

	const char *const * table;

	const char *const * tp;

	const char *opnd1, *opnd2;

	const char *p;

	struct t_op const *op;

	char c;

	c = name[1];

	opnd1 = *t_wp;

	for (tp = table; (p = *tp) != NULL; tp++)

	(void) t_lex(*++t_wp);

		if (p[1] == c && !strcmp(p, name))

	op = t_wp_op;

			return (tp - table);

	return (-1);

	if ((opnd2 = *++t_wp) == (char *)0)

		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 getn(opnd1) == getn(opnd2);

	case INTNE:

		return getn(opnd1) != getn(opnd2);

	case INTGE:

		return getn(opnd1) >= getn(opnd2);

	case INTGT:

		return getn(opnd1) > getn(opnd2);

	case INTLE:

		return getn(opnd1) <= getn(opnd2);

	case INTLT:

		return getn(opnd1) < getn(opnd2);

	case FILNT:

		return newerf (opnd1, opnd2);

	case FILOT:

		return olderf (opnd1, opnd2);

	case FILEQ:

		return equalf (opnd1, opnd2);

	default:

		abort();

		/* NOTREACHED */

	}

posix_unary_op(argv)

filstat(nm, mode)

	char **argv;

	char *nm;

	enum token mode;

	struct filestat fs;

	struct stat s;

	struct value valp;

	int op, c;

	char *opname;

	opname = *argv;

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

	if ((op = lookup_op(opname, unary_op)) < 0)

		return 0;

		return (-1);

	c = op_argflag[op];

	opname = argv[1];

	valp.u.string = opname;

	if (c == OP_FILE) {

		fs.name = opname;

		fs.rcode = stat(opname, &fs.stat);

	} else if (c != OP_STRING)

		return (-1);

	expr_operator(op, &valp, &fs);

	switch (mode) {

	return (valp.u.num == 0);

	case FILRD:

		return access(nm, R_OK) == 0;

	case FILWR:

		return access(nm, W_OK) == 0;

	case FILEX:

		return access(nm, X_OK) == 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 int

static enum token

posix_binary_op(argv)

t_lex(s)

	char  **argv;

	char *s;

	struct value v[2];

	struct t_op const *op = ops;

	int op, c;

	char *opname;

	opname = argv[1];

	if (s == 0) {

	if ((op = lookup_op(opname, binary_op)) < 0)

		t_wp_op = (struct t_op *)0;

		return (-1);

		return EOI;

	op += FIRST_BINARY_OP;

	}

	c = op_argflag[op];

	while (op->op_text) {

		if (strcmp(s, op->op_text) == 0) {

			if ((op->op_type == UNOP && isoperand()) ||

			    (op->op_num == LPAREN && *(t_wp+1) == 0))

				break;

			t_wp_op = op;

			return op->op_num;

		}

		op++;

	}

	t_wp_op = (struct t_op *)0;

	return OPERAND;

}

	if (c == OP_INT) {

static int

		get_int(argv[0], &v[0].u.num);

isoperand()

		get_int(argv[2], &v[1].u.num);

{

	} else {

	struct t_op const *op = ops;

		v[0].u.string = argv[0];

	char *s;

		v[1].u.string = argv[2];

	char *t;

	if ((s  = *(t_wp+1)) == 0)

		return 1;

	if ((t = *(t_wp+2)) == 0)

		return 0;

	while (op->op_text) {

		if (strcmp(s, op->op_text) == 0)

	    		return op->op_type == BINOP &&

	    		    (t[0] != ')' || t[1] != '\0'); 

		op++;

	expr_operator(op, v, NULL);

	return 0;

	return (v[0].u.num == 0);

/*

/* atoi with error detection */

 * Integer type checking.

static int

 */

getn(s)

static void

	const char *s;

get_int(v, lp)

	char *v;

	long *lp;

	long val;

	char *p;

	char *ep;

	long r;

	for (; *v && isspace(*v); ++v);

	errno = 0;

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

	if(!*v) {

	if (errno != 0)

		*lp = 0;

	  errx(2, "%s: out of range", s);

		return;

	}

	if (isdigit(*v) || ((*v == '-' || *v == '+') && isdigit(*(v+1)))) {

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

		errno = 0;

	  p++;

		val = strtol(v, &ep, 10);

		if (*ep != '\0')

	if (*p)

			errx(2, "%s: trailing non-numeric characters", v);

	  errx(2, "%s: bad number", s);

		if (errno == ERANGE) {

			if (val == LONG_MIN)

	return (int) r;

				errx(2, "%s: underflow", v);

			if (val == LONG_MAX)

				errx(2, "%s: overflow", v);

		}

		*lp = val;

		return;

	}

	errx(2, "%s: expected integer", v);

static void

static int

syntax()

newerf (f1, f2)

	const char *f1, *f2;

	errx(2, "syntax error");

	return (stat (f1, &b1) == 0 &&

		stat (f2, &b2) == 0 &&

		b1.st_mtime > b2.st_mtime);

static void

static int

overflow()

olderf (f1, f2)

	const char *f1, *f2;

	errx(2, "expression is too complex");

	return (stat (f1, &b1) == 0 &&

		stat (f2, &b2) == 0 &&

		b1.st_mtime < b2.st_mtime);

}

static int

equalf (f1, f2)

	const char *f1, *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);