![[BACK]](/icons/back.gif){kind=icon}
Return to lexyy.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / awk|
Return to lexyy.c CVS log | Up to [local] / src / usr.bin / awk |
1.1 millert 1: typedef unsigned char Uchar;
2: # include <stdio.h>
3: # define U(x) x
4: # define NLSTATE yyprevious=YYNEWLINE
5: # define BEGIN yybgin = yysvec + 1 +
6: # define INITIAL 0
7: # define YYLERR yysvec
8: # define YYSTATE (yyestate-yysvec-1)
9: # define YYOPTIM 1
10: # define YYLMAX 200
11: # define output(c) putc(c,yyout)
12: # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
13: # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
14: # define yymore() (yymorfg=1)
15: # define ECHO fprintf(yyout, "%s",yytext)
16: # define REJECT { nstr = yyreject(); goto yyfussy;}
17: int yyleng; extern char yytext[];
18: int yymorfg;
19: extern Uchar *yysptr, yysbuf[];
20: int yytchar;
21: FILE *yyin = {stdin}, *yyout = {stdout};
22: extern int yylineno;
23: struct yysvf {
24: struct yywork *yystoff;
25: struct yysvf *yyother;
26: int *yystops;};
27: struct yysvf *yyestate;
28: extern struct yysvf yysvec[], *yybgin;
29: int yylook(void), yywrap(void), yyback(int *, int);
30: #define A 2
31: #define str 4
32: #define sc 6
33: #define reg 8
34: #define comment 10
35: /****************************************************************
36: Copyright (C) AT&T and Lucent Technologies 1996
37: All Rights Reserved
38:
39: Permission to use, copy, modify, and distribute this software and
40: its documentation for any purpose and without fee is hereby
41: granted, provided that the above copyright notice appear in all
42: copies and that both that the copyright notice and this
43: permission notice and warranty disclaimer appear in supporting
44: documentation, and that the names of AT&T or Lucent Technologies
45: or any of their entities not be used in advertising or publicity
46: pertaining to distribution of the software without specific,
47: written prior permission.
48:
49: AT&T AND LUCENT DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
50: SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
51: FITNESS. IN NO EVENT SHALL AT&T OR LUCENT OR ANY OF THEIR
52: ENTITIES BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
53: DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
54: DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
55: OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
56: USE OR PERFORMANCE OF THIS SOFTWARE.
57: ****************************************************************/
58:
59: /* some of this depends on behavior of lex that
60: may not be preserved in other implementations of lex.
61: */
62:
63: #undef input /* defeat lex */
64: #undef unput
65:
66: #include <stdlib.h>
67: #include <string.h>
68: #include "awk.h"
69: #include "awkgram.h"
70:
71: extern YYSTYPE yylval;
72: extern int infunc;
73:
74: int lineno = 1;
75: int bracecnt = 0;
76: int brackcnt = 0;
77: int parencnt = 0;
78:
79: #define DEBUG
80: #ifdef DEBUG
81: # define RET(x) {if(dbg)printf("lex %s [%s]\n", tokname(x), yytext); return(x); }
82: #else
83: # define RET(x) return(x)
84: #endif
85:
86: #define CADD if (cadd(gs, yytext[0]) == 0) { \
87: ERROR "string/reg expr %.30s... too long", gs->cbuf SYNTAX; \
88: BEGIN A; \
89: }
90:
91: char *s;
92: Gstring *gs = 0; /* initialized in main() */
93: int cflag;
94: #define YYNEWLINE 10
95: yylex(void){
96: int nstr; extern int yyprevious;
97: switch (yybgin-yysvec-1) { /* witchcraft */
98: case 0:
99: BEGIN A;
100: break;
101: case sc:
102: BEGIN A;
103: RET('}');
104: }
105: while((nstr = yylook()) >= 0)
106: yyfussy: switch(nstr){
107: case 0:
108: if(yywrap()) return(0); break;
109: case 1:
110: { lineno++; RET(NL); }
111: break;
112: case 2:
113: { ; }
114: break;
115: case 3:
116: { ; }
117: break;
118: case 4:
119: { RET(';'); }
120: break;
121: case 5:
122: { lineno++; }
123: break;
124: case 6:
125: { RET(XBEGIN); }
126: break;
127: case 7:
128: { RET(XEND); }
129: break;
130: case 8:
131: { if (infunc) ERROR "illegal nested function" SYNTAX; RET(FUNC); }
132: break;
133: case 9:
134: { if (!infunc) ERROR "return not in function" SYNTAX; RET(RETURN); }
135: break;
136: case 10:
137: { RET(AND); }
138: break;
139: case 11:
140: { RET(BOR); }
141: break;
142: case 12:
143: { RET(NOT); }
144: break;
145: case 13:
146: { yylval.i = NE; RET(NE); }
147: break;
148: case 14:
149: { yylval.i = MATCH; RET(MATCHOP); }
150: break;
151: case 15:
152: { yylval.i = NOTMATCH; RET(MATCHOP); }
153: break;
154: case 16:
155: { yylval.i = LT; RET(LT); }
156: break;
157: case 17:
158: { yylval.i = LE; RET(LE); }
159: break;
160: case 18:
161: { yylval.i = EQ; RET(EQ); }
162: break;
163: case 19:
164: { yylval.i = GE; RET(GE); }
165: break;
166: case 20:
167: { yylval.i = GT; RET(GT); }
168: break;
169: case 21:
170: { yylval.i = APPEND; RET(APPEND); }
171: break;
172: case 22:
173: { yylval.i = INCR; RET(INCR); }
174: break;
175: case 23:
176: { yylval.i = DECR; RET(DECR); }
177: break;
178: case 24:
179: { yylval.i = ADDEQ; RET(ASGNOP); }
180: break;
181: case 25:
182: { yylval.i = SUBEQ; RET(ASGNOP); }
183: break;
184: case 26:
185: { yylval.i = MULTEQ; RET(ASGNOP); }
186: break;
187: case 27:
188: { yylval.i = DIVEQ; RET(ASGNOP); }
189: break;
190: case 28:
191: { yylval.i = MODEQ; RET(ASGNOP); }
192: break;
193: case 29:
194: { yylval.i = POWEQ; RET(ASGNOP); }
195: break;
196: case 30:
197: { yylval.i = POWEQ; RET(ASGNOP); }
198: break;
199: case 31:
200: { yylval.i = ASSIGN; RET(ASGNOP); }
201: break;
202: case 32:
203: { RET(POWER); }
204: break;
205: case 33:
206: { RET(POWER); }
207: break;
208: case 34:
209: { yylval.cp = fieldadr(atoi(yytext+1)); RET(FIELD); }
210: break;
211: case 35:
212: { unputstr("(NF)"); return(INDIRECT); }
213: break;
214: case 36:
215: { int c, n;
216: c = input(); unput(c);
217: if (c == '(' || c == '[' || (infunc && (n=isarg(yytext+1)) >= 0)) {
218: unputstr(yytext+1);
219: return(INDIRECT);
220: } else {
221: yylval.cp = setsymtab(yytext+1, "", 0.0, STR|NUM, symtab);
222: RET(IVAR);
223: }
224: }
225: break;
226: case 37:
227: { RET(INDIRECT); }
228: break;
229: case 38:
230: { yylval.cp = setsymtab(yytext, "", 0.0, NUM, symtab); RET(VARNF); }
231: break;
232: case 39:
233: {
234: yylval.cp = setsymtab(yytext, tostring(yytext), atof(yytext), CON|NUM, symtab);
235: /* should this also have STR set? */
236: RET(NUMBER); }
237: break;
238: case 40:
239: { RET(WHILE); }
240: break;
241: case 41:
242: { RET(FOR); }
243: break;
244: case 42:
245: { RET(DO); }
246: break;
247: case 43:
248: { RET(IF); }
249: break;
250: case 44:
251: { RET(ELSE); }
252: break;
253: case 45:
254: { RET(NEXT); }
255: break;
256: case 46:
257: { RET(NEXTFILE); }
258: break;
259: case 47:
260: { RET(EXIT); }
261: break;
262: case 48:
263: { RET(BREAK); }
264: break;
265: case 49:
266: { RET(CONTINUE); }
267: break;
268: case 50:
269: { yylval.i = PRINT; RET(PRINT); }
270: break;
271: case 51:
272: { yylval.i = PRINTF; RET(PRINTF); }
273: break;
274: case 52:
275: { yylval.i = SPRINTF; RET(SPRINTF); }
276: break;
277: case 53:
278: { yylval.i = SPLIT; RET(SPLIT); }
279: break;
280: case 54:
281: { RET(SUBSTR); }
282: break;
283: case 55:
284: { yylval.i = SUB; RET(SUB); }
285: break;
286: case 56:
287: { yylval.i = GSUB; RET(GSUB); }
288: break;
289: case 57:
290: { RET(INDEX); }
291: break;
292: case 58:
293: { RET(MATCHFCN); }
294: break;
295: case 59:
296: { RET(IN); }
297: break;
298: case 60:
299: { RET(GETLINE); }
300: break;
301: case 61:
302: { RET(CLOSE); }
303: break;
304: case 62:
305: { RET(DELETE); }
306: break;
307: case 63:
308: { yylval.i = FLENGTH; RET(BLTIN); }
309: break;
310: case 64:
311: { yylval.i = FLOG; RET(BLTIN); }
312: break;
313: case 65:
314: { yylval.i = FINT; RET(BLTIN); }
315: break;
316: case 66:
317: { yylval.i = FEXP; RET(BLTIN); }
318: break;
319: case 67:
320: { yylval.i = FSQRT; RET(BLTIN); }
321: break;
322: case 68:
323: { yylval.i = FSIN; RET(BLTIN); }
324: break;
325: case 69:
326: { yylval.i = FCOS; RET(BLTIN); }
327: break;
328: case 70:
329: { yylval.i = FATAN; RET(BLTIN); }
330: break;
331: case 71:
332: { yylval.i = FSYSTEM; RET(BLTIN); }
333: break;
334: case 72:
335: { yylval.i = FRAND; RET(BLTIN); }
336: break;
337: case 73:
338: { yylval.i = FSRAND; RET(BLTIN); }
339: break;
340: case 74:
341: { yylval.i = FTOUPPER; RET(BLTIN); }
342: break;
343: case 75:
344: { yylval.i = FTOLOWER; RET(BLTIN); }
345: break;
346: case 76:
347: { yylval.i = FFLUSH; RET(BLTIN); }
348: break;
349: case 77:
350: { int n, c;
351: c = input(); unput(c); /* look for '(' */
352: if (c != '(' && infunc && (n=isarg(yytext)) >= 0) {
353: yylval.i = n;
354: RET(ARG);
355: } else {
356: yylval.cp = setsymtab(yytext, "", 0.0, STR|NUM, symtab);
357: if (c == '(') {
358: RET(CALL);
359: } else {
360: RET(VAR);
361: }
362: }
363: }
364: break;
365: case 78:
366: { BEGIN str; caddreset(gs); }
367: break;
368: case 79:
369: { if (--bracecnt < 0) ERROR "extra }" SYNTAX; BEGIN sc; RET(';'); }
370: break;
371: case 80:
372: { if (--brackcnt < 0) ERROR "extra ]" SYNTAX; RET(']'); }
373: break;
374: case 81:
375: { if (--parencnt < 0) ERROR "extra )" SYNTAX; RET(')'); }
376: break;
377: case 82:
378: { if (yytext[0] == '{') bracecnt++;
379: else if (yytext[0] == '[') brackcnt++;
380: else if (yytext[0] == '(') parencnt++;
381: RET(yylval.i = yytext[0]); /* everything else */ }
382: break;
383: case 83:
384: { cadd(gs, '\\'); cadd(gs, yytext[1]); }
385: break;
386: case 84:
387: { ERROR "newline in regular expression %.10s...", gs->cbuf SYNTAX; lineno++; BEGIN A; }
388: break;
389: case 85:
390: { BEGIN A;
391: cadd(gs, 0);
392: yylval.s = tostring(gs->cbuf);
393: unput('/');
394: RET(REGEXPR); }
395: break;
396: case 86:
397: { CADD; }
398: break;
399: case 87:
400: { BEGIN A;
401: cadd(gs, 0); s = tostring(gs->cbuf);
402: cunadd(gs);
403: cadd(gs, ' '); cadd(gs, 0);
404: yylval.cp = setsymtab(gs->cbuf, s, 0.0, CON|STR, symtab);
405: RET(STRING); }
406: break;
407: case 88:
408: { ERROR "newline in string %.10s...", gs->cbuf SYNTAX; lineno++; BEGIN A; }
409: break;
410: case 89:
411: { cadd(gs, '"'); }
412: break;
413: case 90:
414: { cadd(gs, '\n'); }
415: break;
416: case 91:
417: { cadd(gs, '\t'); }
418: break;
419: case 92:
420: { cadd(gs, '\f'); }
421: break;
422: case 93:
423: { cadd(gs, '\r'); }
424: break;
425: case 94:
426: { cadd(gs, '\b'); }
427: break;
428: case 95:
429: { cadd(gs, '\v'); }
430: break;
431: case 96:
432: { cadd(gs, '\007'); }
433: break;
434: case 97:
435: { cadd(gs, '\\'); }
436: break;
437: case 98:
438: { int n;
439: sscanf(yytext+1, "%o", &n); cadd(gs, n); }
440: break;
441: case 99:
442: { int n; /* ANSI permits any number! */
443: sscanf(yytext+2, "%x", &n); cadd(gs, n); }
444: break;
445: case 100:
446: { cadd(gs, yytext[1]); }
447: break;
448: case 101:
449: { CADD; }
450: break;
451: case -1:
452: break;
453: default:
454: fprintf(yyout,"bad switch yylook %d",nstr);
455: } return(0); }
456: /* end of yylex */
457:
458: void startreg(void) /* start parsing a regular expression */
459: {
460: BEGIN reg;
461: caddreset(gs);
462: }
463:
464: /* input() and unput() are transcriptions of the standard lex
465: macros for input and output with additions for error message
466: printing. God help us all if someone changes how lex works.
467: */
468:
469: char ebuf[300];
470: char *ep = ebuf;
471:
472: int input(void) /* get next lexical input character */
473: {
474: int c;
475: extern char *lexprog;
476:
477: if (yysptr > yysbuf)
478: c = U(*--yysptr);
479: else if (lexprog != NULL) { /* awk '...' */
480: if ((c = *lexprog) != 0)
481: lexprog++;
482: } else /* awk -f ... */
483: c = pgetc();
484: if (c == '\n')
485: yylineno++;
486: else if (c == EOF)
487: c = 0;
488: if (ep >= ebuf + sizeof ebuf)
489: ep = ebuf;
490: return *ep++ = c;
491: }
492:
493: void unput(int c) /* put lexical character back on input */
494: {
495: yytchar = c;
496: if (yytchar == '\n')
497: yylineno--;
498: *yysptr++ = yytchar;
499: if (--ep < ebuf)
500: ep = ebuf + sizeof(ebuf) - 1;
501: }
502:
503:
504: void unputstr(char *s) /* put a string back on input */
505: {
506: int i;
507:
508: for (i = strlen(s)-1; i >= 0; i--)
509: unput(s[i]);
510: }
511:
512: /* growing-string code */
513:
514: const int CBUFLEN = 400;
515:
516: Gstring *newGstring()
517: {
518: Gstring *gs = (Gstring *) malloc(sizeof(Gstring));
519: char *cp = (char *) malloc(CBUFLEN);
520:
521: if (gs == 0 || cp == 0)
522: ERROR "Out of space for strings" FATAL;
523: gs->cbuf = cp;
524: gs->cmax = CBUFLEN;
525: gs->clen = 0;
526: return gs;
527: }
528:
529: char *cadd(Gstring *gs, int c) /* add one char to gs->cbuf, grow as needed */
530: {
531: if (gs->clen >= gs->cmax) { /* need to grow */
532: gs->cmax *= 4;
533: gs->cbuf = (char *) realloc((void *) gs->cbuf, gs->cmax);
534:
535: }
536: if (gs->cbuf != 0)
537: gs->cbuf[gs->clen++] = c;
538: return gs->cbuf;
539: }
540:
541: void caddreset(Gstring *gs)
542: {
543: gs->clen = 0;
544: }
545:
546: void cunadd(Gstring *gs)
547: {
548: if (gs->clen > 0)
549: gs->clen--;
550: }
551:
552: void delGstring(Gstring *gs)
553: {
554: free((void *) gs->cbuf);
555: free((void *) gs);
556: }
557: int yyvstop[] = {
558: 0,
559:
560: 82,
561: 0,
562:
563: 3,
564: 82,
565: 0,
566:
567: 1,
568: 0,
569:
570: 12,
571: 82,
572: 0,
573:
574: 78,
575: 82,
576: 0,
577:
578: 2,
579: 82,
580: 0,
581:
582: 37,
583: 82,
584: 0,
585:
586: 82,
587: 0,
588:
589: 82,
590: 0,
591:
592: 81,
593: 82,
594: 0,
595:
596: 82,
597: 0,
598:
599: 82,
600: 0,
601:
602: 82,
603: 0,
604:
605: 82,
606: 0,
607:
608: 82,
609: 0,
610:
611: 39,
612: 82,
613: 0,
614:
615: 4,
616: 82,
617: 0,
618:
619: 16,
620: 82,
621: 0,
622:
623: 31,
624: 82,
625: 0,
626:
627: 20,
628: 82,
629: 0,
630:
631: 77,
632: 82,
633: 0,
634:
635: 77,
636: 82,
637: 0,
638:
639: 77,
640: 82,
641: 0,
642:
643: 77,
644: 82,
645: 0,
646:
647: 82,
648: 0,
649:
650: 80,
651: 82,
652: 0,
653:
654: 33,
655: 82,
656: 0,
657:
658: 77,
659: 82,
660: 0,
661:
662: 77,
663: 82,
664: 0,
665:
666: 77,
667: 82,
668: 0,
669:
670: 77,
671: 82,
672: 0,
673:
674: 77,
675: 82,
676: 0,
677:
678: 77,
679: 82,
680: 0,
681:
682: 77,
683: 82,
684: 0,
685:
686: 77,
687: 82,
688: 0,
689:
690: 77,
691: 82,
692: 0,
693:
694: 77,
695: 82,
696: 0,
697:
698: 77,
699: 82,
700: 0,
701:
702: 77,
703: 82,
704: 0,
705:
706: 77,
707: 82,
708: 0,
709:
710: 77,
711: 82,
712: 0,
713:
714: 77,
715: 82,
716: 0,
717:
718: 77,
719: 82,
720: 0,
721:
722: 82,
723: 0,
724:
725: 79,
726: 82,
727: 0,
728:
729: 14,
730: 82,
731: 0,
732:
733: 101,
734: 0,
735:
736: 88,
737: 0,
738:
739: 87,
740: 101,
741: 0,
742:
743: 101,
744: 0,
745:
746: 86,
747: 0,
748:
749: 84,
750: 0,
751:
752: 85,
753: 86,
754: 0,
755:
756: 86,
757: 0,
758:
759: 3,
760: 0,
761:
762: 13,
763: 0,
764:
765: 15,
766: 0,
767:
768: 2,
769: 0,
770:
771: 34,
772: 0,
773:
774: 36,
775: 0,
776:
777: 36,
778: 0,
779:
780: 28,
781: 0,
782:
783: 10,
784: 0,
785:
786: 32,
787: 0,
788:
789: 26,
790: 0,
791:
792: 22,
793: 0,
794:
795: 24,
796: 0,
797:
798: 23,
799: 0,
800:
801: 25,
802: 0,
803:
804: 39,
805: 0,
806:
807: 27,
808: 0,
809:
810: 39,
811: 0,
812:
813: 39,
814: 0,
815:
816: 17,
817: 0,
818:
819: 18,
820: 0,
821:
822: 19,
823: 0,
824:
825: 21,
826: 0,
827:
828: 77,
829: 0,
830:
831: 77,
832: 0,
833:
834: 77,
835: 0,
836:
837: 38,
838: 77,
839: 0,
840:
841: 5,
842: 0,
843:
844: 29,
845: 0,
846:
847: 77,
848: 0,
849:
850: 77,
851: 0,
852:
853: 77,
854: 0,
855:
856: 77,
857: 0,
858:
859: 77,
860: 0,
861:
862: 42,
863: 77,
864: 0,
865:
866: 77,
867: 0,
868:
869: 77,
870: 0,
871:
872: 77,
873: 0,
874:
875: 77,
876: 0,
877:
878: 77,
879: 0,
880:
881: 77,
882: 0,
883:
884: 77,
885: 0,
886:
887: 43,
888: 77,
889: 0,
890:
891: 59,
892: 77,
893: 0,
894:
895: 77,
896: 0,
897:
898: 77,
899: 0,
900:
901: 77,
902: 0,
903:
904: 77,
905: 0,
906:
907: 77,
908: 0,
909:
910: 77,
911: 0,
912:
913: 77,
914: 0,
915:
916: 77,
917: 0,
918:
919: 77,
920: 0,
921:
922: 77,
923: 0,
924:
925: 77,
926: 0,
927:
928: 77,
929: 0,
930:
931: 77,
932: 0,
933:
934: 77,
935: 0,
936:
937: 77,
938: 0,
939:
940: 11,
941: 0,
942:
943: 100,
944: 0,
945:
946: 89,
947: 100,
948: 0,
949:
950: 98,
951: 100,
952: 0,
953:
954: 97,
955: 100,
956: 0,
957:
958: 96,
959: 100,
960: 0,
961:
962: 94,
963: 100,
964: 0,
965:
966: 92,
967: 100,
968: 0,
969:
970: 90,
971: 100,
972: 0,
973:
974: 93,
975: 100,
976: 0,
977:
978: 91,
979: 100,
980: 0,
981:
982: 95,
983: 100,
984: 0,
985:
986: 100,
987: 0,
988:
989: 83,
990: 0,
991:
992: 35,
993: 36,
994: 0,
995:
996: 30,
997: 0,
998:
999: 39,
1000: 0,
1001:
1002: 77,
1003: 0,
1004:
1005: 7,
1006: 77,
1007: 0,
1008:
1009: 77,
1010: 0,
1011:
1012: 77,
1013: 0,
1014:
1015: 77,
1016: 0,
1017:
1018: 77,
1019: 0,
1020:
1021: 69,
1022: 77,
1023: 0,
1024:
1025: 77,
1026: 0,
1027:
1028: 77,
1029: 0,
1030:
1031: 77,
1032: 0,
1033:
1034: 66,
1035: 77,
1036: 0,
1037:
1038: 77,
1039: 0,
1040:
1041: 41,
1042: 77,
1043: 0,
1044:
1045: 77,
1046: 0,
1047:
1048: 77,
1049: 0,
1050:
1051: 77,
1052: 0,
1053:
1054: 77,
1055: 0,
1056:
1057: 65,
1058: 77,
1059: 0,
1060:
1061: 77,
1062: 0,
1063:
1064: 64,
1065: 77,
1066: 0,
1067:
1068: 77,
1069: 0,
1070:
1071: 77,
1072: 0,
1073:
1074: 77,
1075: 0,
1076:
1077: 77,
1078: 0,
1079:
1080: 77,
1081: 0,
1082:
1083: 68,
1084: 77,
1085: 0,
1086:
1087: 77,
1088: 0,
1089:
1090: 77,
1091: 0,
1092:
1093: 77,
1094: 0,
1095:
1096: 77,
1097: 0,
1098:
1099: 55,
1100: 77,
1101: 0,
1102:
1103: 77,
1104: 0,
1105:
1106: 77,
1107: 0,
1108:
1109: 77,
1110: 0,
1111:
1112: 77,
1113: 0,
1114:
1115: 98,
1116: 0,
1117:
1118: 99,
1119: 0,
1120:
1121: 77,
1122: 0,
1123:
1124: 77,
1125: 0,
1126:
1127: 77,
1128: 0,
1129:
1130: 77,
1131: 0,
1132:
1133: 77,
1134: 0,
1135:
1136: 77,
1137: 0,
1138:
1139: 44,
1140: 77,
1141: 0,
1142:
1143: 47,
1144: 77,
1145: 0,
1146:
1147: 77,
1148: 0,
1149:
1150: 8,
1151: 77,
1152: 0,
1153:
1154: 77,
1155: 0,
1156:
1157: 56,
1158: 77,
1159: 0,
1160:
1161: 77,
1162: 0,
1163:
1164: 77,
1165: 0,
1166:
1167: 77,
1168: 0,
1169:
1170: 45,
1171: 77,
1172: 0,
1173:
1174: 77,
1175: 0,
1176:
1177: 72,
1178: 77,
1179: 0,
1180:
1181: 77,
1182: 0,
1183:
1184: 77,
1185: 0,
1186:
1187: 77,
1188: 0,
1189:
1190: 67,
1191: 77,
1192: 0,
1193:
1194: 77,
1195: 0,
1196:
1197: 77,
1198: 0,
1199:
1200: 77,
1201: 0,
1202:
1203: 77,
1204: 0,
1205:
1206: 77,
1207: 0,
1208:
1209: 77,
1210: 0,
1211:
1212: 98,
1213: 0,
1214:
1215: 6,
1216: 77,
1217: 0,
1218:
1219: 70,
1220: 77,
1221: 0,
1222:
1223: 48,
1224: 77,
1225: 0,
1226:
1227: 61,
1228: 77,
1229: 0,
1230:
1231: 77,
1232: 0,
1233:
1234: 77,
1235: 0,
1236:
1237: 77,
1238: 0,
1239:
1240: 77,
1241: 0,
1242:
1243: 77,
1244: 0,
1245:
1246: 57,
1247: 77,
1248: 0,
1249:
1250: 77,
1251: 0,
1252:
1253: 58,
1254: 77,
1255: 0,
1256:
1257: 77,
1258: 0,
1259:
1260: 50,
1261: 77,
1262: 0,
1263:
1264: 77,
1265: 0,
1266:
1267: 53,
1268: 77,
1269: 0,
1270:
1271: 77,
1272: 0,
1273:
1274: 73,
1275: 77,
1276: 0,
1277:
1278: 77,
1279: 0,
1280:
1281: 77,
1282: 0,
1283:
1284: 77,
1285: 0,
1286:
1287: 77,
1288: 0,
1289:
1290: 40,
1291: 77,
1292: 0,
1293:
1294: 77,
1295: 0,
1296:
1297: 62,
1298: 77,
1299: 0,
1300:
1301: 76,
1302: 77,
1303: 0,
1304:
1305: 77,
1306: 0,
1307:
1308: 77,
1309: 0,
1310:
1311: 63,
1312: 77,
1313: 0,
1314:
1315: 77,
1316: 0,
1317:
1318: 51,
1319: 77,
1320: 0,
1321:
1322: 9,
1323: 77,
1324: 0,
1325:
1326: 77,
1327: 0,
1328:
1329: 54,
1330: 77,
1331: 0,
1332:
1333: 71,
1334: 77,
1335: 0,
1336:
1337: 77,
1338: 0,
1339:
1340: 77,
1341: 0,
1342:
1343: 77,
1344: 0,
1345:
1346: 77,
1347: 0,
1348:
1349: 60,
1350: 77,
1351: 0,
1352:
1353: 77,
1354: 0,
1355:
1356: 52,
1357: 77,
1358: 0,
1359:
1360: 75,
1361: 77,
1362: 0,
1363:
1364: 74,
1365: 77,
1366: 0,
1367:
1368: 49,
1369: 77,
1370: 0,
1371:
1372: 8,
1373: 77,
1374: 0,
1375:
1376: 46,
1377: 77,
1378: 0,
1379: 0};
1380: # define YYTYPE int
1381: struct yywork { YYTYPE verify, advance; } yycrank[] = {
1382: 0,0, 0,0, 3,13, 0,0,
1383: 0,0, 0,0, 0,0, 0,0,
1384: 0,0, 0,0, 3,14, 3,15,
1385: 0,0, 0,0, 0,0, 0,0,
1386: 0,0, 14,67, 0,0, 0,0,
1387: 0,0, 5,59, 0,0, 0,0,
1388: 0,0, 0,0, 0,0, 0,0,
1389: 0,0, 5,59, 5,60, 0,0,
1390: 0,0, 0,0, 3,16, 3,17,
1391: 3,18, 3,19, 3,20, 3,21,
1392: 14,67, 37,95, 3,22, 3,23,
1393: 3,24, 70,0, 3,25, 3,26,
1394: 3,27, 3,28, 6,61, 0,0,
1395: 0,0, 0,0, 5,61, 0,0,
1396: 0,0, 3,28, 0,0, 0,0,
1397: 3,29, 3,30, 3,31, 3,32,
1398: 0,0, 21,75, 3,33, 3,34,
1399: 5,59, 10,65, 3,35, 23,76,
1400: 3,33, 0,0, 16,68, 0,0,
1401: 5,59, 0,0, 0,0, 3,36,
1402: 0,0, 0,0, 0,0, 0,0,
1403: 0,0, 5,59, 0,0, 24,78,
1404: 9,63, 20,74, 23,77, 5,59,
1405: 27,83, 3,37, 3,38, 3,39,
1406: 9,63, 9,64, 3,40, 3,41,
1407: 3,42, 3,43, 3,44, 3,45,
1408: 3,46, 24,79, 3,47, 25,80,
1409: 6,62, 3,48, 3,49, 3,50,
1410: 5,62, 3,51, 10,66, 3,52,
1411: 3,53, 3,54, 30,87, 31,88,
1412: 3,55, 32,89, 32,90, 25,81,
1413: 34,92, 3,56, 3,57, 3,58,
1414: 4,16, 4,17, 4,18, 4,19,
1415: 4,20, 4,21, 9,65, 9,63,
1416: 4,22, 4,23, 4,24, 16,69,
1417: 4,25, 4,26, 4,27, 9,63,
1418: 35,93, 36,94, 39,96, 40,97,
1419: 41,98, 43,101, 42,99, 44,103,
1420: 9,63, 42,100, 4,29, 4,30,
1421: 4,31, 4,32, 9,63, 43,102,
1422: 45,105, 4,34, 47,110, 44,104,
1423: 4,35, 49,114, 46,108, 50,115,
1424: 18,70, 45,106, 47,111, 48,112,
1425: 51,116, 4,36, 52,117, 45,107,
1426: 18,70, 18,0, 52,118, 9,66,
1427: 46,109, 48,113, 54,125, 55,126,
1428: 56,127, 76,142, 82,86, 4,37,
1429: 4,38, 4,39, 92,145, 93,146,
1430: 4,40, 4,41, 4,42, 4,43,
1431: 4,44, 4,45, 4,46, 97,147,
1432: 4,47, 98,148, 99,149, 4,48,
1433: 4,49, 4,50, 101,152, 4,51,
1434: 100,150, 4,52, 4,53, 4,54,
1435: 103,153, 100,151, 4,55, 18,70,
1436: 105,156, 53,119, 82,86, 4,56,
1437: 4,57, 4,58, 106,157, 18,70,
1438: 53,120, 53,121, 53,122, 104,154,
1439: 107,158, 53,123, 108,159, 109,160,
1440: 18,70, 53,124, 104,155, 111,161,
1441: 112,163, 113,164, 18,70, 19,71,
1442: 19,71, 19,71, 19,71, 19,71,
1443: 19,71, 19,71, 19,71, 19,71,
1444: 19,71, 114,165, 115,166, 111,162,
1445: 116,167, 117,168, 118,169, 119,170,
1446: 19,72, 19,72, 19,72, 19,72,
1447: 19,72, 19,72, 19,72, 19,72,
1448: 19,72, 19,72, 19,72, 19,72,
1449: 19,72, 19,73, 19,72, 19,72,
1450: 19,72, 19,72, 19,72, 19,72,
1451: 19,72, 19,72, 19,72, 19,72,
1452: 19,72, 19,72, 121,173, 122,174,
1453: 123,175, 124,176, 19,72, 126,179,
1454: 19,72, 19,72, 19,72, 19,72,
1455: 19,72, 19,72, 19,72, 19,72,
1456: 19,72, 19,72, 19,72, 19,72,
1457: 19,72, 19,72, 19,72, 19,72,
1458: 19,72, 19,72, 19,72, 19,72,
1459: 19,72, 19,72, 19,72, 19,72,
1460: 19,72, 19,72, 26,82, 26,82,
1461: 26,82, 26,82, 26,82, 26,82,
1462: 26,82, 26,82, 26,82, 26,82,
1463: 28,84, 145,182, 28,85, 28,85,
1464: 28,85, 28,85, 28,85, 28,85,
1465: 28,85, 28,85, 28,85, 28,85,
1466: 33,91, 33,91, 33,91, 33,91,
1467: 33,91, 33,91, 33,91, 33,91,
1468: 33,91, 33,91, 120,171, 28,86,
1469: 147,183, 148,184, 149,185, 150,186,
1470: 120,172, 33,91, 33,91, 33,91,
1471: 33,91, 33,91, 33,91, 33,91,
1472: 33,91, 33,91, 33,91, 33,91,
1473: 33,91, 33,91, 33,91, 33,91,
1474: 33,91, 33,91, 33,91, 33,91,
1475: 33,91, 33,91, 33,91, 33,91,
1476: 33,91, 33,91, 33,91, 28,86,
1477: 152,187, 153,188, 154,189, 33,91,
1478: 156,190, 33,91, 33,91, 33,91,
1479: 33,91, 33,91, 33,91, 33,91,
1480: 33,91, 33,91, 33,91, 33,91,
1481: 33,91, 33,91, 33,91, 33,91,
1482: 33,91, 33,91, 33,91, 33,91,
1483: 33,91, 33,91, 33,91, 33,91,
1484: 33,91, 33,91, 33,91, 62,128,
1485: 158,191, 66,140, 159,192, 160,193,
1486: 161,194, 163,195, 165,196, 62,128,
1487: 62,0, 66,140, 66,0, 71,71,
1488: 71,71, 71,71, 71,71, 71,71,
1489: 71,71, 71,71, 71,71, 71,71,
1490: 71,71, 72,72, 72,72, 72,72,
1491: 72,72, 72,72, 72,72, 72,72,
1492: 72,72, 72,72, 72,72, 166,197,
1493: 62,129, 167,198, 168,199, 169,200,
1494: 73,72, 73,72, 73,72, 73,72,
1495: 73,72, 73,72, 73,72, 73,72,
1496: 73,72, 73,72, 62,130, 171,201,
1497: 66,140, 172,202, 125,177, 72,72,
1498: 173,203, 174,204, 62,128, 175,205,
1499: 66,140, 176,206, 73,141, 125,178,
1500: 177,207, 178,208, 179,209, 62,128,
1501: 182,211, 66,140, 73,72, 183,212,
1502: 184,213, 62,128, 185,214, 66,140,
1503: 84,84, 84,84, 84,84, 84,84,
1504: 84,84, 84,84, 84,84, 84,84,
1505: 84,84, 84,84, 130,180, 130,180,
1506: 130,180, 130,180, 130,180, 130,180,
1507: 130,180, 130,180, 62,131, 186,215,
1508: 187,216, 84,86, 190,217, 62,132,
1509: 62,133, 191,218, 192,219, 194,220,
1510: 62,134, 195,221, 196,222, 197,223,
1511: 198,224, 200,225, 201,226, 202,227,
1512: 62,135, 204,228, 205,229, 206,230,
1513: 62,136, 207,231, 62,137, 208,232,
1514: 62,138, 209,233, 62,139, 215,234,
1515: 216,235, 86,143, 217,236, 86,143,
1516: 218,237, 84,86, 86,144, 86,144,
1517: 86,144, 86,144, 86,144, 86,144,
1518: 86,144, 86,144, 86,144, 86,144,
1519: 139,181, 139,181, 139,181, 139,181,
1520: 139,181, 139,181, 139,181, 139,181,
1521: 139,181, 139,181, 219,238, 221,239,
1522: 223,240, 224,241, 225,242, 227,243,
1523: 229,244, 139,181, 139,181, 139,181,
1524: 139,181, 139,181, 139,181, 230,245,
1525: 231,246, 141,72, 141,72, 141,72,
1526: 141,72, 141,72, 141,72, 141,72,
1527: 141,72, 141,72, 141,72, 143,144,
1528: 143,144, 143,144, 143,144, 143,144,
1529: 143,144, 143,144, 143,144, 143,144,
1530: 143,144, 232,247, 234,248, 237,249,
1531: 238,250, 139,181, 139,181, 139,181,
1532: 139,181, 139,181, 139,181, 141,72,
1533: 180,210, 180,210, 180,210, 180,210,
1534: 180,210, 180,210, 180,210, 180,210,
1535: 240,251, 243,252, 246,253, 247,254,
1536: 248,255, 249,256, 251,257, 0,0,
1537: 0,0};
1538: struct yysvf yysvec[] = {
1539: 0, 0, 0,
1540: yycrank+0, 0, 0,
1541: yycrank+0, 0, 0,
1542: yycrank+-1, 0, 0,
1543: yycrank+-95, yysvec+3, 0,
1544: yycrank+-20, 0, 0,
1545: yycrank+-16, yysvec+5, 0,
1546: yycrank+0, 0, 0,
1547: yycrank+0, 0, 0,
1548: yycrank+-87, 0, 0,
1549: yycrank+-22, yysvec+9, 0,
1550: yycrank+0, 0, 0,
1551: yycrank+0, 0, 0,
1552: yycrank+0, 0, yyvstop+1,
1553: yycrank+8, 0, yyvstop+3,
1554: yycrank+0, 0, yyvstop+6,
1555: yycrank+13, 0, yyvstop+8,
1556: yycrank+0, 0, yyvstop+11,
1557: yycrank+-167, 0, yyvstop+14,
1558: yycrank+191, 0, yyvstop+17,
1559: yycrank+28, 0, yyvstop+20,
1560: yycrank+27, 0, yyvstop+22,
1561: yycrank+0, 0, yyvstop+24,
1562: yycrank+29, 0, yyvstop+27,
1563: yycrank+44, 0, yyvstop+29,
1564: yycrank+62, 0, yyvstop+31,
1565: yycrank+266, 0, yyvstop+33,
1566: yycrank+31, 0, yyvstop+35,
1567: yycrank+278, 0, yyvstop+37,
1568: yycrank+0, 0, yyvstop+40,
1569: yycrank+57, 0, yyvstop+43,
1570: yycrank+58, 0, yyvstop+46,
1571: yycrank+60, 0, yyvstop+49,
1572: yycrank+288, 0, yyvstop+52,
1573: yycrank+55, yysvec+33, yyvstop+55,
1574: yycrank+66, yysvec+33, yyvstop+58,
1575: yycrank+75, yysvec+33, yyvstop+61,
1576: yycrank+31, 0, yyvstop+64,
1577: yycrank+0, 0, yyvstop+66,
1578: yycrank+85, 0, yyvstop+69,
1579: yycrank+31, yysvec+33, yyvstop+72,
1580: yycrank+34, yysvec+33, yyvstop+75,
1581: yycrank+42, yysvec+33, yyvstop+78,
1582: yycrank+48, yysvec+33, yyvstop+81,
1583: yycrank+43, yysvec+33, yyvstop+84,
1584: yycrank+58, yysvec+33, yyvstop+87,
1585: yycrank+65, yysvec+33, yyvstop+90,
1586: yycrank+60, yysvec+33, yyvstop+93,
1587: yycrank+70, yysvec+33, yyvstop+96,
1588: yycrank+68, yysvec+33, yyvstop+99,
1589: yycrank+66, yysvec+33, yyvstop+102,
1590: yycrank+58, yysvec+33, yyvstop+105,
1591: yycrank+77, yysvec+33, yyvstop+108,
1592: yycrank+112, yysvec+33, yyvstop+111,
1593: yycrank+71, yysvec+33, yyvstop+114,
1594: yycrank+79, yysvec+33, yyvstop+117,
1595: yycrank+60, 0, yyvstop+120,
1596: yycrank+0, 0, yyvstop+122,
1597: yycrank+0, 0, yyvstop+125,
1598: yycrank+0, 0, yyvstop+128,
1599: yycrank+0, 0, yyvstop+130,
1600: yycrank+0, 0, yyvstop+132,
1601: yycrank+-410, 0, yyvstop+135,
1602: yycrank+0, 0, yyvstop+137,
1603: yycrank+0, 0, yyvstop+139,
1604: yycrank+0, 0, yyvstop+141,
1605: yycrank+-412, 0, yyvstop+144,
1606: yycrank+0, yysvec+14, yyvstop+146,
1607: yycrank+0, 0, yyvstop+148,
1608: yycrank+0, 0, yyvstop+150,
1609: yycrank+-35, yysvec+18, yyvstop+152,
1610: yycrank+375, 0, yyvstop+154,
1611: yycrank+385, yysvec+19, yyvstop+156,
1612: yycrank+400, yysvec+19, yyvstop+158,
1613: yycrank+0, 0, yyvstop+160,
1614: yycrank+0, 0, yyvstop+162,
1615: yycrank+124, 0, yyvstop+164,
1616: yycrank+0, 0, yyvstop+166,
1617: yycrank+0, 0, yyvstop+168,
1618: yycrank+0, 0, yyvstop+170,
1619: yycrank+0, 0, yyvstop+172,
1620: yycrank+0, 0, yyvstop+174,
1621: yycrank+117, yysvec+26, yyvstop+176,
1622: yycrank+0, 0, yyvstop+178,
1623: yycrank+436, 0, yyvstop+180,
1624: yycrank+0, yysvec+28, yyvstop+182,
1625: yycrank+490, 0, 0,
1626: yycrank+0, 0, yyvstop+184,
1627: yycrank+0, 0, yyvstop+186,
1628: yycrank+0, 0, yyvstop+188,
1629: yycrank+0, 0, yyvstop+190,
1630: yycrank+0, yysvec+33, yyvstop+192,
1631: yycrank+119, yysvec+33, yyvstop+194,
1632: yycrank+123, yysvec+33, yyvstop+196,
1633: yycrank+0, yysvec+33, yyvstop+198,
1634: yycrank+0, 0, yyvstop+201,
1635: yycrank+0, 0, yyvstop+203,
1636: yycrank+102, yysvec+33, yyvstop+205,
1637: yycrank+100, yysvec+33, yyvstop+207,
1638: yycrank+91, yysvec+33, yyvstop+209,
1639: yycrank+98, yysvec+33, yyvstop+211,
1640: yycrank+98, yysvec+33, yyvstop+213,
1641: yycrank+0, yysvec+33, yyvstop+215,
1642: yycrank+97, yysvec+33, yyvstop+218,
1643: yycrank+122, yysvec+33, yyvstop+220,
1644: yycrank+108, yysvec+33, yyvstop+222,
1645: yycrank+108, yysvec+33, yyvstop+224,
1646: yycrank+118, yysvec+33, yyvstop+226,
1647: yycrank+114, yysvec+33, yyvstop+228,
1648: yycrank+114, yysvec+33, yyvstop+230,
1649: yycrank+0, yysvec+33, yyvstop+232,
1650: yycrank+135, yysvec+33, yyvstop+235,
1651: yycrank+126, yysvec+33, yyvstop+238,
1652: yycrank+134, yysvec+33, yyvstop+240,
1653: yycrank+133, yysvec+33, yyvstop+242,
1654: yycrank+130, yysvec+33, yyvstop+244,
1655: yycrank+147, yysvec+33, yyvstop+246,
1656: yycrank+143, yysvec+33, yyvstop+248,
1657: yycrank+138, yysvec+33, yyvstop+250,
1658: yycrank+145, yysvec+33, yyvstop+252,
1659: yycrank+238, yysvec+33, yyvstop+254,
1660: yycrank+168, yysvec+33, yyvstop+256,
1661: yycrank+186, yysvec+33, yyvstop+258,
1662: yycrank+186, yysvec+33, yyvstop+260,
1663: yycrank+170, yysvec+33, yyvstop+262,
1664: yycrank+354, yysvec+33, yyvstop+264,
1665: yycrank+182, yysvec+33, yyvstop+266,
1666: yycrank+0, 0, yyvstop+268,
1667: yycrank+0, 0, yyvstop+270,
1668: yycrank+0, 0, yyvstop+272,
1669: yycrank+446, 0, yyvstop+275,
1670: yycrank+0, 0, yyvstop+278,
1671: yycrank+0, 0, yyvstop+281,
1672: yycrank+0, 0, yyvstop+284,
1673: yycrank+0, 0, yyvstop+287,
1674: yycrank+0, 0, yyvstop+290,
1675: yycrank+0, 0, yyvstop+293,
1676: yycrank+0, 0, yyvstop+296,
1677: yycrank+0, 0, yyvstop+299,
1678: yycrank+500, 0, yyvstop+302,
1679: yycrank+0, 0, yyvstop+304,
1680: yycrank+525, yysvec+19, yyvstop+306,
1681: yycrank+0, 0, yyvstop+309,
1682: yycrank+535, 0, 0,
1683: yycrank+0, yysvec+143, yyvstop+311,
1684: yycrank+252, yysvec+33, yyvstop+313,
1685: yycrank+0, yysvec+33, yyvstop+315,
1686: yycrank+238, yysvec+33, yyvstop+318,
1687: yycrank+252, yysvec+33, yyvstop+320,
1688: yycrank+235, yysvec+33, yyvstop+322,
1689: yycrank+235, yysvec+33, yyvstop+324,
1690: yycrank+0, yysvec+33, yyvstop+326,
1691: yycrank+279, yysvec+33, yyvstop+329,
1692: yycrank+280, yysvec+33, yyvstop+331,
1693: yycrank+266, yysvec+33, yyvstop+333,
1694: yycrank+0, yysvec+33, yyvstop+335,
1695: yycrank+267, yysvec+33, yyvstop+338,
1696: yycrank+0, yysvec+33, yyvstop+340,
1697: yycrank+313, yysvec+33, yyvstop+343,
1698: yycrank+306, yysvec+33, yyvstop+345,
1699: yycrank+317, yysvec+33, yyvstop+347,
1700: yycrank+315, yysvec+33, yyvstop+349,
1701: yycrank+0, yysvec+33, yyvstop+351,
1702: yycrank+314, yysvec+33, yyvstop+354,
1703: yycrank+0, yysvec+33, yyvstop+356,
1704: yycrank+319, yysvec+33, yyvstop+359,
1705: yycrank+327, yysvec+33, yyvstop+361,
1706: yycrank+335, yysvec+33, yyvstop+363,
1707: yycrank+346, yysvec+33, yyvstop+365,
1708: yycrank+330, yysvec+33, yyvstop+367,
1709: yycrank+0, yysvec+33, yyvstop+369,
1710: yycrank+354, yysvec+33, yyvstop+372,
1711: yycrank+356, yysvec+33, yyvstop+374,
1712: yycrank+348, yysvec+33, yyvstop+376,
1713: yycrank+355, yysvec+33, yyvstop+378,
1714: yycrank+352, yysvec+33, yyvstop+380,
1715: yycrank+353, yysvec+33, yyvstop+383,
1716: yycrank+361, yysvec+33, yyvstop+385,
1717: yycrank+361, yysvec+33, yyvstop+387,
1718: yycrank+366, yysvec+33, yyvstop+389,
1719: yycrank+556, 0, yyvstop+391,
1720: yycrank+0, yysvec+139, yyvstop+393,
1721: yycrank+398, yysvec+33, yyvstop+395,
1722: yycrank+429, yysvec+33, yyvstop+397,
1723: yycrank+373, yysvec+33, yyvstop+399,
1724: yycrank+381, yysvec+33, yyvstop+401,
1725: yycrank+398, yysvec+33, yyvstop+403,
1726: yycrank+388, yysvec+33, yyvstop+405,
1727: yycrank+0, yysvec+33, yyvstop+407,
1728: yycrank+0, yysvec+33, yyvstop+410,
1729: yycrank+391, yysvec+33, yyvstop+413,
1730: yycrank+393, yysvec+33, yyvstop+415,
1731: yycrank+405, yysvec+33, yyvstop+418,
1732: yycrank+0, yysvec+33, yyvstop+420,
1733: yycrank+391, yysvec+33, yyvstop+423,
1734: yycrank+397, yysvec+33, yyvstop+425,
1735: yycrank+410, yysvec+33, yyvstop+427,
1736: yycrank+413, yysvec+33, yyvstop+429,
1737: yycrank+400, yysvec+33, yyvstop+432,
1738: yycrank+0, yysvec+33, yyvstop+434,
1739: yycrank+403, yysvec+33, yyvstop+437,
1740: yycrank+402, yysvec+33, yyvstop+439,
1741: yycrank+409, yysvec+33, yyvstop+441,
1742: yycrank+0, yysvec+33, yyvstop+443,
1743: yycrank+421, yysvec+33, yyvstop+446,
1744: yycrank+406, yysvec+33, yyvstop+448,
1745: yycrank+422, yysvec+33, yyvstop+450,
1746: yycrank+406, yysvec+33, yyvstop+452,
1747: yycrank+415, yysvec+33, yyvstop+454,
1748: yycrank+428, yysvec+33, yyvstop+456,
1749: yycrank+0, 0, yyvstop+458,
1750: yycrank+0, yysvec+33, yyvstop+460,
1751: yycrank+0, yysvec+33, yyvstop+463,
1752: yycrank+0, yysvec+33, yyvstop+466,
1753: yycrank+0, yysvec+33, yyvstop+469,
1754: yycrank+421, yysvec+33, yyvstop+472,
1755: yycrank+431, yysvec+33, yyvstop+474,
1756: yycrank+430, yysvec+33, yyvstop+476,
1757: yycrank+431, yysvec+33, yyvstop+478,
1758: yycrank+448, yysvec+33, yyvstop+480,
1759: yycrank+0, yysvec+33, yyvstop+482,
1760: yycrank+455, yysvec+33, yyvstop+485,
1761: yycrank+0, yysvec+33, yyvstop+487,
1762: yycrank+455, yysvec+33, yyvstop+490,
1763: yycrank+459, yysvec+33, yyvstop+492,
1764: yycrank+452, yysvec+33, yyvstop+495,
1765: yycrank+0, yysvec+33, yyvstop+497,
1766: yycrank+447, yysvec+33, yyvstop+500,
1767: yycrank+0, yysvec+33, yyvstop+502,
1768: yycrank+450, yysvec+33, yyvstop+505,
1769: yycrank+462, yysvec+33, yyvstop+507,
1770: yycrank+471, yysvec+33, yyvstop+509,
1771: yycrank+492, yysvec+33, yyvstop+511,
1772: yycrank+0, yysvec+33, yyvstop+513,
1773: yycrank+477, yysvec+33, yyvstop+516,
1774: yycrank+0, yysvec+33, yyvstop+518,
1775: yycrank+0, yysvec+33, yyvstop+521,
1776: yycrank+484, yysvec+33, yyvstop+524,
1777: yycrank+495, yysvec+33, yyvstop+526,
1778: yycrank+0, yysvec+33, yyvstop+528,
1779: yycrank+504, yysvec+33, yyvstop+531,
1780: yycrank+0, yysvec+33, yyvstop+533,
1781: yycrank+0, yysvec+33, yyvstop+536,
1782: yycrank+511, yysvec+33, yyvstop+539,
1783: yycrank+0, yysvec+33, yyvstop+541,
1784: yycrank+0, yysvec+33, yyvstop+544,
1785: yycrank+500, yysvec+33, yyvstop+547,
1786: yycrank+501, yysvec+33, yyvstop+549,
1787: yycrank+515, yysvec+33, yyvstop+551,
1788: yycrank+507, yysvec+33, yyvstop+553,
1789: yycrank+0, yysvec+33, yyvstop+555,
1790: yycrank+517, yysvec+33, yyvstop+558,
1791: yycrank+0, yysvec+33, yyvstop+560,
1792: yycrank+0, yysvec+33, yyvstop+563,
1793: yycrank+0, yysvec+33, yyvstop+566,
1794: yycrank+0, yysvec+33, yyvstop+569,
1795: yycrank+0, yysvec+33, yyvstop+572,
1796: yycrank+0, yysvec+33, yyvstop+575,
1797: 0, 0, 0};
1798: struct yywork *yytop = yycrank+618;
1799: struct yysvf *yybgin = yysvec+1;
1800: Uchar yymatch[] = {
1801: 00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1802: 01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 ,
1803: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1804: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1805: 011 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1806: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1807: '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
1808: '8' ,'8' ,01 ,01 ,01 ,01 ,01 ,01 ,
1809: 01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
1810: 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
1811: 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
1812: 'G' ,'G' ,'G' ,01 ,01 ,01 ,01 ,'G' ,
1813: 01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
1814: 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
1815: 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
1816: 'G' ,'G' ,'G' ,01 ,01 ,01 ,01 ,01 ,
1817: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1818: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1819: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1820: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1821: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1822: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1823: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1824: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1825: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1826: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1827: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1828: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1829: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1830: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1831: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1832: 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
1833: 0};
1834: Uchar yyextra[] = {
1835: 0,0,0,0,0,0,0,0,
1836: 0,0,0,0,0,0,0,0,
1837: 0,0,0,0,0,0,0,0,
1838: 0,0,0,0,0,0,0,0,
1839: 0,0,0,0,0,0,0,0,
1840: 0,0,0,0,0,0,0,0,
1841: 0,0,0,0,0,0,0,0,
1842: 0,0,0,0,0,0,0,0,
1843: 0,0,0,0,0,0,0,0,
1844: 0,0,0,0,0,0,0,0,
1845: 0,0,0,0,0,0,0,0,
1846: 0,0,0,0,0,0,0,0,
1847: 0,0,0,0,0,0,0,0,
1848: 0};
1849: int yylineno =1;
1850: # define YYU(x) x
1851: char yytext[YYLMAX];
1852: struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
1853: Uchar yysbuf[YYLMAX];
1854: Uchar *yysptr = yysbuf;
1855: int *yyfnd;
1856: extern struct yysvf *yyestate;
1857: int yyprevious = YYNEWLINE;
1858: # ifdef LEXDEBUG
1859: extern void allprint(char);
1860: # endif
1861: yylook(void){
1862: struct yysvf *yystate, **lsp;
1863: struct yywork *yyt;
1864: struct yysvf *yyz;
1865: int yych;
1866: struct yywork *yyr;
1867: # ifdef LEXDEBUG
1868: int debug;
1869: # endif
1870: Uchar *yylastch;
1871: /* start off machines */
1872: # ifdef LEXDEBUG
1873: debug = 0;
1874: # endif
1875: if (!yymorfg)
1876: yylastch = (Uchar*)yytext;
1877: else {
1878: yymorfg=0;
1879: yylastch = (Uchar*)yytext+yyleng;
1880: }
1881: for(;;){
1882: lsp = yylstate;
1883: yyestate = yystate = yybgin;
1884: if (yyprevious==YYNEWLINE) yystate++;
1885: for (;;){
1886: # ifdef LEXDEBUG
1887: if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
1888: # endif
1889: yyt = yystate->yystoff;
1890: if(yyt == yycrank){ /* may not be any transitions */
1891: yyz = yystate->yyother;
1892: if(yyz == 0)break;
1893: if(yyz->yystoff == yycrank)break;
1894: }
1895: *yylastch++ = yych = input();
1896: tryagain:
1897: # ifdef LEXDEBUG
1898: if(debug){
1899: fprintf(yyout,"char ");
1900: allprint(yych);
1901: putchar('\n');
1902: }
1903: # endif
1904: yyr = yyt;
1.3 ! millert 1905: if ( (int)yyt > (int)yycrank){
1.1 millert 1906: yyt = yyr + yych;
1907: if (yyt <= yytop && yyt->verify+yysvec == yystate){
1908: if(yyt->advance+yysvec == YYLERR) /* error transitions */
1909: {unput(*--yylastch);break;}
1910: *lsp++ = yystate = yyt->advance+yysvec;
1911: goto contin;
1912: }
1913: }
1914: # ifdef YYOPTIM
1.3 ! millert 1915: else if((int)yyt < (int)yycrank) { /* r < yycrank */
1.1 millert 1916: yyt = yyr = yycrank+(yycrank-yyt);
1917: # ifdef LEXDEBUG
1918: if(debug)fprintf(yyout,"compressed state\n");
1919: # endif
1920: yyt = yyt + yych;
1921: if(yyt <= yytop && yyt->verify+yysvec == yystate){
1922: if(yyt->advance+yysvec == YYLERR) /* error transitions */
1923: {unput(*--yylastch);break;}
1924: *lsp++ = yystate = yyt->advance+yysvec;
1925: goto contin;
1926: }
1927: yyt = yyr + YYU(yymatch[yych]);
1928: # ifdef LEXDEBUG
1929: if(debug){
1930: fprintf(yyout,"try fall back character ");
1931: allprint(YYU(yymatch[yych]));
1932: putchar('\n');
1933: }
1934: # endif
1935: if(yyt <= yytop && yyt->verify+yysvec == yystate){
1936: if(yyt->advance+yysvec == YYLERR) /* error transition */
1937: {unput(*--yylastch);break;}
1938: *lsp++ = yystate = yyt->advance+yysvec;
1939: goto contin;
1940: }
1941: }
1942: if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
1943: # ifdef LEXDEBUG
1944: if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
1945: # endif
1946: goto tryagain;
1947: }
1948: # endif
1949: else
1950: {unput(*--yylastch);break;}
1951: contin:
1952: # ifdef LEXDEBUG
1953: if(debug){
1954: fprintf(yyout,"state %d char ",yystate-yysvec-1);
1955: allprint(yych);
1956: putchar('\n');
1957: }
1958: # endif
1959: ;
1960: }
1961: # ifdef LEXDEBUG
1962: if(debug){
1963: fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
1964: allprint(yych);
1965: putchar('\n');
1966: }
1967: # endif
1968: while (lsp-- > yylstate){
1969: *yylastch-- = 0;
1970: if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
1971: yyolsp = lsp;
1972: if(yyextra[*yyfnd]){ /* must backup */
1973: while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
1974: lsp--;
1975: unput(*yylastch--);
1976: }
1977: }
1978: yyprevious = YYU(*yylastch);
1979: yylsp = lsp;
1980: yyleng = yylastch-(Uchar*)yytext+1;
1981: yytext[yyleng] = 0;
1982: # ifdef LEXDEBUG
1983: if(debug){
1984: fprintf(yyout,"\nmatch '%s'", yytext);
1985: fprintf(yyout," action %d\n",*yyfnd);
1986: }
1987: # endif
1988: return(*yyfnd++);
1989: }
1990: unput(*yylastch);
1991: }
1992: if (yytext[0] == 0 /* && feof(yyin) */)
1993: {
1994: yysptr=yysbuf;
1995: return(0);
1996: }
1997: yyprevious = input();
1998: yytext[0] = yyprevious;
1999: if (yyprevious>0)
2000: output(yyprevious);
2001: yylastch = (Uchar*)yytext;
2002: # ifdef LEXDEBUG
2003: if(debug)putchar('\n');
2004: # endif
2005: }
2006: return(0); /* shut up the compiler; i have no idea what should be returned */
2007: }
2008: yyback(int *p, int m)
2009: {
2010: if (p==0) return(0);
2011: while (*p)
2012: {
2013: if (*p++ == m)
2014: return(1);
2015: }
2016: return(0);
2017: }
2018: /* the following are only used in the lex library */
2019: yyinput(void){
2020: return(input());
2021: }
2022: void
2023: yyoutput(int c)
2024: {
2025: output(c);
2026: }
2027: void
2028: yyunput(int c)
2029: {
2030: unput(c);
2031: }