Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
/*
2 
 * test(1); version 7-like  --  author Erik Baalbergen
3 
 * modified by Eric Gisin to be used as built-in.
4 
 * modified by Arnold Robbins to add SVR3 compatibility
5 
 * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
6 
 * modified by Michael Rendell to add Korn's [[ .. ]] expressions.
7 
 * modified by J.T. Conklin to add POSIX compatibility.
8 
 */
9 
 
10 
#include "sh.h"
11 
#include "ksh_stat.h"
12 
#include "c_test.h"
13 
 
14 
/* test(1) accepts the following grammar:
15 
	oexpr	::= aexpr | aexpr "-o" oexpr ;
16 
	aexpr	::= nexpr | nexpr "-a" aexpr ;
17 
	nexpr	::= primary | "!" nexpr ;
18 
	primary	::= unary-operator operand
19 
		| operand binary-operator operand
20 
		| operand
21 
		| "(" oexpr ")"
22 
		;
23 
 
24 
	unary-operator ::= "-a"|"-r"|"-w"|"-x"|"-e"|"-f"|"-d"|"-c"|"-b"|"-p"|
25 
			   "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|
26 
			   "-L"|"-h"|"-S"|"-H";
27 
 
28 
	binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
29 
			    "-nt"|"-ot"|"-ef"|
30 
			    "<"|">"	# rules used for [[ .. ]] expressions
31 
			    ;
32 
	operand ::= <any thing>
33 
*/
34 
 
35 
#define T_ERR_EXIT	2	/* POSIX says > 1 for errors */
36 
 
37 
struct t_op {
38 
	char	op_text[4];
39 
	Test_op	op_num;
40 
};
41 
static const struct t_op u_ops [] = {
42 
	{"-a",	TO_FILAXST },
43 
	{"-b",	TO_FILBDEV },
44 
	{"-c",	TO_FILCDEV },
45 
	{"-d",	TO_FILID },
46 
	{"-e",	TO_FILEXST },
47 
	{"-f",	TO_FILREG },
48 
	{"-G",	TO_FILGID },
49 
	{"-g",	TO_FILSETG },
50 
	{"-h",	TO_FILSYM },
51 
	{"-H",	TO_FILCDF },
52 
	{"-k",	TO_FILSTCK },
53 
	{"-L",	TO_FILSYM },
54 
	{"-n",	TO_STNZE },
55 
	{"-O",	TO_FILUID },
56 
	{"-o",	TO_OPTION },
57 
	{"-p",	TO_FILFIFO },
58 
	{"-r",	TO_FILRD },
59 
	{"-s",	TO_FILGZ },
60 
	{"-S",	TO_FILSOCK },
61 
	{"-t",	TO_FILTT },
62 
	{"-u",	TO_FILSETU },
63 
	{"-w",	TO_FILWR },
64 
	{"-x",	TO_FILEX },
65 
	{"-z",	TO_STZER },
66 
	{"",	TO_NONOP }
67 
    };
68 
static const struct t_op b_ops [] = {
69 
	{"=",	TO_STEQL },
70 
#ifdef KSH
71 
	{"==",	TO_STEQL },
72 
#endif /* KSH */
73 
	{"!=",	TO_STNEQ },
74 
	{"<",	TO_STLT },
75 
	{">",	TO_STGT },
76 
	{"-eq",	TO_INTEQ },
77 
	{"-ne",	TO_INTNE },
78 
	{"-gt",	TO_INTGT },
79 
	{"-ge",	TO_INTGE },
80 
	{"-lt",	TO_INTLT },
81 
	{"-le",	TO_INTLE },
82 
	{"-ef",	TO_FILEQ },
83 
	{"-nt",	TO_FILNT },
84 
	{"-ot",	TO_FILOT },
85 
	{"",	TO_NONOP }
86 
    };
87 
 
88 
static int	test_stat ARGS((const char *path, struct stat *statb));
89 
static int	test_eaccess ARGS((const char *path, int mode));
90 
static int	test_oexpr ARGS((Test_env *te, int do_eval));
91 
static int	test_aexpr ARGS((Test_env *te, int do_eval));
92 
static int	test_nexpr ARGS((Test_env *te, int do_eval));
93 
static int	test_primary ARGS((Test_env *te, int do_eval));
94 
static int	ptest_isa ARGS((Test_env *te, Test_meta meta));
95 
static const char *ptest_getopnd ARGS((Test_env *te, Test_op op, int do_eval));
96 
static int	ptest_eval ARGS((Test_env *te, Test_op op, const char *opnd1,
97 
				const char *opnd2, int do_eval));
