Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	bin/ksh/c_test.c	Lines:	143	216	66.2 %
Date:	2017-11-13	Branches:	117	224	52.2 %


/*	$OpenBSD: c_test.c,v 1.23 2015/12/14 13:59:42 tb 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 Michael Rendell to add Korn's [[ .. ]] expressions.
 * modified by J.T. Conklin to add POSIX compatibility.
 */

#include <sys/stat.h>

#include <string.h>
#include <unistd.h>

#include "sh.h"
#include "c_test.h"

/* test(1) accepts the following grammar:
	oexpr	::= aexpr | aexpr "-o" oexpr ;
	aexpr	::= nexpr | nexpr "-a" aexpr ;
	nexpr	::= primary | "!" nexpr ;
	primary	::= unary-operator operand
		| operand binary-operator operand
		| operand
		| "(" oexpr ")"
		;

	unary-operator ::= "-a"|"-r"|"-w"|"-x"|"-e"|"-f"|"-d"|"-c"|"-b"|"-p"|
			   "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|
			   "-L"|"-h"|"-S"|"-H";

	binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
			    "-nt"|"-ot"|"-ef"|
			    "<"|">"	# rules used for [[ .. ]] expressions
			    ;
	operand ::= <any thing>
*/

#define T_ERR_EXIT	2	/* POSIX says > 1 for errors */

struct t_op {
	char	op_text[4];
	Test_op	op_num;
};
static const struct t_op u_ops [] = {
	{"-a",	TO_FILAXST },
	{"-b",	TO_FILBDEV },
	{"-c",	TO_FILCDEV },
	{"-d",	TO_FILID },
	{"-e",	TO_FILEXST },
	{"-f",	TO_FILREG },
	{"-G",	TO_FILGID },
	{"-g",	TO_FILSETG },
	{"-h",	TO_FILSYM },
	{"-H",	TO_FILCDF },
	{"-k",	TO_FILSTCK },
	{"-L",	TO_FILSYM },
	{"-n",	TO_STNZE },
	{"-O",	TO_FILUID },
	{"-o",	TO_OPTION },
	{"-p",	TO_FILFIFO },
	{"-r",	TO_FILRD },
	{"-s",	TO_FILGZ },
	{"-S",	TO_FILSOCK },
	{"-t",	TO_FILTT },
	{"-u",	TO_FILSETU },
	{"-w",	TO_FILWR },
	{"-x",	TO_FILEX },
	{"-z",	TO_STZER },
	{"",	TO_NONOP }
};
static const struct t_op b_ops [] = {
	{"=",	TO_STEQL },
	{"==",	TO_STEQL },
	{"!=",	TO_STNEQ },
	{"<",	TO_STLT },
	{">",	TO_STGT },
	{"-eq",	TO_INTEQ },
	{"-ne",	TO_INTNE },
	{"-gt",	TO_INTGT },
	{"-ge",	TO_INTGE },
	{"-lt",	TO_INTLT },
	{"-le",	TO_INTLE },
	{"-ef",	TO_FILEQ },
	{"-nt",	TO_FILNT },
	{"-ot",	TO_FILOT },
	{"",	TO_NONOP }
};

static int	test_stat(const char *, struct stat *);
static int	test_eaccess(const char *, int);
static int	test_oexpr(Test_env *, int);
static int	test_aexpr(Test_env *, int);
static int	test_nexpr(Test_env *, int);
static int	test_primary(Test_env *, int);
static int	ptest_isa(Test_env *, Test_meta);
static const char *ptest_getopnd(Test_env *, Test_op, int);
static int	ptest_eval(Test_env *, Test_op, const char *,
		    const char *, int);
static void	ptest_error(Test_env *, int, const char *);

int
c_test(char **wp)
{
	int argc;
	int res;
	Test_env te;

	te.flags = 0;
	te.isa = ptest_isa;
	te.getopnd = ptest_getopnd;
	te.eval = ptest_eval;
	te.error = ptest_error;

	for (argc = 0; wp[argc]; argc++)
		;

	if (strcmp(wp[0], "[") == 0) {
		if (strcmp(wp[--argc], "]") != 0) {
			bi_errorf("missing ]");
			return T_ERR_EXIT;
		}
	}

	te.pos.wp = wp + 1;
	te.wp_end = wp + argc;

	/*
	 * Handle the special cases from POSIX.2, section 4.62.4.
	 * Implementation of all the rules isn't necessary since
	 * our parser does the right thing for the omitted steps.
	 */
	if (argc <= 5) {
		char **owp = wp;
		int invert = 0;
		Test_op	op;
		const char *opnd1, *opnd2;

		while (--argc >= 0) {
			if ((*te.isa)(&te, TM_END))
				return !0;
			if (argc == 3) {
				opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
				if ((op = (Test_op) (*te.isa)(&te, TM_BINOP))) {
					opnd2 = (*te.getopnd)(&te, op, 1);
					res = (*te.eval)(&te, op, opnd1,
					    opnd2, 1);
					if (te.flags & TEF_ERROR)
						return T_ERR_EXIT;
					if (invert & 1)
						res = !res;
					return !res;
				}
				/* back up to opnd1 */
				te.pos.wp--;
			}
			if (argc == 1) {
				opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
				/* Historically, -t by itself test if fd 1
				 * is a file descriptor, but POSIX says its
				 * a string test...
				 */
				if (!Flag(FPOSIX) && strcmp(opnd1, "-t") == 0)
				    break;
				res = (*te.eval)(&te, TO_STNZE, opnd1,
				    NULL, 1);
				if (invert & 1)
					res = !res;
				return !res;
			}
			if ((*te.isa)(&te, TM_NOT)) {
				invert++;
			} else
				break;
		}
		te.pos.wp = owp + 1;
	}

	return test_parse(&te);
}

