![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to y.tab.c 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 / obj386|
Return to y.tab.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / test / obj386 |
1.1 root 1:
2: #line 1 "../test.y"
3:
4: /*
5: * Set return status based on
6: * various specified conditions,
7: * mostly related to files.
8: * Used mostly in shell files.
9: */
10:
11: #include <stdio.h>
12: #include <sys/stat.h>
13: #include <access.h>
14: #include "testnode.h"
15:
16: #define NPRIM (sizeof(prims)/sizeof(prims[0]))
17: #define NFNAME 500 /* size of filename buffer */
18:
19: #include "y.tab.h"
20: #define YYCLEARIN yychar = -1000
21: #define YYERROK yyerrflag = 0
22: extern int yychar;
23: extern short yyerrflag;
24: #ifndef YYMAXDEPTH
25: #define YYMAXDEPTH 150
26: #endif
27: YYSTYPE yyval, yylval;
28:
29: #line 63 "../test.y"
30:
31: struct prim {
32: char *p_name;
33: int p_lval;
34: int p_bin;
35: } prims[] = {
36: "-r", _R, 0,
37: "-w", _W, 0,
38: "-f", _F, 0,
39: "-d", _D, 0,
40: "-s", _S, 0,
41: "-t", _T, 0,
42: "-z", _Z, 0,
43: "-n", _N, 0,
44: "-eq", _EQ, 1,
45: "-ne", _NE, 1,
46: "-gt", _GT, 1,
47: "-ge", _GE, 1,
48: "-lt", _LT, 1,
49: "-le", _LE, 1,
50: "-o", OR, 1,
51: "-a", AND, 1
52: };
53:
54:
55: char **gav;
56: int gac;
57:
58: struct stat sb;
59:
60: NODE *code;
61:
62: char *next();
63: NODE *bnode();
64: NODE *lnode();
65: long atol();
66: int xr();
67: int xw();
68: int xf();
69: int xd();
70: int xs();
71: int xt();
72: int xz();
73: int xn();
74: int xseq();
75: int xsneq();
76: int xeq();
77: int xne();
78: int xgt();
79: int xge();
80: int xlt();
81:
82: main(argc, argv)
83: char *argv[];
84: {
85: gav = argv+1;
86: gac = argc-1;
87: if (argv[0][0]=='[' && argv[0][1]=='\0') {
88: if (strcmp(argv[gac], "]") != 0)
89: tsterr("unbalanced [..]");
90: gac--;
91: }
92: if (gac == 0)
93: exit(1);
94: yyparse();
95: exit(!execute(code));
96: }
97:
98: /*
99: * Lexical analyser
100: */
101: yylex()
102: {
103: static char laststr = 0; /* 1 if last token was string */
104: register char *ap;
105: register struct prim *pp;
106:
107: if ((yylval.fname = ap = next()) == NULL)
108: return ('\n');
109:
110: if (*ap == '-') {
111: for (pp = prims; pp < &prims[NPRIM]; pp++) {
112: if (strcmp(pp->p_name, ap) == 0) {
113: if (!laststr && pp->p_bin)
114: break;
115: laststr = 0;
116: return (pp->p_lval);
117: }
118: }
119: }
120: else {
121: laststr = 0;
122: if (strcmp("!=", ap) == 0)
123: return (SNEQ);
124:
125: if (ap[1] == '\0') {
126: if (ap[0]==')') {
127: laststr = 1;
128: return(')');
129: }
130: if (ap[0]=='(' || ap[0]=='!')
131: return (ap[0]);
132: if (ap[0]=='=')
133: return (SEQ);
134: }
135: }
136: laststr = 1;
137: return (STR);
138: }
139:
140: yyerror()
141: {
142: fprintf(stderr, "Test expression syntax error\n");
143: usage();
144: }
145:
146: /*
147: * Return the next argument from the arg list.
148: */
149: char *
150: next()
151: {
152: if (gac < 1)
153: return (NULL);
154: gac--;
155: return (*gav++);
156: }
157:
158: /*
159: * Build an expression tree node (non-leaf)
160: */
161: NODE *
162: bnode(op, left, right)
163: int op;
164: NODE *left, *right;
165: {
166: register NODE *np;
167: char *malloc();
168:
169: if ((np = (NODE *)malloc(sizeof (NODE))) == NULL)
170: tsterr("Out of space");
171: np->n_un.n_op = op;
172: np->n_left = left;
173: np->n_right = right;
174: return (np);
175: }
176:
177: /*
178: * Build a leaf node in expression tree.
179: */
180: NODE *
181: lnode(fn, str1, str2)
182: int (*fn)();
183: char *str1, *str2;
184: {
185: register NODE *np;
186: char *malloc();
187:
188: if ((np = (NODE *)malloc(sizeof (NODE))) == NULL)
189: tsterr("Out of space");
190: np->n_left = np->n_right = NULL;
191: np->n_un.n_fun = fn;
192: np->n_s1 = str1;
193: np->n_s2 = str2;
194: return (np);
195: }
196:
197: /*
198: * Execute compiled code.
199: */
200: execute(np)
201: register NODE *np;
202: {
203: if (np->n_left != NULL)
204: switch (np->n_un.n_op) {
205: case AND:
206: if (execute(np->n_left) && execute(np->n_right))
207: return (1);
208: return (0);
209:
210: case OR:
211: if (execute(np->n_left) || execute(np->n_right))
212: return (1);
213: return (0);
214:
215: case '!':
216: return (!execute(np->n_left));
217:
218: default:
219: tsterr("Panic: bad tree (op %d)", np->n_un.n_op);
220: }
221: else
222: return ((*np->n_un.n_fun)(np));
223: /* NOTREACHED */
224: }
225:
226: /*
227: * Check to see if the file exists
228: * and if readable.
229: */
230: xr(np)
231: NODE *np;
232: {
233: return (access(np->n_s1, AREAD) >= 0);
234: }
235:
236: /*
237: * Check if the file exists and is
238: * writeable.
239: */
240: xw(np)
241: NODE *np;
242: {
243: return (access(np->n_s1, AWRITE) >= 0);
244: }
245:
246: /*
247: * Check if the file exists and is not
248: * a directory.
249: */
250: xf(np)
251: NODE *np;
252: {
253: return (stat(np->n_s1, &sb)>=0 && (sb.st_mode&S_IFMT)!=S_IFDIR);
254: }
255:
256: /*
257: * Check to see if the file exists
258: * and is a directory.
259: */
260: xd(np)
261: NODE *np;
262: {
263: return (stat(np->n_s1, &sb)>=0 && (sb.st_mode&S_IFMT)==S_IFDIR);
264: }
265:
266: /*
267: * Check to see if the file exists
268: * and has a non-zero size.
269: */
270: xs(np)
271: NODE *np;
272: {
273: return (stat(np->n_s1, &sb)>=0 && sb.st_size>0);
274: }
275:
276: /*
277: * Check to see if the file
278: * descriptor is associated
279: * with a terminal.
280: */
281: xt(np)
282: NODE *np;
283: {
284: return (isatty(atoi(np->n_s1)));
285: }
286:
287: /*
288: * True if the length of the given
289: * string is zero.
290: */
291: xz(np)
292: NODE *np;
293: {
294: return (np->n_s1[0] == '\0');
295: }
296:
297: /*
298: * True if the length of the given
299: * string is non-zero.
300: */
301: xn(np)
302: NODE *np;
303: {
304: return (np->n_s1[0] != '\0');
305: }
306:
307: /*
308: * True if the two strings are
309: * lexicographically equal.
310: */
311: xseq(np)
312: register NODE *np;
313: {
314: return (strcmp(np->n_s1, np->n_s2) == 0);
315: }
316:
317: /*
318: * True if the two strings are
319: * lexicographically unequal.
320: */
321: xsneq(np)
322: register NODE *np;
323: {
324: return (strcmp(np->n_s1, np->n_s2) != 0);
325: }
326:
327: /*
328: * True if the two numbers are
329: * equal.
330: */
331: xeq(np)
332: register NODE *np;
333: {
334: return (atol(np->n_s1) == atol(np->n_s2));
335: }
336:
337: /*
338: * True if the two numbers are
339: * not equal.
340: */
341: xne(np)
342: register NODE *np;
343: {
344: return (atol(np->n_s1) != atol(np->n_s2));
345: }
346:
347: /*
348: * True if the first number is
349: * greater than the second.
350: */
351: xgt(np)
352: register NODE *np;
353: {
354: return (atol(np->n_s1) > atol(np->n_s2));
355: }
356:
357: /*
358: * True if the first number is
359: * greater than or equal to the second.
360: */
361: xge(np)
362: register NODE *np;
363: {
364: return (atol(np->n_s1) >= atol(np->n_s2));
365: }
366:
367: /*
368: * True if the first number is
369: * less than the second.
370: */
371: xlt(np)
372: register NODE *np;
373: {
374: return (atol(np->n_s1) < atol(np->n_s2));
375: }
376:
377: /*
378: * True if the first number is
379: * less than or equal to the second.
380: */
381: xle(np)
382: register NODE *np;
383: {
384: return (atol(np->n_s1) <= atol(np->n_s2));
385: }
386:
387: /*
388: * Error messages.
389: */
390: /* VARARGS */
391: tsterr(x)
392: {
393: fprintf(stderr, "test: %r\n", &x);
394: exit(1);
395: }
396:
397: usage()
398: {
399: fprintf(stderr, "Usage: test expression\n");
400: exit(1);
401: }
402: #ifdef YYTNAMES
403: readonly struct yytname yytnames[26] =
404: {
405: "$end", -1,
406: "error", -2,
407: "OR", 256,
408: "AND", 257,
409: "'!'", 33,
410: "_R", 258,
411: "_W", 259,
412: "_F", 260,
413: "_D", 261,
414: "_S", 262,
415: "_T", 263,
416: "_Z", 264,
417: "_N", 265,
418: "SEQ", 266,
419: "SNEQ", 267,
420: "_EQ", 268,
421: "_NE", 269,
422: "_GT", 270,
423: "_GE", 271,
424: "_LT", 272,
425: "_LE", 273,
426: "STR", 275,
427: "'\\n'", 10,
428: "'('", 40,
429: "')'", 41,
430: NULL
431: } ;
432: #endif
433: #include <action.h>
434: unsigned char yypdnt[24] = {
435: 0, 1, 2, 2, 2, 2, 2, 2,
436: 2, 2, 2, 2, 2, 2, 2, 2,
437: 2, 2, 2, 2, 2, 2, 2, 2
438: };
439: unsigned char yypn[24] = {
440: 2, 2, 3, 2, 3, 3, 2, 2,
441: 2, 2, 2, 2, 1, 2, 2, 3,
442: 3, 3, 3, 3, 3, 3, 3, 1
443: };
444: unsigned char yypgo[3] = {
445: 0, 0, 2
446: };
447: unsigned int yygo[12] = {
448: -1000, 12, 1, 14, 11, 31, 33, 45,
449: 34, 46, -1000, 13
450: };
451: unsigned char yypa[47] = {
452: 0, 0, 24, 28, 32, 36, 40, 44,
453: 48, 52, 56, 0, 74, 78, 86, 88,
454: 90, 92, 94, 96, 98, 100, 102, 104,
455: 108, 112, 116, 120, 124, 128, 132, 136,
456: 144, 0, 0, 148, 150, 152, 154, 156,
457: 158, 160, 162, 164, 166, 168, 172
458: };
459: unsigned int yyact[174] = {
460: 1, 33, 2, 258, 3, 259, 4, 260,
461: 5, 261, 6, 262, 7, 263, 8, 264,
462: 9, 265, 10, 275, 11, 40, 24576, -1000,
463: 15, 275, 24576, -1000, 16, 275, 24576, -1000,
464: 17, 275, 24576, -1000, 18, 275, 24576, -1000,
465: 19, 275, 24576, -1000, 20, 275, 8204, -1000,
466: 21, 275, 24576, -1000, 22, 275, 24576, -1000,
467: 23, 266, 24, 267, 25, 268, 26, 269,
468: 27, 270, 28, 271, 29, 272, 30, 273,
469: 8215, -1000, 32, -1, 24576, -1000, 33, 256,
470: 34, 257, 35, 10, 24576, -1000, 8195, -1000,
471: 8198, -1000, 8199, -1000, 8200, -1000, 8201, -1000,
472: 8202, -1000, 8203, -1000, 8205, -1000, 8206, -1000,
473: 36, 275, 24576, -1000, 37, 275, 24576, -1000,
474: 38, 275, 24576, -1000, 39, 275, 24576, -1000,
475: 40, 275, 24576, -1000, 41, 275, 24576, -1000,
476: 42, 275, 24576, -1000, 43, 275, 24576, -1000,
477: 33, 256, 34, 257, 44, 41, 24576, -1000,
478: 16384, -1, 24576, -1000, 8193, -1000, 8207, -1000,
479: 8208, -1000, 8209, -1000, 8210, -1000, 8211, -1000,
480: 8212, -1000, 8213, -1000, 8214, -1000, 8194, -1000,
481: 34, 257, 8196, -1000, 8197, -1000
482: };
483: #define YYNOCHAR (-1000)
484: #define yyerrok yyerrflag=0
485: #define yyclearin yylval=YYNOCHAR
486: int yystack[YYMAXDEPTH];
487: YYSTYPE yyvstack[YYMAXDEPTH], *yyv;
488: int yychar;
489:
490: #ifdef YYDEBUG
491: int yydebug = 1; /* No sir, not in the BSS */
492: #include <stdio.h>
493: #endif
494:
495: short yyerrflag;
496: int *yys;
497:
498: yyparse()
499: {
500: register YYSTYPE *yypvt;
501: int act;
502: register unsigned *ip, yystate;
503: int pno;
504: yystate = 0;
505: yychar = YYNOCHAR;
506: yyv = &yyvstack[-1];
507: yys = &yystack[-1];
508:
509: stack:
510: if( ++yys >= &yystack[YYMAXDEPTH] ) {
511: write(2, "Stack overflow\n", 15);
512: exit(1);
513: }
514: *yys = yystate;
515: *++yyv = yyval;
516: #ifdef YYDEBUG
517: if( yydebug )
518: fprintf(stdout, "Stack state %d, char %d\n", yystate, yychar);
519: #endif
520:
521: read:
522: ip = &yyact[yypa[yystate]];
523: if( ip[1] != YYNOCHAR ) {
524: if( yychar == YYNOCHAR ) {
525: yychar = yylex();
526: #ifdef YYDEBUG
527: if( yydebug )
528: fprintf(stdout, "lex read char %d, val %d\n", yychar, yylval);
529: #endif
530: }
531: while (ip[1]!=YYNOCHAR) {
532: if (ip[1]==yychar)
533: break;
534: ip += 2;
535: }
536: }
537: act = ip[0];
538: switch( act>>YYACTSH ) {
539: case YYSHIFTACT:
540: if( ip[1]==YYNOCHAR )
541: goto YYerract;
542: if( yychar != -1 )
543: yychar = YYNOCHAR; /* dont throw away EOF */
544: yystate = act&YYAMASK;
545: yyval = yylval;
546: #ifdef YYDEBUG
547: if( yydebug )
548: fprintf(stdout, "shift %d\n", yystate);
549: #endif
550: if( yyerrflag )
551: --yyerrflag;
552: goto stack;
553:
554: case YYACCEPTACT:
555: #ifdef YYDEBUG
556: if( yydebug )
557: fprintf(stdout, "accept\n");
558: #endif
559: return(0);
560:
561: case YYERRACT:
562: YYerract:
563: switch (yyerrflag) {
564: case 0:
565: yyerror("Syntax error");
566:
567: case 1:
568: case 2:
569:
570: yyerrflag = 3;
571: while( yys >= & yystack[0] ) {
572: ip = &yyact[yypa[*yys]];
573: while( ip[1]!=YYNOCHAR )
574: ip += 2;
575: if( (*ip&~YYAMASK) == (YYSHIFTACT<<YYACTSH) ) {
576: yystate = *ip&YYAMASK;
577: goto stack;
578: }
579: #ifdef YYDEBUG
580: if( yydebug )
581: fprintf(stderr, "error recovery leaves state %d, uncovers %d\n", *yys, yys[-1]);
582: #endif
583: yys--;
584: yyv--;
585: }
586: #ifdef YYDEBUG
587: if( yydebug )
588: fprintf(stderr, "no shift on error; abort\n");
589: #endif
590: return(1);
591:
592: case 3:
593: #ifdef YYDEBUG
594: if( yydebug )
595: fprintf(stderr, "Error recovery clobbers char %o\n", yychar);
596: #endif
597: if( yychar==YYEOFVAL )
598: return(1);
599: yychar = YYNOCHAR;
600: goto read;
601: }
602:
603: case YYREDACT:
604: pno = act&YYAMASK;
605: #ifdef YYDEBUG
606: if( yydebug )
607: fprintf(stdout, "reduce %d\n", pno);
608: #endif
609: yypvt = yyv;
610: yyv -= yypn[pno];
611: yys -= yypn[pno];
612: yyval = yyv[1];
613: switch(pno) {
614:
615: case 1: {
616:
617: #line 35 "../test.y"
618: code = yypvt[-1].nodeptr; return; }break;
619:
620: case 2: {
621:
622: #line 39 "../test.y"
623: yyval.nodeptr = yypvt[-1].nodeptr; }break;
624:
625: case 3: {
626:
627: #line 40 "../test.y"
628: yyval.nodeptr = bnode('!', yypvt[0].nodeptr, NULL); }break;
629:
630: case 4: {
631:
632: #line 41 "../test.y"
633: yyval.nodeptr = bnode(OR, yypvt[-2].nodeptr, yypvt[0].nodeptr); }break;
634:
635: case 5: {
636:
637: #line 42 "../test.y"
638: yyval.nodeptr = bnode(AND, yypvt[-2].nodeptr, yypvt[0].nodeptr); }break;
639:
640: case 6: {
641:
642: #line 43 "../test.y"
643: yyval.nodeptr = lnode(xr, yypvt[0].fname, NULL); }break;
644:
645: case 7: {
646:
647: #line 44 "../test.y"
648: yyval.nodeptr = lnode(xw, yypvt[0].fname, NULL); }break;
649:
650: case 8: {
651:
652: #line 45 "../test.y"
653: yyval.nodeptr = lnode(xf, yypvt[0].fname, NULL); }break;
654:
655: case 9: {
656:
657: #line 46 "../test.y"
658: yyval.nodeptr = lnode(xd, yypvt[0].fname, NULL); }break;
659:
660: case 10: {
661:
662: #line 47 "../test.y"
663: yyval.nodeptr = lnode(xs, yypvt[0].fname, NULL); }break;
664:
665: case 11: {
666:
667: #line 48 "../test.y"
668: yyval.nodeptr = lnode(xt, yypvt[0].fname, NULL); }break;
669:
670: case 12: {
671:
672: #line 49 "../test.y"
673: yyval.nodeptr = lnode(xt, "1", NULL); }break;
674:
675: case 13: {
676:
677: #line 50 "../test.y"
678: yyval.nodeptr = lnode(xz, yypvt[0].fname, NULL); }break;
679:
680: case 14: {
681:
682: #line 51 "../test.y"
683: yyval.nodeptr = lnode(xn, yypvt[0].fname, NULL); }break;
684:
685: case 15: {
686:
687: #line 52 "../test.y"
688: yyval.nodeptr = lnode(xseq, yypvt[-2].fname, yypvt[0].fname); }break;
689:
690: case 16: {
691:
692: #line 53 "../test.y"
693: yyval.nodeptr = lnode(xsneq, yypvt[-2].fname, yypvt[0].fname); }break;
694:
695: case 17: {
696:
697: #line 54 "../test.y"
698: yyval.nodeptr = lnode(xeq, yypvt[-2].fname, yypvt[0].fname); }break;
699:
700: case 18: {
701:
702: #line 55 "../test.y"
703: yyval.nodeptr = lnode(xne, yypvt[-2].fname, yypvt[0].fname); }break;
704:
705: case 19: {
706:
707: #line 56 "../test.y"
708: yyval.nodeptr = lnode(xgt, yypvt[-2].fname, yypvt[0].fname); }break;
709:
710: case 20: {
711:
712: #line 57 "../test.y"
713: yyval.nodeptr = lnode(xge, yypvt[-2].fname, yypvt[0].fname); }break;
714:
715: case 21: {
716:
717: #line 58 "../test.y"
718: yyval.nodeptr = lnode(xlt, yypvt[-2].fname, yypvt[0].fname); }break;
719:
720: case 22: {
721:
722: #line 59 "../test.y"
723: yyval.nodeptr = lnode(xle, yypvt[-2].fname, yypvt[0].fname); }break;
724:
725: case 23: {
726:
727: #line 60 "../test.y"
728: yyval.nodeptr = lnode(xn, yypvt[0].fname, NULL); }break;
729:
730: }
731: ip = &yygo[ yypgo[yypdnt[pno]] ];
732: while( *ip!=*yys && *ip!=YYNOCHAR )
733: ip += 2;
734: yystate = ip[1];
735: goto stack;
736: }
737: }
738:
739:
740:
741:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.