![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to test.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / test|
Return to test.y CVS log | Up to [MW Coherent from dump] / coherent / d / bin / test |
1.1 root 1: %{
2: /*
3: * Set return status based on
4: * various specified conditions,
5: * mostly related to files.
6: * Used mostly in shell files.
7: */
8:
9: #include <stdio.h>
10: #include <sys/stat.h>
11: #include <access.h>
12: #include "testnode.h"
13:
14: #define NPRIM (sizeof(prims)/sizeof(prims[0]))
15: #define NFNAME 500 /* size of filename buffer */
16: %}
17: %start command
18:
19: %union {
20: NODE *nodeptr;
21: char *fname;
22: }
23:
24: %left OR
25: %left AND
26: %left '!'
27: %token _R _W _F _D _S _T _Z _N
28: %token SEQ SNEQ
29: %token _EQ _NE _GT _GE _LT _LE
30: %type <nodeptr> exp
31: %token <fname> STR
32: %%
33:
34: command:
35: exp '\n' { code = $1; return; }
36: ;
37:
38: exp:
39: '(' exp ')' { $$ = $2; }
40: | '!' exp { $$ = bnode('!', $2, NULL); }
41: | exp OR exp { $$ = bnode(OR, $1, $3); }
42: | exp AND exp { $$ = bnode(AND, $1, $3); }
43: | _R STR { $$ = lnode(xr, $2, NULL); }
44: | _W STR { $$ = lnode(xw, $2, NULL); }
45: | _F STR { $$ = lnode(xf, $2, NULL); }
46: | _D STR { $$ = lnode(xd, $2, NULL); }
47: | _S STR { $$ = lnode(xs, $2, NULL); }
48: | _T STR { $$ = lnode(xt, $2, NULL); }
49: | _T { $$ = lnode(xt, "1", NULL); }
50: | _Z STR { $$ = lnode(xz, $2, NULL); }
51: | _N STR { $$ = lnode(xn, $2, NULL); }
52: | STR SEQ STR { $$ = lnode(xseq, $1, $3); }
53: | STR SNEQ STR { $$ = lnode(xsneq, $1, $3); }
54: | STR _EQ STR { $$ = lnode(xeq, $1, $3); }
55: | STR _NE STR { $$ = lnode(xne, $1, $3); }
56: | STR _GT STR { $$ = lnode(xgt, $1, $3); }
57: | STR _GE STR { $$ = lnode(xge, $1, $3); }
58: | STR _LT STR { $$ = lnode(xlt, $1, $3); }
59: | STR _LE STR { $$ = lnode(xle, $1, $3); }
60: | STR { $$ = lnode(xn, $1, NULL); }
61: ;
62:
63: %%
64: struct prim {
65: char *p_name;
66: int p_lval;
67: int p_bin;
68: } prims[] = {
69: "-r", _R, 0,
70: "-w", _W, 0,
71: "-f", _F, 0,
72: "-d", _D, 0,
73: "-s", _S, 0,
74: "-t", _T, 0,
75: "-z", _Z, 0,
76: "-n", _N, 0,
77: "-eq", _EQ, 1,
78: "-ne", _NE, 1,
79: "-gt", _GT, 1,
80: "-ge", _GE, 1,
81: "-lt", _LT, 1,
82: "-le", _LE, 1,
83: "-o", OR, 1,
84: "-a", AND, 1
85: };
86:
87:
88: char **gav;
89: int gac;
90:
91: struct stat sb;
92:
93: NODE *code;
94:
95: char *next();
96: NODE *bnode();
97: NODE *lnode();
98: long atol();
99: int xr();
100: int xw();
101: int xf();
102: int xd();
103: int xs();
104: int xt();
105: int xz();
106: int xn();
107: int xseq();
108: int xsneq();
109: int xeq();
110: int xne();
111: int xgt();
112: int xge();
113: int xlt();
114:
115: main(argc, argv)
116: char *argv[];
117: {
118: gav = argv+1;
119: gac = argc-1;
120: if (argv[0][0]=='[' && argv[0][1]=='\0') {
121: if (strcmp(argv[gac], "]") != 0)
122: tsterr("unbalanced [..]");
123: gac--;
124: }
125: if (gac == 0)
126: exit(1);
127: yyparse();
128: exit(!execute(code));
129: }
130:
131: /*
132: * Lexical analyser
133: */
134: yylex()
135: {
136: static char laststr = 0; /* 1 if last token was string */
137: register char *ap;
138: register struct prim *pp;
139:
140: if ((yylval.fname = ap = next()) == NULL)
141: return ('\n');
142:
143: if (*ap == '-') {
144: for (pp = prims; pp < &prims[NPRIM]; pp++) {
145: if (strcmp(pp->p_name, ap) == 0) {
146: if (!laststr && pp->p_bin)
147: break;
148: laststr = 0;
149: return (pp->p_lval);
150: }
151: }
152: }
153: else {
154: laststr = 0;
155: if (strcmp("!=", ap) == 0)
156: return (SNEQ);
157:
158: if (ap[1] == '\0') {
159: if (ap[0]==')') {
160: laststr = 1;
161: return(')');
162: }
163: if (ap[0]=='(' || ap[0]=='!')
164: return (ap[0]);
165: if (ap[0]=='=')
166: return (SEQ);
167: }
168: }
169: laststr = 1;
170: return (STR);
171: }
172:
173: yyerror()
174: {
175: fprintf(stderr, "Test expression syntax error\n");
176: usage();
177: }
178:
179: /*
180: * Return the next argument from the arg list.
181: */
182: char *
183: next()
184: {
185: if (gac < 1)
186: return (NULL);
187: gac--;
188: return (*gav++);
189: }
190:
191: /*
192: * Build an expression tree node (non-leaf)
193: */
194: NODE *
195: bnode(op, left, right)
196: int op;
197: NODE *left, *right;
198: {
199: register NODE *np;
200: char *malloc();
201:
202: if ((np = (NODE *)malloc(sizeof (NODE))) == NULL)
203: tsterr("Out of space");
204: np->n_un.n_op = op;
205: np->n_left = left;
206: np->n_right = right;
207: return (np);
208: }
209:
210: /*
211: * Build a leaf node in expression tree.
212: */
213: NODE *
214: lnode(fn, str1, str2)
215: int (*fn)();
216: char *str1, *str2;
217: {
218: register NODE *np;
219: char *malloc();
220:
221: if ((np = (NODE *)malloc(sizeof (NODE))) == NULL)
222: tsterr("Out of space");
223: np->n_left = np->n_right = NULL;
224: np->n_un.n_fun = fn;
225: np->n_s1 = str1;
226: np->n_s2 = str2;
227: return (np);
228: }
229:
230: /*
231: * Execute compiled code.
232: */
233: execute(np)
234: register NODE *np;
235: {
236: if (np->n_left != NULL)
237: switch (np->n_un.n_op) {
238: case AND:
239: if (execute(np->n_left) && execute(np->n_right))
240: return (1);
241: return (0);
242:
243: case OR:
244: if (execute(np->n_left) || execute(np->n_right))
245: return (1);
246: return (0);
247:
248: case '!':
249: return (!execute(np->n_left));
250:
251: default:
252: tsterr("Panic: bad tree (op %d)", np->n_un.n_op);
253: }
254: else
255: return ((*np->n_un.n_fun)(np));
256: /* NOTREACHED */
257: }
258:
259: /*
260: * Check to see if the file exists
261: * and if readable.
262: */
263: xr(np)
264: NODE *np;
265: {
266: return (access(np->n_s1, AREAD) >= 0);
267: }
268:
269: /*
270: * Check if the file exists and is
271: * writeable.
272: */
273: xw(np)
274: NODE *np;
275: {
276: return (access(np->n_s1, AWRITE) >= 0);
277: }
278:
279: /*
280: * Check if the file exists and is not
281: * a directory.
282: */
283: xf(np)
284: NODE *np;
285: {
286: return (stat(np->n_s1, &sb)>=0 && (sb.st_mode&S_IFMT)!=S_IFDIR);
287: }
288:
289: /*
290: * Check to see if the file exists
291: * and is a directory.
292: */
293: xd(np)
294: NODE *np;
295: {
296: return (stat(np->n_s1, &sb)>=0 && (sb.st_mode&S_IFMT)==S_IFDIR);
297: }
298:
299: /*
300: * Check to see if the file exists
301: * and has a non-zero size.
302: */
303: xs(np)
304: NODE *np;
305: {
306: return (stat(np->n_s1, &sb)>=0 && sb.st_size>0);
307: }
308:
309: /*
310: * Check to see if the file
311: * descriptor is associated
312: * with a terminal.
313: */
314: xt(np)
315: NODE *np;
316: {
317: return (isatty(atoi(np->n_s1)));
318: }
319:
320: /*
321: * True if the length of the given
322: * string is zero.
323: */
324: xz(np)
325: NODE *np;
326: {
327: return (np->n_s1[0] == '\0');
328: }
329:
330: /*
331: * True if the length of the given
332: * string is non-zero.
333: */
334: xn(np)
335: NODE *np;
336: {
337: return (np->n_s1[0] != '\0');
338: }
339:
340: /*
341: * True if the two strings are
342: * lexicographically equal.
343: */
344: xseq(np)
345: register NODE *np;
346: {
347: return (strcmp(np->n_s1, np->n_s2) == 0);
348: }
349:
350: /*
351: * True if the two strings are
352: * lexicographically unequal.
353: */
354: xsneq(np)
355: register NODE *np;
356: {
357: return (strcmp(np->n_s1, np->n_s2) != 0);
358: }
359:
360: /*
361: * True if the two numbers are
362: * equal.
363: */
364: xeq(np)
365: register NODE *np;
366: {
367: return (atol(np->n_s1) == atol(np->n_s2));
368: }
369:
370: /*
371: * True if the two numbers are
372: * not equal.
373: */
374: xne(np)
375: register NODE *np;
376: {
377: return (atol(np->n_s1) != atol(np->n_s2));
378: }
379:
380: /*
381: * True if the first number is
382: * greater than the second.
383: */
384: xgt(np)
385: register NODE *np;
386: {
387: return (atol(np->n_s1) > atol(np->n_s2));
388: }
389:
390: /*
391: * True if the first number is
392: * greater than or equal to the second.
393: */
394: xge(np)
395: register NODE *np;
396: {
397: return (atol(np->n_s1) >= atol(np->n_s2));
398: }
399:
400: /*
401: * True if the first number is
402: * less than the second.
403: */
404: xlt(np)
405: register NODE *np;
406: {
407: return (atol(np->n_s1) < atol(np->n_s2));
408: }
409:
410: /*
411: * True if the first number is
412: * less than or equal to the second.
413: */
414: xle(np)
415: register NODE *np;
416: {
417: return (atol(np->n_s1) <= atol(np->n_s2));
418: }
419:
420: /*
421: * Error messages.
422: */
423: /* VARARGS */
424: tsterr(x)
425: {
426: fprintf(stderr, "test: %r\n", &x);
427: exit(1);
428: }
429:
430: usage()
431: {
432: fprintf(stderr, "Usage: test expression\n");
433: exit(1);
434: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.