/*
 * Generic test routines.
 */

Test_op
test_isop(Test_env *te, Test_meta meta, const char *s)
{
	char sc1;
	const struct t_op *otab;

	otab = meta == TM_UNOP ? u_ops : b_ops;
	if (*s) {
		sc1 = s[1];
		for (; otab->op_text[0]; otab++)
			if (sc1 == otab->op_text[1] &&
			    strcmp(s, otab->op_text) == 0 &&
			    ((te->flags & TEF_DBRACKET) ||
			    (otab->op_num != TO_STLT && otab->op_num != TO_STGT)))
				return otab->op_num;
	}
	return TO_NONOP;
}

int
test_eval(Test_env *te, Test_op op, const char *opnd1, const char *opnd2,
    int do_eval)
{
	int res;
	int not;
	struct stat b1, b2;

	if (!do_eval)
		return 0;

	switch ((int) op) {
	/*
	 * Unary Operators
	 */
	case TO_STNZE: /* -n */
		return *opnd1 != '\0';
	case TO_STZER: /* -z */
		return *opnd1 == '\0';
	case TO_OPTION: /* -o */
		if ((not = *opnd1 == '!'))
			opnd1++;
		if ((res = option(opnd1)) < 0)
			res = 0;
		else {
			res = Flag(res);
			if (not)
				res = !res;
		}
		return res;
	case TO_FILRD: /* -r */
		return test_eaccess(opnd1, R_OK) == 0;
	case TO_FILWR: /* -w */
		return test_eaccess(opnd1, W_OK) == 0;
	case TO_FILEX: /* -x */
		return test_eaccess(opnd1, X_OK) == 0;
	case TO_FILAXST: /* -a */
		return test_stat(opnd1, &b1) == 0;
	case TO_FILEXST: /* -e */
		/* at&t ksh does not appear to do the /dev/fd/ thing for
		 * this (unless the os itself handles it)
		 */
		return stat(opnd1, &b1) == 0;
	case TO_FILREG: /* -r */
		return test_stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode);
	case TO_FILID: /* -d */
		return test_stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode);
	case TO_FILCDEV: /* -c */
		return test_stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode);
	case TO_FILBDEV: /* -b */
		return test_stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode);
	case TO_FILFIFO: /* -p */
		return test_stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode);
	case TO_FILSYM: /* -h -L */
		return lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode);
	case TO_FILSOCK: /* -S */
		return test_stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode);
	case TO_FILCDF:/* -H HP context dependent files (directories) */
		return 0;
	case TO_FILSETU: /* -u */
		return test_stat(opnd1, &b1) == 0 &&
		    (b1.st_mode & S_ISUID) == S_ISUID;
	case TO_FILSETG: /* -g */
		return test_stat(opnd1, &b1) == 0 &&
		    (b1.st_mode & S_ISGID) == S_ISGID;
	case TO_FILSTCK: /* -k */
		return test_stat(opnd1, &b1) == 0 &&
		    (b1.st_mode & S_ISVTX) == S_ISVTX;
	case TO_FILGZ: /* -s */
		return test_stat(opnd1, &b1) == 0 && b1.st_size > 0L;
	case TO_FILTT: /* -t */
		if (opnd1 && !bi_getn(opnd1, &res)) {
			te->flags |= TEF_ERROR;
			res = 0;
		} else {
			/* generate error if in FPOSIX mode? */
			res = isatty(opnd1 ? res : 0);
		}
		return res;
	case TO_FILUID: /* -O */
		return test_stat(opnd1, &b1) == 0 && b1.st_uid == ksheuid;
	case TO_FILGID: /* -G */
		return test_stat(opnd1, &b1) == 0 && b1.st_gid == getegid();
	/*
	 * Binary Operators
	 */
	case TO_STEQL: /* = */
		if (te->flags & TEF_DBRACKET)
			return gmatch(opnd1, opnd2, false);
		return strcmp(opnd1, opnd2) == 0;
	case TO_STNEQ: /* != */
		if (te->flags & TEF_DBRACKET)
			return !gmatch(opnd1, opnd2, false);
		return strcmp(opnd1, opnd2) != 0;
	case TO_STLT: /* < */
		return strcmp(opnd1, opnd2) < 0;
	case TO_STGT: /* > */
		return strcmp(opnd1, opnd2) > 0;
	case TO_INTEQ: /* -eq */
	case TO_INTNE: /* -ne */
	case TO_INTGE: /* -ge */
	case TO_INTGT: /* -gt */
	case TO_INTLE: /* -le */
	case TO_INTLT: /* -lt */
		{
			long v1, v2;

			if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR, false) ||
			    !evaluate(opnd2, &v2, KSH_RETURN_ERROR, false)) {
				/* error already printed.. */
				te->flags |= TEF_ERROR;
				return 1;
			}
			switch ((int) op) {
			case TO_INTEQ:
				return v1 == v2;
			case TO_INTNE:
				return v1 != v2;
			case TO_INTGE:
				return v1 >= v2;
			case TO_INTGT:
				return v1 > v2;
			case TO_INTLE:
				return v1 <= v2;
			case TO_INTLT:
				return v1 < v2;
			}
		}
	case TO_FILNT: /* -nt */
		{
			int s2;
			/* ksh88/ksh93 succeed if file2 can't be stated
			 * (subtly different from `does not exist').
			 */
			return stat(opnd1, &b1) == 0 &&
			    (((s2 = stat(opnd2, &b2)) == 0 &&
			    b1.st_mtime > b2.st_mtime) || s2 < 0);
		}
	case TO_FILOT: /* -ot */
		{
			int s1;
			/* ksh88/ksh93 succeed if file1 can't be stated
			 * (subtly different from `does not exist').
			 */
			return stat(opnd2, &b2) == 0 &&
			    (((s1 = stat(opnd1, &b1)) == 0 &&
			    b1.st_mtime < b2.st_mtime) || s1 < 0);
		}
	case TO_FILEQ: /* -ef */
		return stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0 &&
		    b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino;
	}
	(*te->error)(te, 0, "internal error: unknown op");
	return 1;
}