98 
static void	ptest_error ARGS((Test_env *te, int offset, const char *msg));
99 
 
100 
int
101 
c_test(wp)
102 
	char **wp;
103 
{
104 
	int argc;
105 
	int res;
106 
	Test_env te;
107 
 
108 
	te.flags = 0;
109 
	te.isa = ptest_isa;
110 
	te.getopnd = ptest_getopnd;
111 
	te.eval = ptest_eval;
112 
	te.error = ptest_error;
113 
 
114 
	for (argc = 0; wp[argc]; argc++)
115 
		;
116 
 
117 
	if (strcmp(wp[0], "[") == 0) {
118 
		if (strcmp(wp[--argc], "]") != 0) {
119 
			bi_errorf("missing ]");
120 
			return T_ERR_EXIT;
121 
		}
122 
	}
123 
 
124 
	te.pos.wp = wp + 1;
125 
	te.wp_end = wp + argc;
126 
 
127 
	/*
128 
	 * Handle the special cases from POSIX.2, section 4.62.4.
129 
	 * Implementation of all the rules isn't necessary since
130 
	 * our parser does the right thing for the ommited steps.
131 
	 */
132 
	if (argc <= 5) {
133 
		char **owp = wp;
134 
		int invert = 0;
135 
		Test_op	op;
136 
		const char *opnd1, *opnd2;
137 
 
138 
		while (--argc >= 0) {
139 
			if ((*te.isa)(&te, TM_END))
140 
				return !0;
141 
			if (argc == 3) {
142 
				opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
143 
				if ((op = (Test_op) (*te.isa)(&te, TM_BINOP))) {
144 
					opnd2 = (*te.getopnd)(&te, op, 1);
145 
					res = (*te.eval)(&te, op, opnd1, opnd2,
146 
							1);
147 
					if (te.flags & TEF_ERROR)
148 
						return T_ERR_EXIT;
149 
					if (invert & 1)
150 
						res = !res;
151 
					return !res;
152 
				}
153 
				/* back up to opnd1 */
154 
				te.pos.wp--;
155 
			}
156 
			if (argc == 1) {
157 
				opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
158 
				/* Historically, -t by itself test if fd 1
159 
				 * is a file descriptor, but POSIX says its
160 
				 * a string test...
161 
				 */
162 
				if (!Flag(FPOSIX) && strcmp(opnd1, "-t") == 0)
163 
				    break;
164 
				res = (*te.eval)(&te, TO_STNZE, opnd1,
165 
						(char *) 0, 1);
166 
				if (invert & 1)
167 
					res = !res;
168 
				return !res;
169 
			}
170 
			if ((*te.isa)(&te, TM_NOT)) {
171 
				invert++;
172 
			} else
173 
				break;
174 
		}
175 
		te.pos.wp = owp + 1;
176 
	}
177 
 
178 
	return test_parse(&te);
179 
}
180 
 
181 
/*
182 
 * Generic test routines.
183 
 */
184 
 
185 
Test_op
186 
test_isop(te, meta, s)
187 
	Test_env *te;
188 
	Test_meta meta;
189 
	const char *s;
190 
{
191 
	char sc1;
192 
	const struct t_op *otab;
193 
 
194 
	otab = meta == TM_UNOP ? u_ops : b_ops;
195 
	if (*s) {
196 
		sc1 = s[1];
197 
		for (; otab->op_text[0]; otab++)
198 
			if (sc1 == otab->op_text[1]
199 
			    && strcmp(s, otab->op_text) == 0
200 
			    && ((te->flags & TEF_DBRACKET)
201 
				|| (otab->op_num != TO_STLT
202 
				    && otab->op_num != TO_STGT)))
203 
				return otab->op_num;
204 
	}
205 
	return TO_NONOP;
206 
}
207 
 
208 
int
209 
test_eval(te, op, opnd1, opnd2, do_eval)
210 
	Test_env *te;
