![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin|
Return to expr.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin |
1.1 root 1: # define OR 257
2: # define AND 258
3: # define ADD 259
4: # define SUBT 260
5: # define MULT 261
6: # define DIV 262
7: # define REM 263
8: # define EQ 264
9: # define GT 265
10: # define GEQ 266
11: # define LT 267
12: # define LEQ 268
13: # define NEQ 269
14: # define A_STRING 270
15: # define SUBSTR 271
16: # define LENGTH 272
17: # define INDEX 273
18: # define NOARG 274
19: # define MATCH 275
20: # define MCH 276
21: #define yyclearin yychar = -1
22: #define yyerrok yyerrflag = 0
23: extern int yychar;
24: extern short yyerrflag;
25: #ifndef YYMAXDEPTH
26: #define YYMAXDEPTH 150
27: #endif
28: #ifndef YYSTYPE
29: #define YYSTYPE int
30: #endif
31: YYSTYPE yylval, yyval;
32: # define YYERRCODE 256
33:
34: # line 48 "expr.y"
35:
36: /* expression command */
37: #include <stdio.h>
38: #define ESIZE 256
39: #define error(c) errxx(c)
40: #define EQL(x,y) !strcmp(x,y)
41: long atol();
42: char **Av;
43: int Ac;
44: int Argi;
45:
46: char Mstring[1][128];
47: char *malloc();
48: extern int nbra;
49:
50: main(argc, argv) char **argv; {
51: Ac = argc;
52: Argi = 1;
53: Av = argv;
54: yyparse();
55: }
56:
57: char *operators[] = { "|", "&", "+", "-", "*", "/", "%", ":",
58: "=", "==", "<", "<=", ">", ">=", "!=",
59: "match", "substr", "length", "index", "\0" };
60: int op[] = { OR, AND, ADD, SUBT, MULT, DIV, REM, MCH,
61: EQ, EQ, LT, LEQ, GT, GEQ, NEQ,
62: MATCH, SUBSTR, LENGTH, INDEX };
63: yylex() {
64: register char *p;
65: register i;
66:
67: if(Argi >= Ac) return NOARG;
68:
69: p = Av[Argi++];
70:
71: if(*p == '(' || *p == ')')
72: return (int)*p;
73: for(i = 0; *operators[i]; ++i)
74: if(EQL(operators[i], p))
75: return op[i];
76:
77: yylval = p;
78: return A_STRING;
79: }
80:
81: char *rel(op, r1, r2) register char *r1, *r2; {
82: register long i;
83:
84: if(ematch(r1, "-*[0-9]*$") && ematch(r2, "[0-9]*$"))
85: i = atol(r1) - atol(r2);
86: else
87: i = strcmp(r1, r2);
88: switch(op) {
89: case EQ: i = i==0; break;
90: case GT: i = i>0; break;
91: case GEQ: i = i>=0; break;
92: case LT: i = i<0; break;
93: case LEQ: i = i<=0; break;
94: case NEQ: i = i!=0; break;
95: }
96: return i? "1": "0";
97: }
98:
99: char *arith(op, r1, r2) char *r1, *r2; {
100: long i1, i2;
101: register char *rv;
102:
103: if(!(ematch(r1, "[0-9]*$") && ematch(r2, "[0-9]*$")))
104: yyerror("non-numeric argument");
105: i1 = atol(r1);
106: i2 = atol(r2);
107:
108: switch(op) {
109: case ADD: i1 = i1 + i2; break;
110: case SUBT: i1 = i1 - i2; break;
111: case MULT: i1 = i1 * i2; break;
112: case DIV: i1 = i1 / i2; break;
113: case REM: i1 = i1 % i2; break;
114: }
115: rv = malloc(16);
116: sprintf(rv, "%D", i1);
117: return rv;
118: }
119: char *conj(op, r1, r2) char *r1, *r2; {
120: register char *rv;
121:
122: switch(op) {
123:
124: case OR:
125: if(EQL(r1, "0")
126: || EQL(r1, ""))
127: if(EQL(r2, "0")
128: || EQL(r2, ""))
129: rv = "0";
130: else
131: rv = r2;
132: else
133: rv = r1;
134: break;
135: case AND:
136: if(EQL(r1, "0")
137: || EQL(r1, ""))
138: rv = "0";
139: else if(EQL(r2, "0")
140: || EQL(r2, ""))
141: rv = "0";
142: else
143: rv = r1;
144: break;
145: }
146: return rv;
147: }
148:
149: char *substr(v, s, w) char *v, *s, *w; {
150: register si, wi;
151: register char *res;
152:
153: si = atol(s);
154: wi = atol(w);
155: while(--si) if(*v) ++v;
156:
157: res = v;
158:
159: while(wi--) if(*v) ++v;
160:
161: *v = '\0';
162: return res;
163: }
164:
165: char *length(s) register char *s; {
166: register i = 0;
167: register char *rv;
168:
169: while(*s++) ++i;
170:
171: rv = malloc(8);
172: sprintf(rv, "%d", i);
173: return rv;
174: }
175:
176: char *index(s, t) char *s, *t; {
177: register i, j;
178: register char *rv;
179:
180: for(i = 0; s[i] ; ++i)
181: for(j = 0; t[j] ; ++j)
182: if(s[i]==t[j]) {
183: sprintf(rv = malloc(8), "%d", ++i);
184: return rv;
185: }
186: return "0";
187: }
188:
189: char *match(s, p)
190: {
191: register char *rv;
192:
193: sprintf(rv = malloc(8), "%d", ematch(s, p));
194: if(nbra) {
195: rv = malloc(strlen(Mstring[0])+1);
196: strcpy(rv, Mstring[0]);
197: }
198: return rv;
199: }
200:
201: #define INIT register char *sp = instring;
202: #define GETC() (*sp++)
203: #define PEEKC() (*sp)
204: #define UNGETC(c) (--sp)
205: #define RETURN(c) return
206: #define ERROR(c) errxx(c)
207:
208:
209: ematch(s, p)
210: char *s;
211: register char *p;
212: {
213: static char expbuf[ESIZE];
214: char *compile();
215: register num;
216: extern char *braslist[], *braelist[], *loc2;
217:
218: compile(p, expbuf, &expbuf[ESIZE], 0);
219: if(nbra > 1)
220: yyerror("Too many '\\('s");
221: if(advance(s, expbuf)) {
222: if(nbra == 1) {
223: p = braslist[0];
224: num = braelist[0] - p;
225: strncpy(Mstring[0], p, num);
226: Mstring[0][num] = '\0';
227: }
228: return(loc2-s);
229: }
230: return(0);
231: }
232:
233: errxx(c)
234: {
235: yyerror("RE error");
236: }
237:
238: #define CBRA 2
239: #define CCHR 4
240: #define CDOT 8
241: #define CCL 12
242: #define CDOL 20
243: #define CEOF 22
244: #define CKET 24
245: #define CBACK 36
246:
247: #define STAR 01
248: #define RNGE 03
249:
250: #define NBRA 9
251:
252: #define PLACE(c) ep[c >> 3] |= bittab[c & 07]
253: #define ISTHERE(c) (ep[c >> 3] & bittab[c & 07])
254:
255: char *braslist[NBRA];
256: char *braelist[NBRA];
257: int nbra;
258: char *loc1, *loc2, *locs;
259: int sed;
260:
261: int circf;
262: int low;
263: int size;
264:
265: char bittab[] = {
266: 1,
267: 2,
268: 4,
269: 8,
270: 16,
271: 32,
272: 64,
273: 128
274: };
275:
276: char *
277: compile(instring, ep, endbuf, seof)
278: register char *ep;
279: char *instring, *endbuf;
280: {
281: INIT /* Dependent declarations and initializations */
282: register c;
283: register eof = seof;
284: char *lastep = instring;
285: int cclcnt;
286: char bracket[NBRA], *bracketp;
287: int closed;
288: char neg;
289: int lc;
290: int i, cflg;
291:
292: lastep = 0;
293: if((c = GETC()) == eof) {
294: if(*ep == 0 && !sed)
295: ERROR(41);
296: RETURN(ep);
297: }
298: bracketp = bracket;
299: circf = closed = nbra = 0;
300: if (c == '^')
301: circf++;
302: else
303: UNGETC(c);
304: for (;;) {
305: if (ep >= endbuf)
306: ERROR(50);
307: if((c = GETC()) != '*' && ((c != '\\') || (PEEKC() != '{')))
308: lastep = ep;
309: if (c == eof) {
310: *ep++ = CEOF;
311: RETURN(ep);
312: }
313: switch (c) {
314:
315: case '.':
316: *ep++ = CDOT;
317: continue;
318:
319: case '\n':
320: ERROR(36);
321: case '*':
322: if (lastep==0 || *lastep==CBRA || *lastep==CKET)
323: goto defchar;
324: *lastep |= STAR;
325: continue;
326:
327: case '$':
328: if(PEEKC() != eof)
329: goto defchar;
330: *ep++ = CDOL;
331: continue;
332:
333: case '[':
334: if(&ep[17] >= endbuf)
335: ERROR(50);
336:
337: *ep++ = CCL;
338: lc = 0;
339: for(i = 0; i < 16; i++)
340: ep[i] = 0;
341:
342: neg = 0;
343: if((c = GETC()) == '^') {
344: neg = 1;
345: c = GETC();
346: }
347:
348: do {
349: if(c == '\0' || c == '\n')
350: ERROR(49);
351: if(c == '-' && lc != 0) {
352: if ((c = GETC()) == ']') {
353: PLACE('-');
354: break;
355: }
356: while(lc < c) {
357: PLACE(lc);
358: lc++;
359: }
360: }
361: lc = c;
362: PLACE(c);
363: } while((c = GETC()) != ']');
364: if(neg) {
365: for(cclcnt = 0; cclcnt < 16; cclcnt++)
366: ep[cclcnt] ^= -1;
367: ep[0] &= 0376;
368: }
369:
370: ep += 16;
371:
372: continue;
373:
374: case '\\':
375: switch(c = GETC()) {
376:
377: case '(':
378: if(nbra >= NBRA)
379: ERROR(43);
380: *bracketp++ = nbra;
381: *ep++ = CBRA;
382: *ep++ = nbra++;
383: continue;
384:
385: case ')':
386: if(bracketp <= bracket)
387: ERROR(42);
388: *ep++ = CKET;
389: *ep++ = *--bracketp;
390: closed++;
391: continue;
392:
393: case '{':
394: if(lastep == (char *) (0))
395: goto defchar;
396: *lastep |= RNGE;
397: cflg = 0;
398: nlim:
399: c = GETC();
400: i = 0;
401: do {
402: if ('0' <= c && c <= '9')
403: i = 10 * i + c - '0';
404: else
405: ERROR(16);
406: } while(((c = GETC()) != '\\') && (c != ','));
407: if (i > 255)
408: ERROR(11);
409: *ep++ = i;
410: if (c == ',') {
411: if(cflg++)
412: ERROR(44);
413: if((c = GETC()) == '\\')
414: *ep++ = 255;
415: else {
416: UNGETC(c);
417: goto nlim; /* get 2'nd number */
418: }
419: }
420: if(GETC() != '}')
421: ERROR(45);
422: if(!cflg) /* one number */
423: *ep++ = i;
424: else if((ep[-1] & 0377) < (ep[-2] & 0377))
425: ERROR(46);
426: continue;
427:
428: case '\n':
429: ERROR(36);
430:
431: case 'n':
432: c = '\n';
433: goto defchar;
434:
435: default:
436: if(c >= '1' && c <= '9') {
437: if((c -= '1') >= closed)
438: ERROR(25);
439: *ep++ = CBACK;
440: *ep++ = c;
441: continue;
442: }
443: }
444: /* Drop through to default to use \ to turn off special chars */
445:
446: defchar:
447: default:
448: lastep = ep;
449: *ep++ = CCHR;
450: *ep++ = c;
451: }
452: }
453: }
454:
455: step(p1, p2)
456: register char *p1, *p2;
457: {
458: register c;
459:
460: if (circf) {
461: loc1 = p1;
462: return(advance(p1, p2));
463: }
464: /* fast check for first character */
465: if (*p2==CCHR) {
466: c = p2[1];
467: do {
468: if (*p1 != c)
469: continue;
470: if (advance(p1, p2)) {
471: loc1 = p1;
472: return(1);
473: }
474: } while (*p1++);
475: return(0);
476: }
477: /* regular algorithm */
478: do {
479: if (advance(p1, p2)) {
480: loc1 = p1;
481: return(1);
482: }
483: } while (*p1++);
484: return(0);
485: }
486:
487: advance(lp, ep)
488: register char *lp, *ep;
489: {
490: register char *curlp;
491: char c;
492: char *bbeg;
493: int ct;
494:
495: for (;;) switch (*ep++) {
496:
497: case CCHR:
498: if (*ep++ == *lp++)
499: continue;
500: return(0);
501:
502: case CDOT:
503: if (*lp++)
504: continue;
505: return(0);
506:
507: case CDOL:
508: if (*lp==0)
509: continue;
510: return(0);
511:
512: case CEOF:
513: loc2 = lp;
514: return(1);
515:
516: case CCL:
517: c = *lp++ & 0177;
518: if(ISTHERE(c)) {
519: ep += 16;
520: continue;
521: }
522: return(0);
523: case CBRA:
524: braslist[*ep++] = lp;
525: continue;
526:
527: case CKET:
528: braelist[*ep++] = lp;
529: continue;
530:
531: case CCHR|RNGE:
532: c = *ep++;
533: getrnge(ep);
534: while(low--)
535: if(*lp++ != c)
536: return(0);
537: curlp = lp;
538: while(size--)
539: if(*lp++ != c)
540: break;
541: if(size < 0)
542: lp++;
543: ep += 2;
544: goto star;
545:
546: case CDOT|RNGE:
547: getrnge(ep);
548: while(low--)
549: if(*lp++ == '\0')
550: return(0);
551: curlp = lp;
552: while(size--)
553: if(*lp++ == '\0')
554: break;
555: if(size < 0)
556: lp++;
557: ep += 2;
558: goto star;
559:
560: case CCL|RNGE:
561: getrnge(ep + 16);
562: while(low--) {
563: c = *lp++ & 0177;
564: if(!ISTHERE(c))
565: return(0);
566: }
567: curlp = lp;
568: while(size--) {
569: c = *lp++ & 0177;
570: if(!ISTHERE(c))
571: break;
572: }
573: if(size < 0)
574: lp++;
575: ep += 18; /* 16 + 2 */
576: goto star;
577:
578: case CBACK:
579: bbeg = braslist[*ep];
580: ct = braelist[*ep++] - bbeg;
581:
582: if(ecmp(bbeg, lp, ct)) {
583: lp += ct;
584: continue;
585: }
586: return(0);
587:
588: case CBACK|STAR:
589: bbeg = braslist[*ep];
590: ct = braelist[*ep++] - bbeg;
591: curlp = lp;
592: while(ecmp(bbeg, lp, ct))
593: lp += ct;
594:
595: while(lp >= curlp) {
596: if(advance(lp, ep)) return(1);
597: lp -= ct;
598: }
599: return(0);
600:
601:
602: case CDOT|STAR:
603: curlp = lp;
604: while (*lp++);
605: goto star;
606:
607: case CCHR|STAR:
608: curlp = lp;
609: while (*lp++ == *ep);
610: ep++;
611: goto star;
612:
613: case CCL|STAR:
614: curlp = lp;
615: do {
616: c = *lp++ & 0177;
617: } while(ISTHERE(c));
618: ep += 16;
619: goto star;
620:
621: star:
622: do {
623: if(--lp == locs)
624: break;
625: if (advance(lp, ep))
626: return(1);
627: } while (lp > curlp);
628: return(0);
629:
630: }
631: }
632:
633: getrnge(str)
634: register char *str;
635: {
636: low = *str++ & 0377;
637: size = *str == 255 ? 20000 : (*str &0377) - low;
638: }
639:
640: ecmp(a, b, count)
641: register char *a, *b;
642: register count;
643: {
644: if(a == b) /* should have been caught in compile() */
645: error(51);
646: while(count--)
647: if(*a++ != *b++) return(0);
648: return(1);
649: }
650:
651: static char *sccsid = "@(#)expr.y 4.3 (Berkeley) 6/30/83";
652: yyerror(s)
653:
654: {
655: fprintf(stderr, "%s\n", s);
656: exit(2);
657: }
658: short yyexca[] ={
659: -1, 1,
660: 0, -1,
661: -2, 0,
662: };
663: # define YYNPROD 22
664: # define YYLAST 270
665: short yyact[]={
666:
667: 3, 10, 11, 18, 19, 20, 21, 22, 12, 13,
668: 14, 15, 16, 17, 23, 1, 0, 0, 9, 0,
669: 23, 43, 11, 18, 19, 20, 21, 22, 12, 13,
670: 14, 15, 16, 17, 3, 18, 19, 20, 21, 22,
671: 23, 18, 19, 20, 21, 22, 12, 13, 14, 15,
672: 16, 17, 23, 20, 21, 22, 0, 0, 23, 2,
673: 0, 0, 0, 24, 25, 26, 27, 28, 23, 0,
674: 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
675: 39, 40, 41, 42, 0, 44, 45, 0, 46, 0,
676: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
677: 0, 0, 0, 0, 0, 47, 0, 0, 0, 0,
678: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
679: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
680: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
681: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
682: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
683: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
684: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
685: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
686: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
687: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
688: 0, 0, 0, 0, 0, 0, 0, 10, 11, 18,
689: 19, 20, 21, 22, 12, 13, 14, 15, 16, 17,
690: 8, 5, 6, 7, 0, 4, 23, 10, 11, 18,
691: 19, 20, 21, 22, 12, 13, 14, 15, 16, 17,
692: 0, 0, 0, 0, 0, 0, 23, 0, 0, 0,
693: 0, 0, 0, 0, 8, 5, 6, 7, 0, 4 };
694: short yypact[]={
695:
696: -6,-1000,-256, -6, -6, -6, -6, -6,-1000,-1000,
697: -6, -6, -6, -6, -6, -6, -6, -6, -6, -6,
698: -6, -6, -6, -6, -20, -40, -40,-1000, -40,-236,
699: -218,-224,-224,-224,-224,-224,-224,-208,-208,-262,
700: -262,-262,-1000,-1000,-1000, -40,-1000,-1000 };
701: short yypgo[]={
702:
703: 0, 15, 59 };
704: short yyr1[]={
705:
706: 0, 1, 2, 2, 2, 2, 2, 2, 2, 2,
707: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
708: 2, 2 };
709: short yyr2[]={
710:
711: 0, 2, 3, 3, 3, 3, 3, 3, 3, 3,
712: 3, 3, 3, 3, 3, 3, 3, 3, 4, 2,
713: 3, 1 };
714: short yychk[]={
715:
716: -1000, -1, -2, 40, 275, 271, 272, 273, 270, 274,
717: 257, 258, 264, 265, 266, 267, 268, 269, 259, 260,
718: 261, 262, 263, 276, -2, -2, -2, -2, -2, -2,
719: -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
720: -2, -2, -2, 41, -2, -2, -2, -2 };
721: short yydef[]={
722:
723: 0, -2, 0, 0, 0, 0, 0, 0, 21, 1,
724: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
725: 0, 0, 0, 0, 0, 0, 0, 19, 0, 3,
726: 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
727: 14, 15, 16, 2, 17, 0, 20, 18 };
728: #ifndef lint
729: static char yaccpar_sccsid[] = "@(#)yaccpar 4.1 (Berkeley) 2/11/83";
730: #endif not lint
731:
732: #
733: # define YYFLAG -1000
734: # define YYERROR goto yyerrlab
735: # define YYACCEPT return(0)
736: # define YYABORT return(1)
737:
738: /* parser for yacc output */
739:
740: #ifdef YYDEBUG
741: int yydebug = 0; /* 1 for debugging */
742: #endif
743: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
744: int yychar = -1; /* current input token number */
745: int yynerrs = 0; /* number of errors */
746: short yyerrflag = 0; /* error recovery flag */
747:
748: yyparse() {
749:
750: short yys[YYMAXDEPTH];
751: short yyj, yym;
752: register YYSTYPE *yypvt;
753: register short yystate, *yyps, yyn;
754: register YYSTYPE *yypv;
755: register short *yyxi;
756:
757: yystate = 0;
758: yychar = -1;
759: yynerrs = 0;
760: yyerrflag = 0;
761: yyps= &yys[-1];
762: yypv= &yyv[-1];
763:
764: yystack: /* put a state and value onto the stack */
765:
766: #ifdef YYDEBUG
767: if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar );
768: #endif
769: if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
770: *yyps = yystate;
771: ++yypv;
772: *yypv = yyval;
773:
774: yynewstate:
775:
776: yyn = yypact[yystate];
777:
778: if( yyn<= YYFLAG ) goto yydefault; /* simple state */
779:
780: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
781: if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
782:
783: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
784: yychar = -1;
785: yyval = yylval;
786: yystate = yyn;
787: if( yyerrflag > 0 ) --yyerrflag;
788: goto yystack;
789: }
790:
791: yydefault:
792: /* default state action */
793:
794: if( (yyn=yydef[yystate]) == -2 ) {
795: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
796: /* look through exception table */
797:
798: for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
799:
800: while( *(yyxi+=2) >= 0 ){
801: if( *yyxi == yychar ) break;
802: }
803: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
804: }
805:
806: if( yyn == 0 ){ /* error */
807: /* error ... attempt to resume parsing */
808:
809: switch( yyerrflag ){
810:
811: case 0: /* brand new error */
812:
813: yyerror( "syntax error" );
814: yyerrlab:
815: ++yynerrs;
816:
817: case 1:
818: case 2: /* incompletely recovered error ... try again */
819:
820: yyerrflag = 3;
821:
822: /* find a state where "error" is a legal shift action */
823:
824: while ( yyps >= yys ) {
825: yyn = yypact[*yyps] + YYERRCODE;
826: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
827: yystate = yyact[yyn]; /* simulate a shift of "error" */
828: goto yystack;
829: }
830: yyn = yypact[*yyps];
831:
832: /* the current yyps has no shift onn "error", pop stack */
833:
834: #ifdef YYDEBUG
835: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
836: #endif
837: --yyps;
838: --yypv;
839: }
840:
841: /* there is no state on the stack with an error shift ... abort */
842:
843: yyabort:
844: return(1);
845:
846:
847: case 3: /* no shift yet; clobber input char */
848:
849: #ifdef YYDEBUG
850: if( yydebug ) printf( "error recovery discards char %d\n", yychar );
851: #endif
852:
853: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
854: yychar = -1;
855: goto yynewstate; /* try again in the same state */
856:
857: }
858:
859: }
860:
861: /* reduction by production yyn */
862:
863: #ifdef YYDEBUG
864: if( yydebug ) printf("reduce %d\n",yyn);
865: #endif
866: yyps -= yyr2[yyn];
867: yypvt = yypv;
868: yypv -= yyr2[yyn];
869: yyval = yypv[1];
870: yym=yyn;
871: /* consult goto table to find next state */
872: yyn = yyr1[yyn];
873: yyj = yypgo[yyn] + *yyps + 1;
874: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
875: switch(yym){
876:
877: case 1:
878: # line 20 "expr.y"
879: {
880: printf("%s\n", yypvt[-1]);
881: exit((!strcmp(yypvt[-1],"0")||!strcmp(yypvt[-1],"\0"))? 1: 0);
882: } break;
883: case 2:
884: # line 27 "expr.y"
885: { yyval = yypvt[-1]; } break;
886: case 3:
887: # line 28 "expr.y"
888: { yyval = conj(OR, yypvt[-2], yypvt[-0]); } break;
889: case 4:
890: # line 29 "expr.y"
891: { yyval = conj(AND, yypvt[-2], yypvt[-0]); } break;
892: case 5:
893: # line 30 "expr.y"
894: { yyval = rel(EQ, yypvt[-2], yypvt[-0]); } break;
895: case 6:
896: # line 31 "expr.y"
897: { yyval = rel(GT, yypvt[-2], yypvt[-0]); } break;
898: case 7:
899: # line 32 "expr.y"
900: { yyval = rel(GEQ, yypvt[-2], yypvt[-0]); } break;
901: case 8:
902: # line 33 "expr.y"
903: { yyval = rel(LT, yypvt[-2], yypvt[-0]); } break;
904: case 9:
905: # line 34 "expr.y"
906: { yyval = rel(LEQ, yypvt[-2], yypvt[-0]); } break;
907: case 10:
908: # line 35 "expr.y"
909: { yyval = rel(NEQ, yypvt[-2], yypvt[-0]); } break;
910: case 11:
911: # line 36 "expr.y"
912: { yyval = arith(ADD, yypvt[-2], yypvt[-0]); } break;
913: case 12:
914: # line 37 "expr.y"
915: { yyval = arith(SUBT, yypvt[-2], yypvt[-0]); } break;
916: case 13:
917: # line 38 "expr.y"
918: { yyval = arith(MULT, yypvt[-2], yypvt[-0]); } break;
919: case 14:
920: # line 39 "expr.y"
921: { yyval = arith(DIV, yypvt[-2], yypvt[-0]); } break;
922: case 15:
923: # line 40 "expr.y"
924: { yyval = arith(REM, yypvt[-2], yypvt[-0]); } break;
925: case 16:
926: # line 41 "expr.y"
927: { yyval = match(yypvt[-2], yypvt[-0]); } break;
928: case 17:
929: # line 42 "expr.y"
930: { yyval = match(yypvt[-1], yypvt[-0]); } break;
931: case 18:
932: # line 43 "expr.y"
933: { yyval = substr(yypvt[-2], yypvt[-1], yypvt[-0]); } break;
934: case 19:
935: # line 44 "expr.y"
936: { yyval = length(yypvt[-0]); } break;
937: case 20:
938: # line 45 "expr.y"
939: { yyval = index(yypvt[-1], yypvt[-0]); } break;
940: }
941: goto yystack; /* stack new state and value */
942:
943: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.