/* Nasty kludge to handle Korn's bizarre /dev/fd hack */
static int
test_stat(const char *path, struct stat *statb)
{
	return stat(path, statb);
}

/* Routine to handle Korn's /dev/fd hack, and to deal with X_OK on
 * non-directories when running as root.
 */
static int
test_eaccess(const char *path, int mode)
{
	int res;

	res = access(path, mode);
	/*
	 * On most (all?) unixes, access() says everything is executable for
	 * root - avoid this on files by using stat().
	 */
	if (res == 0 && ksheuid == 0 && (mode & X_OK)) {
		struct stat statb;

		if (stat(path, &statb) < 0)
			res = -1;
		else if (S_ISDIR(statb.st_mode))
			res = 0;
		else
			res = (statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) ?
			    0 : -1;
	}

	return res;
}

int
test_parse(Test_env *te)
{
	int res;

	res = test_oexpr(te, 1);

	if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END))
		(*te->error)(te, 0, "unexpected operator/operand");

	return (te->flags & TEF_ERROR) ? T_ERR_EXIT : !res;
}

static int
test_oexpr(Test_env *te, int do_eval)
{
	int res;

	res = test_aexpr(te, do_eval);
	if (res)
		do_eval = 0;
	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR))
		return test_oexpr(te, do_eval) || res;
	return res;
}

static int
test_aexpr(Test_env *te, int do_eval)
{
	int res;

	res = test_nexpr(te, do_eval);
	if (!res)
		do_eval = 0;
	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND))
		return test_aexpr(te, do_eval) && res;
	return res;
}

static int
test_nexpr(Test_env *te, int do_eval)
{
	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT))
		return !test_nexpr(te, do_eval);
	return test_primary(te, do_eval);
}