211 
	Test_op op;
212 
	const char *opnd1;
213 
	const char *opnd2;
214 
	int do_eval;
215 
{
216 
	int res;
217 
	int not;
218 
	struct stat b1, b2;
219 
 
220 
	if (!do_eval)
221 
		return 0;
222 
 
223 
	switch ((int) op) {
224 
	/*
225 
	 * Unary Operators
226 
	 */
227 
	  case TO_STNZE: /* -n */
228 
		return *opnd1 != '\0';
229 
	  case TO_STZER: /* -z */
230 
		return *opnd1 == '\0';
231 
	  case TO_OPTION: /* -o */
232 
		if ((not = *opnd1 == '!'))
233 
			opnd1++;
234 
		if ((res = option(opnd1)) < 0)
235 
			res = 0;
236 
		else {
237 
			res = Flag(res);
238 
			if (not)
239 
				res = !res;
240 
		}
241 
		return res;
242 
	  case TO_FILRD: /* -r */
243 
		return test_eaccess(opnd1, R_OK) == 0;
244 
	  case TO_FILWR: /* -w */
245 
		return test_eaccess(opnd1, W_OK) == 0;
246 
	  case TO_FILEX: /* -x */
247 
		return test_eaccess(opnd1, X_OK) == 0;
248 
	  case TO_FILAXST: /* -a */
249 
		return test_stat(opnd1, &b1) == 0;
250 
	  case TO_FILEXST: /* -e */
251 
		/* at&t ksh does not appear to do the /dev/fd/ thing for
252 
		 * this (unless the os itself handles it)
253 
		 */
254 
		return stat(opnd1, &b1) == 0;
255 
	  case TO_FILREG: /* -r */
256 
		return test_stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode);
257 
	  case TO_FILID: /* -d */
258 
		return test_stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode);
259 
	  case TO_FILCDEV: /* -c */
260 
#ifdef S_ISCHR
261 
		return test_stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode);
262 
#else
263 
		return 0;
264 
#endif
265 
	  case TO_FILBDEV: /* -b */
266 
#ifdef S_ISBLK
267 
		return test_stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode);
268 
#else
269 
		return 0;
270 
#endif
271 
	  case TO_FILFIFO: /* -p */
272 
#ifdef S_ISFIFO
273 
		return test_stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode);
274 
#else
275 
		return 0;
276 
#endif
277 
	  case TO_FILSYM: /* -h -L */
278 
#ifdef S_ISLNK
279 
		return lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode);
280 
#else
281 
		return 0;
282 
#endif
283 
	  case TO_FILSOCK: /* -S */
284 
#ifdef S_ISSOCK
285 
		return test_stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode);
286 
#else
287 
		return 0;
288 
#endif
289 
	  case TO_FILCDF:/* -H HP context dependent files (directories) */
290 
#ifdef S_ISCDF
291 
	  {
292 
		/* Append a + to filename and check to see if result is a
293 
		 * setuid directory.  CDF stuff in general is hookey, since
294 
		 * it breaks for the following sequence: echo hi > foo+;
295 
		 * mkdir foo; echo bye > foo/default; chmod u+s foo
296 
		 * (foo+ refers to the file with hi in it, there is no way
297 
		 * to get at the file with bye in it - please correct me if
298 
		 * I'm wrong about this).
299 
		 */
300 
		int len = strlen(opnd1);
301 
		char *p = str_nsave(opnd1, len + 1, ATEMP);
302 
 
303 
		p[len++] = '+';
304 
		p[len] = '\0';
305 
		return stat(p, &b1) == 0 && S_ISCDF(b1.st_mode);
306 
	  }
307 
#else
308 
		return 0;
309 
#endif
310 
	  case TO_FILSETU: /* -u */
311 
#ifdef S_ISUID
312 
		return test_stat(opnd1, &b1) == 0
313 
			&& (b1.st_mode & S_ISUID) == S_ISUID;
314 
#else
315 
		return 0;
316 
#endif
317 
	  case TO_FILSETG: /* -g */
318 
#ifdef S_ISGID
319 
		return test_stat(opnd1, &b1) == 0
320 
			&& (b1.st_mode & S_ISGID) == S_ISGID;
