![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to test.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin|
Return to test.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin |
1.1 root 1: /*
2: * New, improved version of the "test" utility, hopefully P1003.2 compliant.
3: *
4: * "test" has represented a problem to implementors because of the possibility
5: * of aliasing between operators and operands; while it is possible to resolve
6: * this ambiguity with conventional tools, the resulting program is rather
7: * subtle and easily broken.
8: *
9: * The observation the underpins this implementation is that the "test" input
10: * is more accurately parsed /from the right/ than from the left. Because the
11: * last element of a form is always an operand rather than an operator, and
12: * because unary and binary primaries are lexically distinct, it is possible
13: * to create an unambiguous parse with a single right->left scan of the input.
14: *
15: * Parentheses are a unique problem, however. The easiest way to support them
16: * is to say that parentheses are matched only if they are not consumed by
17: * any operators, i.e. \( "a" \) would fail to match any operators and so the
18: * parenthesis would match.
19: */
20:
21: #include <sys/compat.h>
22: #include <sys/stat.h>
23: #include <access.h>
24: #include <string.h>
25: #include <stdlib.h>
26: #include <unistd.h>
27:
28: enum {
29: SYNTAX_ERROR = 2
30: };
31:
32:
33: typedef int (* compare_p) PROTO ((long diff));
34: typedef int (* file_binop_p) PROTO ((struct stat * left,
35: struct stat * right));
36: typedef int (* log_binop_p) PROTO ((int left, int right));
37: typedef int (* string_unop_p) PROTO ((char * arg));
38: typedef int (* file_unop_p) PROTO ((struct stat * stat));
39:
40:
41: #ifdef USE_PROTO
42: # define SELECT(ansi,knr) ansi
43: #else
44: # define SELECT(ansi,knr) knr
45: #endif
46:
47: /*
48: * Miscellaneous comparison operators.
49: */
50:
51: #define CMP_OP(name) static int name SELECT ((long diff), (diff) long diff;)
52:
53: CMP_OP (cmp_eq) {
54: return diff != 0;
55: }
56: CMP_OP (cmp_neq) {
57: return diff == 0;
58: }
59: CMP_OP (cmp_lt) {
60: return diff >= 0;
61: }
62: CMP_OP (cmp_gt) {
63: return diff <= 0;
64: }
65: CMP_OP (cmp_le) {
66: return diff > 0;
67: }
68: CMP_OP (cmp_ge) {
69: return diff < 0;
70: }
71:
72:
73: /*
74: * Miscellaneous file operators.
75: */
76:
77: #define FILE_BINOP(name) \
78: static int name SELECT((struct stat * left, struct stat * right), \
79: (left, right) struct stat * left; struct stat * right;)
80:
81: FILE_BINOP (file_eq) {
82: return left->st_dev != right->st_dev || left->st_ino != right->st_ino;
83: }
84: FILE_BINOP (file_newer) {
85: return left->st_mtime <= right->st_mtime;
86: }
87: FILE_BINOP (file_older) {
88: return left->st_mtime >= right->st_mtime;
89: }
90:
91: #define FILE_UNOP(name) static int name SELECT ((struct stat * stat), \
92: (stat) struct stat * stat;)
93:
94: FILE_UNOP (file_exists) {
95: return 0;
96: }
97: FILE_UNOP (file_blockspecial) {
98: return (stat->st_mode & S_IFMT) != S_IFBLK;
99: }
100: FILE_UNOP (file_charspecial) {
101: return (stat->st_mode & S_IFMT) != S_IFCHR;
102: }
103: FILE_UNOP (file_directory) {
104: return (stat->st_mode & S_IFMT) != S_IFDIR;
105: }
106: FILE_UNOP (file_pipe) {
107: return (stat->st_mode & S_IFMT) != S_IFPIP;
108: }
109: FILE_UNOP (file_regular) {
110: return (stat->st_mode & S_IFMT) != S_IFREG;
111: }
112: FILE_UNOP (file_setgid) {
113: return (stat->st_mode & S_ISGID) == 0;
114: }
115: FILE_UNOP (file_setuid) {
116: return (stat->st_mode & S_ISUID) == 0;
117: }
118: FILE_UNOP (file_sticky) {
119: return (stat->st_mode & S_ISVTX) == 0;
120: }
121: FILE_UNOP (file_linked) {
122: #if 1
123: return 1; /* Coherent has no symbolic links */
124: #else
125: return stat->st_nlink == 0;
126: #endif
127: }
128: FILE_UNOP (file_nonempty) {
129: return stat->st_size == 0;
130: }
131:
132: /*
133: * Miscellaneous string operators.
134: */
135:
136: #define STRING_UNOP(name) static int name SELECT ((char * str),\
137: (str) char * str;)
138:
139: STRING_UNOP (string_empty) {
140: return str [0] != 0;
141: }
142: STRING_UNOP (string_nonempty) {
143: return str [0] == 0;
144: }
145: STRING_UNOP (strfile_istty) {
146: return ! isatty (atoi (str));
147: }
148: STRING_UNOP (strfile_readable) {
149: return access (str, AREAD);
150: }
151: STRING_UNOP (strfile_writeable) {
152: return access (str, AWRITE);
153: }
154: STRING_UNOP (strfile_executable) {
155: return access (str, AEXEC);
156: }
157:
158:
159: /*
160: * Declare and fill in some tables of function names and pointers to the
161: * implementations.
162: */
163:
164: struct op {
165: char * op_name;
166: VOID * op_func;
167: };
168: #define OP(name,func) { name, (VOID *) func }
169:
170: struct op string_binop [] = {
171: OP ("=", cmp_eq), OP ("!=", cmp_neq), OP ("<", cmp_lt),
172: OP (">", cmp_gt), OP ("<=", cmp_le), OP (">=", cmp_ge)
173: };
174: struct op arith_binop [] = {
175: OP ("-eq", cmp_eq), OP ("-ne", cmp_neq), OP ("-lt", cmp_lt),
176: OP ("-gt", cmp_gt), OP ("-le", cmp_le), OP ("-ge", cmp_ge)
177: };
178: struct op file_binop [] = {
179: OP ("-ef", file_eq), OP ("-nt", file_newer), OP ("-ot", file_older)
180: };
181: struct op string_unop [] = {
182: OP ("-z", string_empty), OP ("-n", string_nonempty),
183: OP ("-t", strfile_istty), OP ("-r", strfile_readable),
184: OP ("-w", strfile_writeable), OP ("-x", strfile_executable)
185: /* OP ("!", string_empty) */
186: };
187: struct op file_unop [] = {
188: OP ("-b", file_blockspecial), OP ("-c", file_charspecial),
189: OP ("-d", file_directory), OP ("-p", file_pipe),
190: OP ("-f", file_regular), OP ("-g", file_setgid),
191: OP ("-u", file_setuid), OP ("-K", file_sticky),
192: OP ("-L", file_linked), OP ("-s", file_nonempty),
193: OP ("-e", file_exists)
194: };
195:
196: #define FIND_OP(table,str) find_op (sizeof (table) / sizeof (* table),\
197: table, str)
198: #define is_string_binop(str) ((compare_p) FIND_OP (string_binop, str))
199: #define is_arith_binop(str) ((compare_p) FIND_OP (arith_binop, str))
200: #define is_file_binop(str) ((file_binop_p) FIND_OP (file_binop, str))
201: #define is_string_unop(str) ((string_unop_p) FIND_OP (string_unop, str))
202: #define is_file_unop(str) ((file_unop_p) FIND_OP (file_unop, str))
203:
204: /*
205: * Generic operator table search routine.
206: */
207:
208: #ifdef USE_PROTO
209: static VOID * find_op (int size, struct op * table, char * str)
210: #else
211: static VOID *
212: find_op (size, table, str)
213: int size;
214: struct op * table;
215: char * str;
216: #endif
217: {
218: do
219: if (strcmp (table->op_name, str) == 0)
220: return table->op_func;
221: while (table ++, -- size > 0);
222:
223: return NULL;
224: }
225:
226:
227: /*
228: * Convert an operand of a numeric expression into a number. The rules for
229: * how strict the conversion to integer is are not clear.
230: *
231: * We return 0 on success, non-zero on failure.
232: */
233:
234: #define convert_number(str,nump) (* (nump) = atol (str), 0)
235:
236: #ifdef USE_PROTO
237: int (convert_number) (char * string, long * numberp)
238: #else
239: int
240: convert_number ARGS ((string, numberp))
241: char * string;
242: long * numberp;
243: #endif
244: {
245: return convert_number (string, numberp);
246: }
247:
248: enum {
249: NO_PAREN,
250: IN_PAREN
251: };
252:
253: int test_boolor PROTO ((int argc, char * argv [],
254: int * matchedp, int paren));
255:
256:
257: /*
258: * Process a non-empty element of a test-expression (see test () below).
259: * The fundamental premise of this code is that argv [argc - 1] is an
260: * operand, and thus that argv [argc - 2] is an operator of some form.
261: */
262:
263: #ifdef USE_PROTO
264: int test_primop (int argc, char * argv [], int * matchedp, int paren)
265: #else
266: int
267: test_primop (argc, argv, matchedp, paren)
268: int argc;
269: char * argv [];
270: int * matchedp;
271: int paren;
272: #endif
273: {
274: int result;
275: int operator_flag = 1;
276:
277: if (argc < 1)
278: return SYNTAX_ERROR; /* syntax error in subexpr */
279:
280: /*
281: * Begin by looking for binary operator at argv [argc - 2].
282: * String operators only match if we have 3 arguments, and the
283: * same is true of arithmetic operators.
284: */
285:
286: if (argc >= 3) {
287: compare_p cmp;
288: file_binop_p file;
289:
290: * matchedp = 3;
291:
292: if ((cmp = is_string_binop (argv [argc - 2])) != NULL) {
293: result = (* cmp) (strcmp (argv [argc - 3],
294: argv [argc - 1]));
295: goto negate;
296: }
297: if ((cmp = is_arith_binop (argv [argc - 2])) != NULL) {
298: long left;
299: long right;
300:
301: if (convert_number (argv [argc - 3], & left) == 0 &&
302: convert_number (argv [argc - 1], & right) == 0) {
303: result = (* cmp) (left - right);
304: goto negate;
305: }
306:
307: return SYNTAX_ERROR;
308: }
309:
310: if ((file = is_file_binop (argv [argc - 2])) != NULL) {
311: struct stat left;
312: struct stat right;
313:
314: if (stat (argv [argc - 3], & left) < 0 ||
315: stat (argv [argc - 1], & right) < 0)
316: result = 1;
317: else
318: result = (* file) (& left, & right);
319: goto negate;
320: }
321: }
322:
323: if (argc >= 2) {
324: string_unop_p string;
325: file_unop_p file;
326:
327: * matchedp = 2;
328:
329: if ((string = is_string_unop (argv [argc - 2])) != NULL) {
330: result = (* string) (argv [argc - 1]);
331: goto negate;
332: }
333: if ((file = is_file_unop (argv [argc - 2])) != NULL) {
334: struct stat statbuf;
335:
336: if (stat (argv [argc - 1], & statbuf) < 0)
337: result = 1;
338: else
339: result = (* file) (& statbuf);
340: goto negate;
341: }
342: }
343:
344: not_really_operator:
345: operator_flag = 0;
346:
347: if (argc > 2 && strcmp (argv [argc - 1], ")") == 0 &&
348: (result = test_boolor (argc - 1, argv, matchedp,
349: IN_PAREN)) != SYNTAX_ERROR &&
350: argc - 1 > * matchedp &&
351: strcmp (argv [argc - 2 - * matchedp], "(") == 0)
352: (* matchedp) += 2;
353: else {
354: * matchedp = 1;
355: result = argv [argc - 1][0] == 0;
356: }
357:
358: negate:
359: /*
360: * Try and extend the subexpression on the right by looking
361: * for negations.
362: */
363:
364: while (argc > * matchedp) {
365: char * next = argv [argc - 1 - * matchedp];
366:
367: if (strcmp (next, "!") == 0) {
368: (* matchedp) ++;
369: result = ! result;
370: continue;
371: }
372:
373: /*
374: * We now have encountered something on the left... if it is
375: * a conjunction or disjunction operator, we are OK, otherwise
376: * we have hit a syntax error. If we got here by matching an
377: * operator, we can try matching a parenthesis and/or string
378: * as a fallback.
379: */
380:
381: if (strcmp (next, "-a") != 0 && strcmp (next, "-o") != 0 &&
382: (paren != IN_PAREN || strcmp (next, "(") != 0) &&
383: operator_flag)
384: goto not_really_operator;
385:
386: break;
387: }
388:
389: return result;
390: }
391:
392:
393: /*
394: * Process an optional sequence of boolean conjunctions. This is separated
395: * from disjunction because conjunction has higher "precedence".
396: */
397:
398: #ifdef USE_PROTO
399: int test_booland (int argc, char * argv [], int * matchedp, int paren)
400: #else
401: int
402: test_booland (argc, argv, matchedp, paren)
403: int argc;
404: char * argv [];
405: int * matchedp;
406: int paren;
407: #endif
408: {
409: int right = 0; /* "true" */
410:
411: * matchedp = 0;
412:
413: /*
414: * Match a sequence of the form:
415: * and_expr = and_expr AND prim_expr
416: * | prim_expr ;
417: * Note that this grammar matches the definition of "and" as left-
418: * associative, but in fact since conjunction is commutative there is
419: * no great magic to this and we right-associate instead.
420: */
421:
422: for (;;) {
423: int left;
424: int matched;
425:
426: if ((left = test_primop (argc, argv, & matched,
427: paren)) == SYNTAX_ERROR)
428: return SYNTAX_ERROR;
429:
430: right = right || left; /* "and" */
431: * matchedp += matched;
432: argc -= matched;
433:
434: if (argc < 2 || strcmp (argv [argc - 1], "-a") != 0)
435: return right;
436:
437: (* matchedp) ++;
438: argc --;
439: }
440: }
441:
442:
443: /*
444: * Process an optional sequence of boolean disjunctions.
445: */
446:
447: #ifdef USE_PROTO
448: int test_boolor (int argc, char * argv [], int * matchedp, int paren)
449: #else
450: int
451: test_boolor (argc, argv, matchedp, paren)
452: int argc;
453: char * argv [];
454: int * matchedp;
455: int paren;
456: #endif
457: {
458: int right = 1; /* "false" */
459:
460: * matchedp = 0;
461:
462: /*
463: * Match an expression of the form:
464: * or_expr = or_expr OR and_expr
465: * | and_expr ;
466: * Note that this grammar matches the definition of "or" as being
467: * left-associative, but since disjunction is commutative this does
468: * not really matter and we actually associate to the right.
469: */
470:
471: for (;;) {
472: int left;
473: int matched;
474:
475: if ((left = test_booland (argc, argv, & matched,
476: paren)) == SYNTAX_ERROR)
477: return SYNTAX_ERROR;
478:
479: (* matchedp) += matched;
480: argc -= matched;
481: right = right && left; /* "or" */
482:
483: if (argc < 2 || strcmp (argv [argc - 1], "-o") != 0)
484: return right;
485:
486: (* matchedp) ++;
487: argc --;
488: }
489: }
490:
491:
492: /*
493: * Process a test-expression. The "argc" argument specifies the number of
494: * elements in the argument-vector "argv", where each element is a string.
495: * Note that unlike main (), the first element of argv [] is a real
496: * argument.
497: */
498:
499: #ifdef USE_PROTO
500: int test (int argc, char * argv [])
501: #else
502: int
503: test ARGS ((argc, argv))
504: int argc;
505: char * argv [];
506: #endif
507: {
508: int matched;
509: int value;
510:
511: /*
512: * Special cases to allow some simple tests. All these are available
513: * other ways, but they are historically significant.
514: */
515:
516: if (argc == 0)
517: return 1; /* false */
518:
519: #if 0
520: if (argc == 1)
521: return argv [0][0] == 0; /* => -n <arg> */
522: #endif
523:
524: if ((value = test_boolor (argc, argv, & matched,
525: NO_PAREN)) == SYNTAX_ERROR ||
526: matched != argc)
527: return SYNTAX_ERROR;
528:
529: return value;
530: }
531:
532:
533: #ifdef TEST
534:
535: #define WRITESTR(s) write (2, s, strlen (s))
536: #define WRITECONST(s) write (2, s, sizeof (s))
537:
538: #ifdef USE_PROTO
539: void error (char * prog, char * str)
540: #else
541: void
542: error (prog, str)
543: char * prog;
544: char * str;
545: #endif
546: {
547: WRITESTR (prog);
548: WRITECONST (":");
549: WRITESTR (str);
550: WRITECONST ("\n");
551:
552: WRITECONST ("Unary primaries:\n"
553: "\t-b file\t\tfile exists and is a block special file\n"
554: "\t-c file\t\tfile exists and is a character special file\n"
555: "\t-d file\t\tfile exists and is a directory\n"
556: "\t-e file\t\tfile exists\n"
557: "\t-f file\t\tfile exists and is a regular file\n"
558: "\t-g file\t\tfile exists and is setgid\n"
559: "\t-k file\t\tfile exists and has sticky bit set\t(not Posix)\n"
560: "\t-L file\t\tfile is a link\t\t\t\t(not Posix)\n"
561: "\t-n string\tstring length is nonzero\n"
562: "\t-p file\t\tfile exists and is a named pipe (FIFO)\n"
563: "\t-r file\t\tfile exists and is readable\n"
564: "\t-s file\t\tfile exists and has nonzero size\n"
565: "\t-t fd\t\tfd is the file descriptor of a terminal\n"
566: "\t-u file\t\tfile exists and is setuid\n"
567: "\t-w file\t\tfile exists and is writable\n"
568: "\t-x file\t\tfile exists and is executable\n"
569: "\t-z string\tstring length is zero\n"
570: "\tstring\t\tstring is not the empty string\n"
571: );
572: WRITECONST ("Binary primaries:\n"
573: "\ts1 = s2\t\tstrings s1 and s2 are identical\n"
574: "\ts1 != s2\tstrings s1 and s2 are not identical\n"
575: "\ts1 < s2\t\tstring s1 is less than s2\t\t(not Posix)\n"
576: "\ts1 > s2\t\tstring s1 is greater than s2\t\t(not Posix)\n"
577: "\tfile1 -ef file2\tfile1 and file2 are identical\t\t(not Posix)\n"
578: "\tn1 -eq n2\tnumbers n1 and n2 are equal\n"
579: "\tn1 -ge n2\tnumber n1 is greater than or equal to n2\n"
580: "\tn1 -gt n2\tnumber n1 is greater than n2\n"
581: "\tn1 -le n2\tnumber n1 is less than or equal to n2\n"
582: "\tn1 -lt n2\tnumber n1 is less than n2\n"
583: "\tn1 -ne n2\tnumbers n1 and n2 are not equal\n"
584: "\tfile1 -nt file2\tfile1 is newer than file2\t\t(not Posix)\n"
585: "\tfile1 -ot file2\tfile1 is older than file2\t\t(not Posix)\n"
586: );
587: WRITECONST (
588: "Expression grouping:\n"
589: "\t! exp\t\texp is false\n"
590: "\texp1 -a exp2\texp1 and exp2 are true\t\t\t(not Posix)\n"
591: "\texp1 -o exp2\texp1 or exp2 is true\t\t\t(not Posix)\n"
592: "\t( exp )\t\tparentheses for grouping\t\t(not Posix)\n"
593: );
594:
595: exit (2);
596: }
597:
598:
599: #ifdef USE_PROTO
600: int main (int argc, char * argv [])
601: #else
602: int
603: main (argc, argv)
604: int argc;
605: char * argv [];
606: #endif
607: {
608: if (strcmp (argv [0], "[") == 0) {
609: if (strcmp (argv [argc - 1], "]") != 0)
610: error (argv [0], "Missing ']'");
611: argc --;
612: }
613:
614: if ((argc = test (argc - 1, argv + 1)) == 2)
615: error (argv [0], "syntax error");
616:
617: return argc;
618: }
619:
620: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.