static int
test_primary(Test_env *te, int do_eval)
{
	const char *opnd1, *opnd2;
	int res;
	Test_op op;

	if (te->flags & TEF_ERROR)
		return 0;
	if ((*te->isa)(te, TM_OPAREN)) {
		res = test_oexpr(te, do_eval);
		if (te->flags & TEF_ERROR)
			return 0;
		if (!(*te->isa)(te, TM_CPAREN)) {
			(*te->error)(te, 0, "missing closing paren");
			return 0;
		}
		return res;
	}
	/*
	 * Binary should have precedence over unary in this case
	 * so that something like test \( -f = -f \) is accepted
	 */
	if ((te->flags & TEF_DBRACKET) || (&te->pos.wp[1] < te->wp_end &&
	    !test_isop(te, TM_BINOP, te->pos.wp[1]))) {
		if ((op = (Test_op) (*te->isa)(te, TM_UNOP))) {
			/* unary expression */
			opnd1 = (*te->getopnd)(te, op, do_eval);
			if (!opnd1) {
				(*te->error)(te, -1, "missing argument");
				return 0;
			}

			return (*te->eval)(te, op, opnd1, NULL,
			    do_eval);
		}
	}
	opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval);
	if (!opnd1) {
		(*te->error)(te, 0, "expression expected");
		return 0;
	}
	if ((op = (Test_op) (*te->isa)(te, TM_BINOP))) {
		/* binary expression */
		opnd2 = (*te->getopnd)(te, op, do_eval);
		if (!opnd2) {
			(*te->error)(te, -1, "missing second argument");
			return 0;
		}

		return (*te->eval)(te, op, opnd1, opnd2, do_eval);
	}
	if (te->flags & TEF_DBRACKET) {
		(*te->error)(te, -1, "missing expression operator");
		return 0;
	}
	return (*te->eval)(te, TO_STNZE, opnd1, NULL, do_eval);
}

/*
 * Plain test (test and [ .. ]) specific routines.
 */

/* Test if the current token is a whatever.  Accepts the current token if
 * it is.  Returns 0 if it is not, non-zero if it is (in the case of
 * TM_UNOP and TM_BINOP, the returned value is a Test_op).
 */
static int
ptest_isa(Test_env *te, Test_meta meta)
{
	/* Order important - indexed by Test_meta values */
	static const char *const tokens[] = {
		"-o", "-a", "!", "(", ")"
	};
	int ret;

	if (te->pos.wp >= te->wp_end)
		return meta == TM_END;

	if (meta == TM_UNOP || meta == TM_BINOP)
		ret = (int) test_isop(te, meta, *te->pos.wp);
	else if (meta == TM_END)
		ret = 0;
	else
		ret = strcmp(*te->pos.wp, tokens[(int) meta]) == 0;

	/* Accept the token? */
	if (ret)
		te->pos.wp++;

	return ret;
}

static const char *
ptest_getopnd(Test_env *te, Test_op op, int do_eval)
{
	if (te->pos.wp >= te->wp_end)
		return op == TO_FILTT ? "1" : NULL;
	return *te->pos.wp++;
}

static int
ptest_eval(Test_env *te, Test_op op, const char *opnd1, const char *opnd2,
    int do_eval)
{
	return test_eval(te, op, opnd1, opnd2, do_eval);
}