321 
#else
322 
		return 0;
323 
#endif
324 
	  case TO_FILSTCK: /* -k */
325 
		return test_stat(opnd1, &b1) == 0
326 
			&& (b1.st_mode & S_ISVTX) == S_ISVTX;
327 
	  case TO_FILGZ: /* -s */
328 
		return test_stat(opnd1, &b1) == 0 && b1.st_size > 0L;
329 
	  case TO_FILTT: /* -t */
330 
		if (opnd1 && !bi_getn(opnd1, &res)) {
331 
			te->flags |= TEF_ERROR;
332 
			res = 0;
333 
		} else {
334 
			/* generate error if in FPOSIX mode? */
335 
			res = isatty(opnd1 ? res : 0);
336 
		}
337 
		return res;
338 
	  case TO_FILUID: /* -O */
339 
		return test_stat(opnd1, &b1) == 0 && b1.st_uid == ksheuid;
340 
	  case TO_FILGID: /* -G */
341 
		return test_stat(opnd1, &b1) == 0 && b1.st_gid == getegid();
342 
	/*
343 
	 * Binary Operators
344 
	 */
345 
	  case TO_STEQL: /* = */
346 
		if (te->flags & TEF_DBRACKET)
347 
			return gmatch(opnd1, opnd2, FALSE);
348 
		return strcmp(opnd1, opnd2) == 0;
349 
	  case TO_STNEQ: /* != */
350 
		if (te->flags & TEF_DBRACKET)
351 
			return !gmatch(opnd1, opnd2, FALSE);
352 
		return strcmp(opnd1, opnd2) != 0;
353 
	  case TO_STLT: /* < */
354 
		return strcmp(opnd1, opnd2) < 0;
355 
	  case TO_STGT: /* > */
356 
		return strcmp(opnd1, opnd2) > 0;
357 
	  case TO_INTEQ: /* -eq */
358 
	  case TO_INTNE: /* -ne */
359 
	  case TO_INTGE: /* -ge */
360 
	  case TO_INTGT: /* -gt */
361 
	  case TO_INTLE: /* -le */
362 
	  case TO_INTLT: /* -lt */
363 
		{
364 
			long v1, v2;
365 
 
366 
			if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR)
367 
			    || !evaluate(opnd2, &v2, KSH_RETURN_ERROR))
368 
			{
369 
				/* error already printed.. */
370 
				te->flags |= TEF_ERROR;
371 
				return 1;
372 
			}
373 
			switch ((int) op) {
374 
			  case TO_INTEQ:
375 
				return v1 == v2;
376 
			  case TO_INTNE:
377 
				return v1 != v2;
378 
			  case TO_INTGE:
379 
				return v1 >= v2;
380 
			  case TO_INTGT:
381 
				return v1 > v2;
382 
			  case TO_INTLE:
383 
				return v1 <= v2;
384 
			  case TO_INTLT:
385 
				return v1 < v2;
386 
			}
387 
		}
388 
	  case TO_FILNT: /* -nt */
389 
		{
390 
			int s2;
391 
			/* ksh88/ksh93 succeed if file2 can't be stated
392 
			 * (subtly different from `does not exist').
393 
			 */
394 
			return stat(opnd1, &b1) == 0
395 
				&& (((s2 = stat(opnd2, &b2)) == 0
396 
				      && b1.st_mtime > b2.st_mtime) || s2 < 0);
397 
		}
398 
	  case TO_FILOT: /* -ot */
399 
		{
400 
			int s1;
401 
			/* ksh88/ksh93 succeed if file1 can't be stated
402 
			 * (subtly different from `does not exist').
403 
			 */
404 
			return stat(opnd2, &b2) == 0
405 
				&& (((s1 = stat(opnd1, &b1)) == 0
406 
				      && b1.st_mtime < b2.st_mtime) || s1 < 0);
407 
		}
408 
	  case TO_FILEQ: /* -ef */
409 
		return stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0
410 
		       && b1.st_dev == b2.st_dev
411 
		       && b1.st_ino == b2.st_ino;
412 
	}
413 
	(*te->error)(te, 0, "internal error: unknown op");
414 
	return 1;
415 
}
416 
 
417 
/* Nasty kludge to handle Korn's bizarre /dev/fd hack */
418 
static int
419 
test_stat(path, statb)
420 
	const char *path;
421 
	struct stat *statb;
422 
{
423 
#if !defined(HAVE_DEV_FD)
424 
	int fd;
425 
 
426 
	if (strncmp(path, "/dev/fd/", 8) == 0 && getn(path + 8, &fd))
427 
		return fstat(fd, statb);
428 
#endif /* !HAVE_DEV_FD */
429 
 
430 
	return stat(path, statb);
431 
}
432 
 
433 
/* Routine to handle Korn's /dev/fd hack, and to deal with X_OK on
434 
 * non-directories when running as root.
435 
 */
436 
static int
437 
test_eaccess(path, mode)
438 
	const char *path;
439 
	int mode;
440 
{
441 
	int res;
442 
 
443 
#if !defined(HAVE_DEV_FD)
444 
	int fd;
445 
 
446 
	/* Note: doesn't handle //dev/fd, etc.. (this is ok) */
447 
	if (strncmp(path, "/dev/fd/", 8) == 0 && getn(path + 8, &fd)) {
448 
		int flags;
449 
 
450 
		if ((flags = fcntl(fd, F_GETFL, 0)) < 0
451 
		    || (mode & X_OK)
452 
		    || ((mode & W_OK) && (flags & O_ACCMODE) == O_RDONLY)
453 
		    || ((mode & R_OK) && (flags & O_ACCMODE) == O_WRONLY))
454 
			return -1;
455 
		return 0;
456 
	}
457 
#endif /* !HAVE_DEV_FD */
458 
 
459 
	/* On most (all?) unixes, access() says everything is executable for
460 
	 * root - avoid this on files by using stat().
461 
	 */
462 
	if ((mode & X_OK) && ksheuid == 0) {
463 
		struct stat statb;
464 
 
465 
		if (stat(path, &statb) < 0)
466 
			res = -1;
467 
		else if (S_ISDIR(statb.st_mode))
468 
			res = 0;
469 
		else
470 
			res = (statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
471 
				? 0 : -1;
472 
		/* Need to check other permissions?  If so, use access() as
473 
		 * this will deal with root on NFS.
474 
		 */
475 
		if (res == 0 && (mode & (R_OK|W_OK)))
476 
			res = eaccess(path, mode);
477 
	} else
478 
		res = eaccess(path, mode);
479 
 
480 
	return res;
481 
}
482 
 
483 
int
484 
test_parse(te)
485 
	Test_env *te;
486 
{
487 
	int res;
488 
 
489 
	res = test_oexpr(te, 1);
490 
 
491 
	if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END))
492 
		(*te->error)(te, 0, "unexpected operator/operand");
493 
 
494 
	return (te->flags & TEF_ERROR) ? T_ERR_EXIT : !res;
495 
}
496 
 
497 
static int
498 
test_oexpr(te, do_eval)
499 
	Test_env *te;
500 
	int do_eval;
501 
{
502 
	int res;
503 
 
504 
	res = test_aexpr(te, do_eval);
505 
	if (res)
506 
		do_eval = 0;
507 
	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR))
508 
		return test_oexpr(te, do_eval) || res;
509 
	return res;
510 
}
511 
 
512 
static int
513 
test_aexpr(te, do_eval)
514 
	Test_env *te;
515 
	int do_eval;
516 
{
517 
	int res;
518 
 
519 
	res = test_nexpr(te, do_eval);
520 
	if (!res)
521 
		do_eval = 0;
522 
	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND))
523 
		return test_aexpr(te, do_eval) && res;
524 
	return res;
525 
}
526 
 
527 
static int
528 
test_nexpr(te, do_eval)
529 
	Test_env *te;
530 
	int do_eval;
531 
{
532 
	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT))
533 
		return !test_nexpr(te, do_eval);
534 
	return test_primary(te, do_eval);
535 
}
536 
 
537 
static int
538 
test_primary(te, do_eval)
539 
	Test_env *te;
540 
	int do_eval;