static void
ptest_error(Test_env *te, int offset, const char *msg)
{
	const char *op = te->pos.wp + offset >= te->wp_end ?
	    NULL : te->pos.wp[offset];

	te->flags |= TEF_ERROR;
	if (op)
		bi_errorf("%s: %s", op, msg);
	else
		bi_errorf("%s", msg);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: c_test.c,v 1.23 2015/12/14 13:59:42 tb Exp $ */
2
3			/*
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 Michael Rendell to add Korn's [[ .. ]] expressions.
9			* modified by J.T. Conklin to add POSIX compatibility.
10			*/
11
12			#include <sys/stat.h>
13
14			#include <string.h>
15			#include <unistd.h>
16
17			#include "sh.h"
18			#include "c_test.h"
19
20			/* test(1) accepts the following grammar:
21			oexpr ::= aexpr \| aexpr "-o" oexpr ;
22			aexpr ::= nexpr \| nexpr "-a" aexpr ;
23			nexpr ::= primary \| "!" nexpr ;
24			primary ::= unary-operator operand
25			\| operand binary-operator operand
26			\| operand
27			\| "(" oexpr ")"
28			;
29
30			unary-operator ::= "-a"\|"-r"\|"-w"\|"-x"\|"-e"\|"-f"\|"-d"\|"-c"\|"-b"\|"-p"\|
31			"-u"\|"-g"\|"-k"\|"-s"\|"-t"\|"-z"\|"-n"\|"-o"\|"-O"\|"-G"\|
32			"-L"\|"-h"\|"-S"\|"-H";
33
34			binary-operator ::= "="\|"=="\|"!="\|"-eq"\|"-ne"\|"-ge"\|"-gt"\|"-le"\|"-lt"\|
35			"-nt"\|"-ot"\|"-ef"\|
36			"<"\|">" # rules used for [[ .. ]] expressions
37			;
38			operand ::= <any thing>
39			*/
40
41			#define T_ERR_EXIT 2 /* POSIX says > 1 for errors */
42
43			struct t_op {
44			char op_text[4];
45			Test_op op_num;
46			};
47			static const struct t_op u_ops [] = {
48			{"-a", TO_FILAXST },
49			{"-b", TO_FILBDEV },
50			{"-c", TO_FILCDEV },
51			{"-d", TO_FILID },
52			{"-e", TO_FILEXST },
53			{"-f", TO_FILREG },
54			{"-G", TO_FILGID },
55			{"-g", TO_FILSETG },
56			{"-h", TO_FILSYM },
57			{"-H", TO_FILCDF },
58			{"-k", TO_FILSTCK },
59			{"-L", TO_FILSYM },
60			{"-n", TO_STNZE },
61			{"-O", TO_FILUID },
62			{"-o", TO_OPTION },
63			{"-p", TO_FILFIFO },
64			{"-r", TO_FILRD },
65			{"-s", TO_FILGZ },
66			{"-S", TO_FILSOCK },
67			{"-t", TO_FILTT },
68			{"-u", TO_FILSETU },
69			{"-w", TO_FILWR },
70			{"-x", TO_FILEX },
71			{"-z", TO_STZER },
72			{"", TO_NONOP }
73			};
74			static const struct t_op b_ops [] = {
75			{"=", TO_STEQL },
76			{"==", TO_STEQL },
77			{"!=", TO_STNEQ },
78			{"<", TO_STLT },
79			{">", TO_STGT },
80			{"-eq", TO_INTEQ },
81			{"-ne", TO_INTNE },
82			{"-gt", TO_INTGT },
83			{"-ge", TO_INTGE },
84			{"-lt", TO_INTLT },
85			{"-le", TO_INTLE },
86			{"-ef", TO_FILEQ },
87			{"-nt", TO_FILNT },
88			{"-ot", TO_FILOT },
89			{"", TO_NONOP }
90			};
91
92			static int test_stat(const char , struct stat );
93			static int test_eaccess(const char *, int);
94			static int test_oexpr(Test_env *, int);
95			static int test_aexpr(Test_env *, int);
96			static int test_nexpr(Test_env *, int);
97			static int test_primary(Test_env *, int);
98			static int ptest_isa(Test_env *, Test_meta);
99			static const char ptest_getopnd(Test_env , Test_op, int);
100			static int ptest_eval(Test_env , Test_op, const char ,
101			const char *, int);
102			static void ptest_error(Test_env , int, const char );
103
104			int
105			c_test(char **wp)
106			{
107			int argc;
108			int res;
109		2774416	Test_env te;
110
111		1387208	te.flags = 0;
112		1387208	te.isa = ptest_isa;
113		1387208	te.getopnd = ptest_getopnd;
114		1387208	te.eval = ptest_eval;
115		1387208	te.error = ptest_error;
116
117	✓✓	15773552	for (argc = 0; wp[argc]; argc++)
118			;
119
120	✓✓	1387208	if (strcmp(wp[0], "[") == 0) {
121	✗✓	1330148	if (strcmp(wp[--argc], "]") != 0) {
122			bi_errorf("missing ]");
123			return T_ERR_EXIT;
124			}
125			}
126
127		1387208	te.pos.wp = wp + 1;
128		1387208	te.wp_end = wp + argc;
129
130			/*
131			* Handle the special cases from POSIX.2, section 4.62.4.
132			* Implementation of all the rules isn't necessary since
133			* our parser does the right thing for the omitted steps.
134			*/
135	✓✓	1387208	if (argc <= 5) {
136			char **owp = wp;
137			int invert = 0;
138			Test_op op;
139			const char opnd1, opnd2;
140
141	✓✗	2762592	while (--argc >= 0) {
142	✗✓	1381296	if ((*te.isa)(&te, TM_END))
143			return !0;
144	✓✓	1381296	if (argc == 3) {
145		976579	opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
146	✓✓	976579	if ((op = (Test_op) (*te.isa)(&te, TM_BINOP))) {
147		976218	opnd2 = (*te.getopnd)(&te, op, 1);
148		976218	res = (*te.eval)(&te, op, opnd1,
149			opnd2, 1);
150	✗✓	976218	if (te.flags & TEF_ERROR)
151			return T_ERR_EXIT;
152	✗✓	976218	if (invert & 1)
153			res = !res;
154		976218	return !res;
155			}
156			/* back up to opnd1 */
157		361	te.pos.wp--;
158		361	}
159	✓✓	405078	if (argc == 1) {
160		84	opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
161			/* Historically, -t by itself test if fd 1
162			* is a file descriptor, but POSIX says its
163			* a string test...
164			*/
165	✓✗✓✗	168	if (!Flag(FPOSIX) && strcmp(opnd1, "-t") == 0)
166			break;
167		84	res = (*te.eval)(&te, TO_STNZE, opnd1,
168			NULL, 1);
169	✗✓	84	if (invert & 1)
170			res = !res;
171		84	return !res;
172			}
173	✓✓	404994	if ((*te.isa)(&te, TM_NOT)) {
174		361	invert++;
175			} else
176			break;
177			}
178		404633	te.pos.wp = owp + 1;
179	✓✓	404633	}
180
181		410906	return test_parse(&te);
182		1387208	}
183
184			/*
185			* Generic test routines.
186			*/
187
188			Test_op
189			test_isop(Test_env te, Test_meta meta, const char s)
190			{
191			char sc1;
192			const struct t_op *otab;
193
194		3649002	otab = meta == TM_UNOP ? u_ops : b_ops;
195	✓✓	1824501	if (*s) {
196		1699926	sc1 = s[1];
197	✓✓	31074276	for (; otab->op_text[0]; otab++)
198	✓✓✓✗	16662492	if (sc1 == otab->op_text[1] &&
199	✓✓	2289631	strcmp(s, otab->op_text) == 0 &&
200	✓✓	1419422	((te->flags & TEF_DBRACKET) \|\|
201	✓✗	2811716	(otab->op_num != TO_STLT && otab->op_num != TO_STGT)))
202		1419422	return otab->op_num;
203			}
204		405079	return TO_NONOP;
205		1824501	}
206
207			int
208			test_eval(Test_env te, Test_op op, const char opnd1, const char *opnd2,
209			int do_eval)
210			{
211		2813430	int res;
212			int not;
213		1406715	struct stat b1, b2;
214
215	✓✓	1406715	if (!do_eval)
216		4307	return 0;
217
218	✓✓✗✗ ✓✓✗✓ ✓✓✓✗ ✗✓✗✗ ✗✗✗✓ ✗✗✗✓ ✓✗✗✗ ✗✗✗✗ ✓✓✓✗ ✗	1402408	switch ((int) op) {
219			/*
220			* Unary Operators
221			*/
222			case TO_STNZE: /* -n */
223		177014	return *opnd1 != '\0';
224			case TO_STZER: /* -z */
225		213659	return *opnd1 == '\0';
226			case TO_OPTION: /* -o */
227			if ((not = *opnd1 == '!'))
228			opnd1++;
229			if ((res = option(opnd1)) < 0)
230			res = 0;
231			else {
232			res = Flag(res);
233			if (not)
234			res = !res;
235			}
236			return res;
237			case TO_FILRD: /* -r */
238			return test_eaccess(opnd1, R_OK) == 0;
239			case TO_FILWR: /* -w */
240		10	return test_eaccess(opnd1, W_OK) == 0;
241			case TO_FILEX: /* -x */
242		49	return test_eaccess(opnd1, X_OK) == 0;
243			case TO_FILAXST: /* -a */
244			return test_stat(opnd1, &b1) == 0;
245			case TO_FILEXST: /* -e */
246			/* at&t ksh does not appear to do the /dev/fd/ thing for
247			* this (unless the os itself handles it)
248			*/
249		6314	return stat(opnd1, &b1) == 0;
250			case TO_FILREG: /* -r */
251	✓✓	1785	return test_stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode);
252			case TO_FILID: /* -d */
253	✓✓	13787	return test_stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode);
254			case TO_FILCDEV: /* -c */
255	✓✗	12	return test_stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode);
256			case TO_FILBDEV: /* -b */
257			return test_stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode);
258			case TO_FILFIFO: /* -p */
259			return test_stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode);
260			case TO_FILSYM: /* -h -L */
261	✓✓	256	return lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode);
262			case TO_FILSOCK: /* -S */
263			return test_stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode);
264			case TO_FILCDF:/* -H HP context dependent files (directories) */
265			return 0;
266			case TO_FILSETU: /* -u */
267			return test_stat(opnd1, &b1) == 0 &&
268			(b1.st_mode & S_ISUID) == S_ISUID;
269			case TO_FILSETG: /* -g */
270			return test_stat(opnd1, &b1) == 0 &&
271			(b1.st_mode & S_ISGID) == S_ISGID;
272			case TO_FILSTCK: /* -k */
273			return test_stat(opnd1, &b1) == 0 &&
274			(b1.st_mode & S_ISVTX) == S_ISVTX;
275			case TO_FILGZ: /* -s */
276		205	return test_stat(opnd1, &b1) == 0 && b1.st_size > 0L;
277			case TO_FILTT: /* -t */
278			if (opnd1 && !bi_getn(opnd1, &res)) {
279			te->flags \|= TEF_ERROR;
280			res = 0;
281			} else {
282			/* generate error if in FPOSIX mode? */
283			res = isatty(opnd1 ? res : 0);
284			}
285			return res;
286			case TO_FILUID: /* -O */
287			return test_stat(opnd1, &b1) == 0 && b1.st_uid == ksheuid;
288			case TO_FILGID: /* -G */
289			return test_stat(opnd1, &b1) == 0 && b1.st_gid == getegid();
290			/*
291			* Binary Operators
292			*/
293			case TO_STEQL: /* = */
294	✓✓	119694	if (te->flags & TEF_DBRACKET)
295		13136	return gmatch(opnd1, opnd2, false);
296		106558	return strcmp(opnd1, opnd2) == 0;
297			case TO_STNEQ: /* != */
298	✗✓	674384	if (te->flags & TEF_DBRACKET)
299			return !gmatch(opnd1, opnd2, false);
300		674384	return strcmp(opnd1, opnd2) != 0;
301			case TO_STLT: /* < */
302			return strcmp(opnd1, opnd2) < 0;
303			case TO_STGT: /* > */
304			return strcmp(opnd1, opnd2) > 0;
305			case TO_INTEQ: /* -eq */
306			case TO_INTNE: /* -ne */
307			case TO_INTGE: /* -ge */
308			case TO_INTGT: /* -gt */
309			case TO_INTLE: /* -le */
310			case TO_INTLT: /* -lt */
311			{
312		203433	long v1, v2;
313
314	✓✗✗✓	406866	if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR, false) \|\|
315		203433	!evaluate(opnd2, &v2, KSH_RETURN_ERROR, false)) {
316			/* error already printed.. */
317			te->flags \|= TEF_ERROR;
318			return 1;
319			}
320	✓✓✗✓ ✗✓✗	203433	switch ((int) op) {
321			case TO_INTEQ:
322		989	return v1 == v2;
323			case TO_INTNE:
324		35619	return v1 != v2;
325			case TO_INTGE:
326			return v1 >= v2;
327			case TO_INTGT:
328		145705	return v1 > v2;
329			case TO_INTLE:
330			return v1 <= v2;
331			case TO_INTLT:
332		21120	return v1 < v2;
333			}
334	✗✓	203433	}
335			case TO_FILNT: /* -nt */
336			{
337			int s2;
338			/* ksh88/ksh93 succeed if file2 can't be stated
339			* (subtly different from `does not exist').
340			*/
341	✓✗	12	return stat(opnd1, &b1) == 0 &&
342	✗✓	6	(((s2 = stat(opnd2, &b2)) == 0 &&
343	✗✗	6	b1.st_mtime > b2.st_mtime) \|\| s2 < 0);
344			}
345			case TO_FILOT: /* -ot */
346			{
347			int s1;
348			/* ksh88/ksh93 succeed if file1 can't be stated
349			* (subtly different from `does not exist').
350			*/
351	✓✗	12	return stat(opnd2, &b2) == 0 &&
352	✗✓	6	(((s1 = stat(opnd1, &b1)) == 0 &&
353	✗✗	6	b1.st_mtime < b2.st_mtime) \|\| s1 < 0);
354			}
355			case TO_FILEQ: /* -ef */
356			return stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0 &&
357			b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino;
358			}
359			(*te->error)(te, 0, "internal error: unknown op");
360			return 1;
361		1406715	}
362
363			/* Nasty kludge to handle Korn's bizarre /dev/fd hack */
364			static int
365			test_stat(const char path, struct stat statb)
366			{
367		15486	return stat(path, statb);
368			}
369
370			/* Routine to handle Korn's /dev/fd hack, and to deal with X_OK on
371			* non-directories when running as root.
372			*/
373			static int
374			test_eaccess(const char *path, int mode)
375			{
376			int res;
377
378		118	res = access(path, mode);
379			/*
380			* On most (all?) unixes, access() says everything is executable for
381			* root - avoid this on files by using stat().
382			*/
383	✓✗✓✓	118	if (res == 0 && ksheuid == 0 && (mode & X_OK)) {
384		49	struct stat statb;
385
386	✗✓	49	if (stat(path, &statb) < 0)
387			res = -1;
388	✗✓	49	else if (S_ISDIR(statb.st_mode))
389			res = 0;
390			else
391		49	res = (statb.st_mode & (S_IXUSR\|S_IXGRP\|S_IXOTH)) ?
392			0 : -1;
393		49	}
394
395		59	return res;
396			}
397
398			int
399			test_parse(Test_env *te)
400			{
401			int res;
402
403		848940	res = test_oexpr(te, 1);
404
405	✓✗✗✓	848940	if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END))
406			(*te->error)(te, 0, "unexpected operator/operand");
407
408	✓✗	1273410	return (te->flags & TEF_ERROR) ? T_ERR_EXIT : !res;
409			}
410
411			static int
412			test_oexpr(Test_env *te, int do_eval)
413			{
414			int res;
415
416		861386	res = test_aexpr(te, do_eval);
417	✓✓	430693	if (res)
418		145694	do_eval = 0;
419	✓✗✓✓	861386	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR))
420		6223	return test_oexpr(te, do_eval) \|\| res;
421		424470	return res;
422		430693	}
423
424			static int
425			test_aexpr(Test_env *te, int do_eval)
426			{
427			int res;
428
429		861486	res = test_nexpr(te, do_eval);
430	✓✓	430743	if (!res)
431		285014	do_eval = 0;
432	✓✗✓✓	861486	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND))
433		50	return test_aexpr(te, do_eval) && res;
434		430693	return res;
435		430743	}
436
437			static int
438			test_nexpr(Test_env *te, int do_eval)
439			{
440	✓✗✓✓	1293375	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT))
441		382	return !test_nexpr(te, do_eval);
442		430743	return test_primary(te, do_eval);
443		431125	}
444
445			static int
446			test_primary(Test_env *te, int do_eval)
447			{
448			const char opnd1, opnd2;
449			int res;
450			Test_op op;
451
452	✗✓	861486	if (te->flags & TEF_ERROR)
453			return 0;
454	✗✓	430743	if ((*te->isa)(te, TM_OPAREN)) {
455			res = test_oexpr(te, do_eval);
456			if (te->flags & TEF_ERROR)
457			return 0;
458			if (!(*te->isa)(te, TM_CPAREN)) {
459			(*te->error)(te, 0, "missing closing paren");
460			return 0;
461			}
462			return res;
463			}
464			/*
465			* Binary should have precedence over unary in this case
466			* so that something like test \( -f = -f \) is accepted
467			*/
468	✓✓✓✗ ✓✓	1265101	if ((te->flags & TEF_DBRACKET) \|\| (&te->pos.wp[1] < te->wp_end &&
469		417179	!test_isop(te, TM_BINOP, te->pos.wp[1]))) {
470	✓✓	418282	if ((op = (Test_op) (*te->isa)(te, TM_UNOP))) {
471			/* unary expression */
472		404858	opnd1 = (*te->getopnd)(te, op, do_eval);
473	✗✓	404858	if (!opnd1) {
474			(*te->error)(te, -1, "missing argument");
475			return 0;
476			}
477
478		404858	return (*te->eval)(te, op, opnd1, NULL,
479			do_eval);
480			}
481			}
482		25885	opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval);
483	✗✓	25885	if (!opnd1) {
484			(*te->error)(te, 0, "expression expected");
485			return 0;
486			}
487	✓✗	25885	if ((op = (Test_op) (*te->isa)(te, TM_BINOP))) {
488			/* binary expression */
489		25885	opnd2 = (*te->getopnd)(te, op, do_eval);
490	✗✓	25885	if (!opnd2) {
491			(*te->error)(te, -1, "missing second argument");
492			return 0;
493			}
494
495		25885	return (*te->eval)(te, op, opnd1, opnd2, do_eval);
496			}
497			if (te->flags & TEF_DBRACKET) {
498			(*te->error)(te, -1, "missing expression operator");
499			return 0;
500			}
501			return (*te->eval)(te, TO_STNZE, opnd1, NULL, do_eval);
502		430743	}
503
504			/*
505			* Plain test (test and [ .. ]) specific routines.
506			*/
507
508			/* Test if the current token is a whatever. Accepts the current token if
509			* it is. Returns 0 if it is not, non-zero if it is (in the case of
510			* TM_UNOP and TM_BINOP, the returned value is a Test_op).
511			*/
512			static int
513			ptest_isa(Test_env *te, Test_meta meta)
514			{
515			/* Order important - indexed by Test_meta values */
516			static const char *const tokens[] = {
517			"-o", "-a", "!", "(", ")"
518			};
519			int ret;
520
521	✓✓	10520004	if (te->pos.wp >= te->wp_end)
522		1232718	return meta == TM_END;
523
524	✓✓	4027284	if (meta == TM_UNOP \|\| meta == TM_BINOP)
525		1393758	ret = (int) test_isop(te, meta, *te->pos.wp);
526	✓✓	2633526	else if (meta == TM_END)
527		1381296	ret = 0;
528			else
529		1252230	ret = strcmp(*te->pos.wp, tokens[(int) meta]) == 0;
530
531			/* Accept the token? */
532	✓✓	4027284	if (ret)
533		1400413	te->pos.wp++;
534
535		4027284	return ret;
536		5260002	}
537
538			static const char *
539			ptest_getopnd(Test_env *te, Test_op op, int do_eval)
540			{
541	✗✓	4765042	if (te->pos.wp >= te->wp_end)
542			return op == TO_FILTT ? "1" : NULL;
543		2382521	return *te->pos.wp++;
544		2382521	}
545
546			static int
547			ptest_eval(Test_env te, Test_op op, const char opnd1, const char *opnd2,
548			int do_eval)
549			{
550		2786962	return test_eval(te, op, opnd1, opnd2, do_eval);
551			}
552
553			static void
554			ptest_error(Test_env te, int offset, const char msg)
555			{
556			const char *op = te->pos.wp + offset >= te->wp_end ?
557			NULL : te->pos.wp[offset];
558
559			te->flags \|= TEF_ERROR;
560			if (op)
561			bi_errorf("%s: %s", op, msg);
562			else
563			bi_errorf("%s", msg);
564			}