541 
{
542 
	const char *opnd1, *opnd2;
543 
	int res;
544 
	Test_op op;
545 
 
546 
	if (te->flags & TEF_ERROR)
547 
		return 0;
548 
	if ((*te->isa)(te, TM_OPAREN)) {
549 
		res = test_oexpr(te, do_eval);
550 
		if (te->flags & TEF_ERROR)
551 
			return 0;
552 
		if (!(*te->isa)(te, TM_CPAREN)) {
553 
			(*te->error)(te, 0, "missing closing paren");
554 
			return 0;
555 
		}
556 
		return res;
557 
	}
558 
	if ((op = (Test_op) (*te->isa)(te, TM_UNOP))) {
559 
		/* unary expression */
560 
		opnd1 = (*te->getopnd)(te, op, do_eval);
561 
		if (!opnd1) {
562 
			(*te->error)(te, -1, "missing argument");
563 
			return 0;
564 
		}
565 
 
566 
		return (*te->eval)(te, op, opnd1, (const char *) 0, do_eval);
567 
	}
568 
	opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval);
569 
	if (!opnd1) {
570 
		(*te->error)(te, 0, "expression expected");
571 
		return 0;
572 
	}
573 
	if ((op = (Test_op) (*te->isa)(te, TM_BINOP))) {
574 
		/* binary expression */
575 
		opnd2 = (*te->getopnd)(te, op, do_eval);
576 
		if (!opnd2) {
577 
			(*te->error)(te, -1, "missing second argument");
578 
			return 0;
579 
		}
580 
 
581 
		return (*te->eval)(te, op, opnd1, opnd2, do_eval);
582 
	}
583 
	if (te->flags & TEF_DBRACKET) {
584 
		(*te->error)(te, -1, "missing expression operator");
585 
		return 0;
586 
	}
587 
	return (*te->eval)(te, TO_STNZE, opnd1, (const char *) 0, do_eval);
588 
}
589 
 
590 
/*
591 
 * Plain test (test and [ .. ]) specific routines.
592 
 */
593 
 
594 
/* Test if the current token is a whatever.  Accepts the current token if
595 
 * it is.  Returns 0 if it is not, non-zero if it is (in the case of
596 
 * TM_UNOP and TM_BINOP, the returned value is a Test_op).
597 
 */
598 
static int
599 
ptest_isa(te, meta)
600 
	Test_env *te;
601 
	Test_meta meta;
602 
{
603 
	/* Order important - indexed by Test_meta values */
604 
	static const char *const tokens[] = {
605 
				"-o", "-a", "!", "(", ")"
606 
			};
607 
	int ret;
608 
 
609 
	if (te->pos.wp >= te->wp_end)
610 
		return meta == TM_END;
611 
 
612 
	if (meta == TM_UNOP || meta == TM_BINOP)
613 
		ret = (int) test_isop(te, meta, *te->pos.wp);
614 
	else if (meta == TM_END)
615 
		ret = 0;
616 
	else
617 
		ret = strcmp(*te->pos.wp, tokens[(int) meta]) == 0;
618 
 
619 
	/* Accept the token? */
620 
	if (ret)
621 
		te->pos.wp++;
622 
 
623 
	return ret;
624 
}
625 
 
626 
static const char *
627 
ptest_getopnd(te, op, do_eval)
628 
	Test_env *te;
629 
	Test_op op;
630 
	int do_eval;
631 
{
632 
	if (te->pos.wp >= te->wp_end)
633 
		return op == TO_FILTT ? "1" : (const char *) 0;
634 
	return *te->pos.wp++;
635 
}
636 
 
637 
static int
638 
ptest_eval(te, op, opnd1, opnd2, do_eval)
639 
	Test_env *te;
640 
	Test_op op;
641 
	const char *opnd1;
642 
	const char *opnd2;
643 
	int do_eval;
644 
{
645 
	return test_eval(te, op, opnd1, opnd2, do_eval);
646 
}
647 
 
648 
static void
649 
ptest_error(te, offset, msg)
650 
	Test_env *te;
651 
	int offset;
652 
	const char *msg;
653 
{
654 
	const char *op = te->pos.wp + offset >= te->wp_end ?
655 
				(const char *) 0 : te->pos.wp[offset];
656 
 
657 
	te->flags |= TEF_ERROR;
658 
	if (op)
659 
		bi_errorf("%s: %s", op, msg);
660 
	else
661 
		bi_errorf("%s", msg);
662 
}