1 using System;
2 using System.Lex;
3 using RexTokens;
4
5
6
7 public class RexLexer : System.Lex.Lexer
8 {
9 public RexLexer(const ustring& content_, const string& fileName_, int fileIndex_) :
10 base(content_, fileName_, fileIndex_)
11 {
12 RexClassMap.Init();
13 }
14 public RexLexer(const uchar* start_, const uchar* end_, const string& fileName_, int fileIndex_) :
15 base(start_, end_, fileName_, fileIndex_)
16 {
17 RexClassMap.Init();
18 }
19 public override int NextState(int state, uchar c)
20 {
21 int i = RexClassMap.GetClass(c);
22 switch (state)
23 {
24 case 0:
25 {
26 switch (i)
27 {
28 case 0:
29 {
30 return 1;
31 }
32 case 1:
33 {
34 return 2;
35 }
36 case 2:
37 {
38 return 3;
39 }
40 case 3:
41 {
42 return 4;
43 }
44 case 4:
45 {
46 return 5;
47 }
48 case 5:
49 {
50 return 6;
51 }
52 case 6:
53 {
54 return 7;
55 }
56 case 7:
57 {
58 return 8;
59 }
60 case 8:
61 {
62 return 9;
63 }
64 case 9:
65 {
66 return 10;
67 }
68 case 10:
69 {
70 return 11;
71 }
72 case 11:
73 {
74 return 12;
75 }
76 case 12: case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 30:
77 {
78 return 13;
79 }
80 case 31:
81 {
82 return 14;
83 }
84 default:
85 {
86 return -1;
87 }
88 }
89 return -1;
90 }
91 case 14:
92 {
93 switch (i)
94 {
95 case 0:
96 {
97 return 1;
98 }
99 case 1:
100 {
101 return 2;
102 }
103 case 2:
104 {
105 return 3;
106 }
107 case 3:
108 {
109 return 4;
110 }
111 case 4:
112 {
113 return 5;
114 }
115 case 5:
116 {
117 return 6;
118 }
119 case 6:
120 {
121 return 7;
122 }
123 case 7:
124 {
125 return 8;
126 }
127 case 8:
128 {
129 return 9;
130 }
131 case 9:
132 {
133 return 10;
134 }
135 case 10:
136 {
137 return 11;
138 }
139 case 11:
140 {
141 return 12;
142 }
143 case 12: case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 30:
144 {
145 return 13;
146 }
147 default:
148 {
149 return -1;
150 }
151 }
152 return -1;
153 }
154 case 13:
155 {
156 System.Lex.Lexeme prevMatch = token.match;
157 token.match = lexeme;
158 int tokenId = GetTokenId(12);
159 if (tokenId == CONTINUE_TOKEN)
160 {
161 token.id = CONTINUE_TOKEN;
162 return -1;
163 }
164 else
165 {
166 if (tokenId != INVALID_TOKEN)
167 {
168 token.id = tokenId;
169 }
170 else
171 {
172 token.match = prevMatch;
173 }
174 }
175 return -1;
176 }
177 case 12:
178 {
179 System.Lex.Lexeme prevMatch = token.match;
180 token.match = lexeme;
181 int tokenId = GetTokenId(11);
182 if (tokenId == CONTINUE_TOKEN)
183 {
184 token.id = CONTINUE_TOKEN;
185 return -1;
186 }
187 else
188 {
189 if (tokenId != INVALID_TOKEN)
190 {
191 token.id = tokenId;
192 }
193 else
194 {
195 token.match = prevMatch;
196 }
197 }
198 return -1;
199 }
200 case 11:
201 {
202 System.Lex.Lexeme prevMatch = token.match;
203 token.match = lexeme;
204 int tokenId = GetTokenId(10);
205 if (tokenId == CONTINUE_TOKEN)
206 {
207 token.id = CONTINUE_TOKEN;
208 return -1;
209 }
210 else
211 {
212 if (tokenId != INVALID_TOKEN)
213 {
214 token.id = tokenId;
215 }
216 else
217 {
218 token.match = prevMatch;
219 }
220 }
221 return -1;
222 }
223 case 10:
224 {
225 System.Lex.Lexeme prevMatch = token.match;
226 token.match = lexeme;
227 int tokenId = GetTokenId(9);
228 if (tokenId == CONTINUE_TOKEN)
229 {
230 token.id = CONTINUE_TOKEN;
231 return -1;
232 }
233 else
234 {
235 if (tokenId != INVALID_TOKEN)
236 {
237 token.id = tokenId;
238 }
239 else
240 {
241 token.match = prevMatch;
242 }
243 }
244 switch (i)
245 {
246 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 18: case 21: case 30: case 32: case 33: case 34: case 35:
247 {
248 return 15;
249 }
250 case 14:
251 {
252 return 16;
253 }
254 case 15:
255 {
256 return 17;
257 }
258 case 16:
259 {
260 return 18;
261 }
262 case 17:
263 {
264 return 19;
265 }
266 case 19:
267 {
268 return 20;
269 }
270 case 20:
271 {
272 return 21;
273 }
274 case 22:
275 {
276 return 22;
277 }
278 case 23:
279 {
280 return 23;
281 }
282 case 24:
283 {
284 return 24;
285 }
286 case 25:
287 {
288 return 25;
289 }
290 case 26:
291 {
292 return 26;
293 }
294 case 27:
295 {
296 return 27;
297 }
298 case 28:
299 {
300 return 28;
301 }
302 case 29:
303 {
304 return 29;
305 }
306 case 31:
307 {
308 return 30;
309 }
310 default:
311 {
312 return -1;
313 }
314 }
315 return -1;
316 }
317 case 30:
318 {
319 System.Lex.Lexeme prevMatch = token.match;
320 token.match = lexeme;
321 int tokenId = GetTokenId(9);
322 if (tokenId == CONTINUE_TOKEN)
323 {
324 token.id = CONTINUE_TOKEN;
325 return -1;
326 }
327 else
328 {
329 if (tokenId != INVALID_TOKEN)
330 {
331 token.id = tokenId;
332 }
333 else
334 {
335 token.match = prevMatch;
336 }
337 }
338 switch (i)
339 {
340 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 18: case 21: case 30: case 32: case 33: case 34: case 35:
341 {
342 return 15;
343 }
344 case 14:
345 {
346 return 16;
347 }
348 case 15:
349 {
350 return 17;
351 }
352 case 16:
353 {
354 return 18;
355 }
356 case 17:
357 {
358 return 19;
359 }
360 case 19:
361 {
362 return 20;
363 }
364 case 20:
365 {
366 return 21;
367 }
368 case 22:
369 {
370 return 22;
371 }
372 case 23:
373 {
374 return 23;
375 }
376 case 24:
377 {
378 return 24;
379 }
380 case 25:
381 {
382 return 25;
383 }
384 case 26:
385 {
386 return 26;
387 }
388 case 27:
389 {
390 return 27;
391 }
392 case 28:
393 {
394 return 28;
395 }
396 case 29:
397 {
398 return 29;
399 }
400 case 31:
401 {
402 return 31;
403 }
404 default:
405 {
406 return -1;
407 }
408 }
409 return -1;
410 }
411 case 31:
412 {
413 System.Lex.Lexeme prevMatch = token.match;
414 token.match = lexeme;
415 int tokenId = GetTokenId(9);
416 if (tokenId == CONTINUE_TOKEN)
417 {
418 token.id = CONTINUE_TOKEN;
419 return -1;
420 }
421 else
422 {
423 if (tokenId != INVALID_TOKEN)
424 {
425 token.id = tokenId;
426 }
427 else
428 {
429 token.match = prevMatch;
430 }
431 }
432 switch (i)
433 {
434 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 18: case 21: case 30: case 32: case 33: case 34: case 35:
435 {
436 return 15;
437 }
438 case 14:
439 {
440 return 16;
441 }
442 case 15:
443 {
444 return 17;
445 }
446 case 16:
447 {
448 return 18;
449 }
450 case 17:
451 {
452 return 19;
453 }
454 case 19:
455 {
456 return 20;
457 }
458 case 20:
459 {
460 return 21;
461 }
462 case 22:
463 {
464 return 22;
465 }
466 case 23:
467 {
468 return 23;
469 }
470 case 24:
471 {
472 return 24;
473 }
474 case 25:
475 {
476 return 25;
477 }
478 case 26:
479 {
480 return 26;
481 }
482 case 27:
483 {
484 return 27;
485 }
486 case 28:
487 {
488 return 28;
489 }
490 case 29:
491 {
492 return 29;
493 }
494 case 31:
495 {
496 return 32;
497 }
498 default:
499 {
500 return -1;
501 }
502 }
503 return -1;
504 }
505 case 32:
506 {
507 System.Lex.Lexeme prevMatch = token.match;
508 token.match = lexeme;
509 int tokenId = GetTokenId(9);
510 if (tokenId == CONTINUE_TOKEN)
511 {
512 token.id = CONTINUE_TOKEN;
513 return -1;
514 }
515 else
516 {
517 if (tokenId != INVALID_TOKEN)
518 {
519 token.id = tokenId;
520 }
521 else
522 {
523 token.match = prevMatch;
524 }
525 }
526 switch (i)
527 {
528 case 14:
529 {
530 return 33;
531 }
532 case 15:
533 {
534 return 34;
535 }
536 case 16:
537 {
538 return 35;
539 }
540 case 19:
541 {
542 return 36;
543 }
544 case 20:
545 {
546 return 37;
547 }
548 case 22:
549 {
550 return 38;
551 }
552 case 23:
553 {
554 return 39;
555 }
556 case 24:
557 {
558 return 40;
559 }
560 case 25:
561 {
562 return 41;
563 }
564 case 26:
565 {
566 return 42;
567 }
568 case 27:
569 {
570 return 43;
571 }
572 case 28:
573 {
574 return 44;
575 }
576 case 29:
577 {
578 return 45;
579 }
580 case 31:
581 {
582 return 46;
583 }
584 default:
585 {
586 return -1;
587 }
588 }
589 return -1;
590 }
591 case 46:
592 {
593 System.Lex.Lexeme prevMatch = token.match;
594 token.match = lexeme;
595 int tokenId = GetTokenId(9);
596 if (tokenId == CONTINUE_TOKEN)
597 {
598 token.id = CONTINUE_TOKEN;
599 return -1;
600 }
601 else
602 {
603 if (tokenId != INVALID_TOKEN)
604 {
605 token.id = tokenId;
606 }
607 else
608 {
609 token.match = prevMatch;
610 }
611 }
612 switch (i)
613 {
614 case 14:
615 {
616 return 33;
617 }
618 case 15:
619 {
620 return 34;
621 }
622 case 19:
623 {
624 return 36;
625 }
626 case 20:
627 {
628 return 37;
629 }
630 case 22:
631 {
632 return 38;
633 }
634 case 23:
635 {
636 return 39;
637 }
638 case 24:
639 {
640 return 40;
641 }
642 case 25:
643 {
644 return 41;
645 }
646 case 26:
647 {
648 return 42;
649 }
650 case 27:
651 {
652 return 43;
653 }
654 case 28:
655 {
656 return 44;
657 }
658 case 31:
659 {
660 return 47;
661 }
662 default:
663 {
664 return -1;
665 }
666 }
667 return -1;
668 }
669 case 47:
670 {
671 System.Lex.Lexeme prevMatch = token.match;
672 token.match = lexeme;
673 int tokenId = GetTokenId(9);
674 if (tokenId == CONTINUE_TOKEN)
675 {
676 token.id = CONTINUE_TOKEN;
677 return -1;
678 }
679 else
680 {
681 if (tokenId != INVALID_TOKEN)
682 {
683 token.id = tokenId;
684 }
685 else
686 {
687 token.match = prevMatch;
688 }
689 }
690 switch (i)
691 {
692 case 14:
693 {
694 return 33;
695 }
696 case 15:
697 {
698 return 34;
699 }
700 case 19:
701 {
702 return 36;
703 }
704 case 20:
705 {
706 return 37;
707 }
708 case 22:
709 {
710 return 38;
711 }
712 case 23:
713 {
714 return 39;
715 }
716 case 24:
717 {
718 return 40;
719 }
720 case 25:
721 {
722 return 41;
723 }
724 case 26:
725 {
726 return 42;
727 }
728 case 27:
729 {
730 return 43;
731 }
732 case 31:
733 {
734 return 48;
735 }
736 default:
737 {
738 return -1;
739 }
740 }
741 return -1;
742 }
743 case 48:
744 {
745 switch (i)
746 {
747 case 14:
748 {
749 return 33;
750 }
751 case 15:
752 {
753 return 34;
754 }
755 case 19:
756 {
757 return 36;
758 }
759 case 20:
760 {
761 return 37;
762 }
763 case 23:
764 {
765 return 39;
766 }
767 case 24:
768 {
769 return 40;
770 }
771 case 25:
772 {
773 return 41;
774 }
775 case 26:
776 {
777 return 42;
778 }
779 case 31:
780 {
781 return 49;
782 }
783 default:
784 {
785 return -1;
786 }
787 }
788 return -1;
789 }
790 case 49:
791 {
792 switch (i)
793 {
794 case 23:
795 {
796 return 39;
797 }
798 case 24:
799 {
800 return 40;
801 }
802 case 25:
803 {
804 return 41;
805 }
806 case 31:
807 {
808 return 50;
809 }
810 default:
811 {
812 return -1;
813 }
814 }
815 return -1;
816 }
817 case 50:
818 {
819 switch (i)
820 {
821 case 23:
822 {
823 return 39;
824 }
825 case 24:
826 {
827 return 40;
828 }
829 default:
830 {
831 return -1;
832 }
833 }
834 return -1;
835 }
836 case 45:
837 {
838 System.Lex.Lexeme prevMatch = token.match;
839 token.match = lexeme;
840 int tokenId = GetTokenId(9);
841 if (tokenId == CONTINUE_TOKEN)
842 {
843 token.id = CONTINUE_TOKEN;
844 return -1;
845 }
846 else
847 {
848 if (tokenId != INVALID_TOKEN)
849 {
850 token.id = tokenId;
851 }
852 else
853 {
854 token.match = prevMatch;
855 }
856 }
857 switch (i)
858 {
859 case 31:
860 {
861 return 51;
862 }
863 default:
864 {
865 return -1;
866 }
867 }
868 return -1;
869 }
870 case 51:
871 {
872 System.Lex.Lexeme prevMatch = token.match;
873 token.match = lexeme;
874 int tokenId = GetTokenId(9);
875 if (tokenId == CONTINUE_TOKEN)
876 {
877 token.id = CONTINUE_TOKEN;
878 return -1;
879 }
880 else
881 {
882 if (tokenId != INVALID_TOKEN)
883 {
884 token.id = tokenId;
885 }
886 else
887 {
888 token.match = prevMatch;
889 }
890 }
891 switch (i)
892 {
893 case 31:
894 {
895 return 52;
896 }
897 default:
898 {
899 return -1;
900 }
901 }
902 return -1;
903 }
904 case 52:
905 {
906 System.Lex.Lexeme prevMatch = token.match;
907 token.match = lexeme;
908 int tokenId = GetTokenId(9);
909 if (tokenId == CONTINUE_TOKEN)
910 {
911 token.id = CONTINUE_TOKEN;
912 return -1;
913 }
914 else
915 {
916 if (tokenId != INVALID_TOKEN)
917 {
918 token.id = tokenId;
919 }
920 else
921 {
922 token.match = prevMatch;
923 }
924 }
925 switch (i)
926 {
927 case 31:
928 {
929 return 53;
930 }
931 default:
932 {
933 return -1;
934 }
935 }
936 return -1;
937 }
938 case 53:
939 {
940 System.Lex.Lexeme prevMatch = token.match;
941 token.match = lexeme;
942 int tokenId = GetTokenId(9);
943 if (tokenId == CONTINUE_TOKEN)
944 {
945 token.id = CONTINUE_TOKEN;
946 return -1;
947 }
948 else
949 {
950 if (tokenId != INVALID_TOKEN)
951 {
952 token.id = tokenId;
953 }
954 else
955 {
956 token.match = prevMatch;
957 }
958 }
959 return -1;
960 }
961 case 44:
962 {
963 System.Lex.Lexeme prevMatch = token.match;
964 token.match = lexeme;
965 int tokenId = GetTokenId(9);
966 if (tokenId == CONTINUE_TOKEN)
967 {
968 token.id = CONTINUE_TOKEN;
969 return -1;
970 }
971 else
972 {
973 if (tokenId != INVALID_TOKEN)
974 {
975 token.id = tokenId;
976 }
977 else
978 {
979 token.match = prevMatch;
980 }
981 }
982 switch (i)
983 {
984 case 31:
985 {
986 return 54;
987 }
988 default:
989 {
990 return -1;
991 }
992 }
993 return -1;
994 }
995 case 54:
996 {
997 System.Lex.Lexeme prevMatch = token.match;
998 token.match = lexeme;
999 int tokenId = GetTokenId(9);
1000 if (tokenId == CONTINUE_TOKEN)
1001 {
1002 token.id = CONTINUE_TOKEN;
1003 return -1;
1004 }
1005 else
1006 {
1007 if (tokenId != INVALID_TOKEN)
1008 {
1009 token.id = tokenId;
1010 }
1011 else
1012 {
1013 token.match = prevMatch;
1014 }
1015 }
1016 switch (i)
1017 {
1018 case 31:
1019 {
1020 return 51;
1021 }
1022 default:
1023 {
1024 return -1;
1025 }
1026 }
1027 return -1;
1028 }
1029 case 43:
1030 {
1031 System.Lex.Lexeme prevMatch = token.match;
1032 token.match = lexeme;
1033 int tokenId = GetTokenId(9);
1034 if (tokenId == CONTINUE_TOKEN)
1035 {
1036 token.id = CONTINUE_TOKEN;
1037 return -1;
1038 }
1039 else
1040 {
1041 if (tokenId != INVALID_TOKEN)
1042 {
1043 token.id = tokenId;
1044 }
1045 else
1046 {
1047 token.match = prevMatch;
1048 }
1049 }
1050 switch (i)
1051 {
1052 case 31:
1053 {
1054 return 55;
1055 }
1056 default:
1057 {
1058 return -1;
1059 }
1060 }
1061 return -1;
1062 }
1063 case 55:
1064 {
1065 System.Lex.Lexeme prevMatch = token.match;
1066 token.match = lexeme;
1067 int tokenId = GetTokenId(9);
1068 if (tokenId == CONTINUE_TOKEN)
1069 {
1070 token.id = CONTINUE_TOKEN;
1071 return -1;
1072 }
1073 else
1074 {
1075 if (tokenId != INVALID_TOKEN)
1076 {
1077 token.id = tokenId;
1078 }
1079 else
1080 {
1081 token.match = prevMatch;
1082 }
1083 }
1084 switch (i)
1085 {
1086 case 31:
1087 {
1088 return 54;
1089 }
1090 default:
1091 {
1092 return -1;
1093 }
1094 }
1095 return -1;
1096 }
1097 case 42:
1098 {
1099 System.Lex.Lexeme prevMatch = token.match;
1100 token.match = lexeme;
1101 int tokenId = GetTokenId(9);
1102 if (tokenId == CONTINUE_TOKEN)
1103 {
1104 token.id = CONTINUE_TOKEN;
1105 return -1;
1106 }
1107 else
1108 {
1109 if (tokenId != INVALID_TOKEN)
1110 {
1111 token.id = tokenId;
1112 }
1113 else
1114 {
1115 token.match = prevMatch;
1116 }
1117 }
1118 switch (i)
1119 {
1120 case 31:
1121 {
1122 return 56;
1123 }
1124 default:
1125 {
1126 return -1;
1127 }
1128 }
1129 return -1;
1130 }
1131 case 56:
1132 {
1133 System.Lex.Lexeme prevMatch = token.match;
1134 token.match = lexeme;
1135 int tokenId = GetTokenId(9);
1136 if (tokenId == CONTINUE_TOKEN)
1137 {
1138 token.id = CONTINUE_TOKEN;
1139 return -1;
1140 }
1141 else
1142 {
1143 if (tokenId != INVALID_TOKEN)
1144 {
1145 token.id = tokenId;
1146 }
1147 else
1148 {
1149 token.match = prevMatch;
1150 }
1151 }
1152 switch (i)
1153 {
1154 case 31:
1155 {
1156 return 55;
1157 }
1158 default:
1159 {
1160 return -1;
1161 }
1162 }
1163 return -1;
1164 }
1165 case 41:
1166 {
1167 System.Lex.Lexeme prevMatch = token.match;
1168 token.match = lexeme;
1169 int tokenId = GetTokenId(9);
1170 if (tokenId == CONTINUE_TOKEN)
1171 {
1172 token.id = CONTINUE_TOKEN;
1173 return -1;
1174 }
1175 else
1176 {
1177 if (tokenId != INVALID_TOKEN)
1178 {
1179 token.id = tokenId;
1180 }
1181 else
1182 {
1183 token.match = prevMatch;
1184 }
1185 }
1186 switch (i)
1187 {
1188 case 31:
1189 {
1190 return 57;
1191 }
1192 default:
1193 {
1194 return -1;
1195 }
1196 }
1197 return -1;
1198 }
1199 case 57:
1200 {
1201 System.Lex.Lexeme prevMatch = token.match;
1202 token.match = lexeme;
1203 int tokenId = GetTokenId(9);
1204 if (tokenId == CONTINUE_TOKEN)
1205 {
1206 token.id = CONTINUE_TOKEN;
1207 return -1;
1208 }
1209 else
1210 {
1211 if (tokenId != INVALID_TOKEN)
1212 {
1213 token.id = tokenId;
1214 }
1215 else
1216 {
1217 token.match = prevMatch;
1218 }
1219 }
1220 switch (i)
1221 {
1222 case 31:
1223 {
1224 return 56;
1225 }
1226 default:
1227 {
1228 return -1;
1229 }
1230 }
1231 return -1;
1232 }
1233 case 40:
1234 {
1235 System.Lex.Lexeme prevMatch = token.match;
1236 token.match = lexeme;
1237 int tokenId = GetTokenId(9);
1238 if (tokenId == CONTINUE_TOKEN)
1239 {
1240 token.id = CONTINUE_TOKEN;
1241 return -1;
1242 }
1243 else
1244 {
1245 if (tokenId != INVALID_TOKEN)
1246 {
1247 token.id = tokenId;
1248 }
1249 else
1250 {
1251 token.match = prevMatch;
1252 }
1253 }
1254 switch (i)
1255 {
1256 case 31:
1257 {
1258 return 58;
1259 }
1260 default:
1261 {
1262 return -1;
1263 }
1264 }
1265 return -1;
1266 }
1267 case 58:
1268 {
1269 System.Lex.Lexeme prevMatch = token.match;
1270 token.match = lexeme;
1271 int tokenId = GetTokenId(9);
1272 if (tokenId == CONTINUE_TOKEN)
1273 {
1274 token.id = CONTINUE_TOKEN;
1275 return -1;
1276 }
1277 else
1278 {
1279 if (tokenId != INVALID_TOKEN)
1280 {
1281 token.id = tokenId;
1282 }
1283 else
1284 {
1285 token.match = prevMatch;
1286 }
1287 }
1288 switch (i)
1289 {
1290 case 31:
1291 {
1292 return 57;
1293 }
1294 default:
1295 {
1296 return -1;
1297 }
1298 }
1299 return -1;
1300 }
1301 case 39:
1302 {
1303 System.Lex.Lexeme prevMatch = token.match;
1304 token.match = lexeme;
1305 int tokenId = GetTokenId(9);
1306 if (tokenId == CONTINUE_TOKEN)
1307 {
1308 token.id = CONTINUE_TOKEN;
1309 return -1;
1310 }
1311 else
1312 {
1313 if (tokenId != INVALID_TOKEN)
1314 {
1315 token.id = tokenId;
1316 }
1317 else
1318 {
1319 token.match = prevMatch;
1320 }
1321 }
1322 switch (i)
1323 {
1324 case 31:
1325 {
1326 return 58;
1327 }
1328 default:
1329 {
1330 return -1;
1331 }
1332 }
1333 return -1;
1334 }
1335 case 38:
1336 {
1337 System.Lex.Lexeme prevMatch = token.match;
1338 token.match = lexeme;
1339 int tokenId = GetTokenId(9);
1340 if (tokenId == CONTINUE_TOKEN)
1341 {
1342 token.id = CONTINUE_TOKEN;
1343 return -1;
1344 }
1345 else
1346 {
1347 if (tokenId != INVALID_TOKEN)
1348 {
1349 token.id = tokenId;
1350 }
1351 else
1352 {
1353 token.match = prevMatch;
1354 }
1355 }
1356 switch (i)
1357 {
1358 case 22:
1359 {
1360 return 38;
1361 }
1362 case 31:
1363 {
1364 return 59;
1365 }
1366 default:
1367 {
1368 return -1;
1369 }
1370 }
1371 return -1;
1372 }
1373 case 59:
1374 {
1375 System.Lex.Lexeme prevMatch = token.match;
1376 token.match = lexeme;
1377 int tokenId = GetTokenId(9);
1378 if (tokenId == CONTINUE_TOKEN)
1379 {
1380 token.id = CONTINUE_TOKEN;
1381 return -1;
1382 }
1383 else
1384 {
1385 if (tokenId != INVALID_TOKEN)
1386 {
1387 token.id = tokenId;
1388 }
1389 else
1390 {
1391 token.match = prevMatch;
1392 }
1393 }
1394 switch (i)
1395 {
1396 case 22:
1397 {
1398 return 38;
1399 }
1400 case 31:
1401 {
1402 return 60;
1403 }
1404 default:
1405 {
1406 return -1;
1407 }
1408 }
1409 return -1;
1410 }
1411 case 60:
1412 {
1413 System.Lex.Lexeme prevMatch = token.match;
1414 token.match = lexeme;
1415 int tokenId = GetTokenId(9);
1416 if (tokenId == CONTINUE_TOKEN)
1417 {
1418 token.id = CONTINUE_TOKEN;
1419 return -1;
1420 }
1421 else
1422 {
1423 if (tokenId != INVALID_TOKEN)
1424 {
1425 token.id = tokenId;
1426 }
1427 else
1428 {
1429 token.match = prevMatch;
1430 }
1431 }
1432 switch (i)
1433 {
1434 case 31:
1435 {
1436 return 61;
1437 }
1438 default:
1439 {
1440 return -1;
1441 }
1442 }
1443 return -1;
1444 }
1445 case 61:
1446 {
1447 System.Lex.Lexeme prevMatch = token.match;
1448 token.match = lexeme;
1449 int tokenId = GetTokenId(9);
1450 if (tokenId == CONTINUE_TOKEN)
1451 {
1452 token.id = CONTINUE_TOKEN;
1453 return -1;
1454 }
1455 else
1456 {
1457 if (tokenId != INVALID_TOKEN)
1458 {
1459 token.id = tokenId;
1460 }
1461 else
1462 {
1463 token.match = prevMatch;
1464 }
1465 }
1466 switch (i)
1467 {
1468 case 31:
1469 {
1470 return 62;
1471 }
1472 default:
1473 {
1474 return -1;
1475 }
1476 }
1477 return -1;
1478 }
1479 case 62:
1480 {
1481 System.Lex.Lexeme prevMatch = token.match;
1482 token.match = lexeme;
1483 int tokenId = GetTokenId(9);
1484 if (tokenId == CONTINUE_TOKEN)
1485 {
1486 token.id = CONTINUE_TOKEN;
1487 return -1;
1488 }
1489 else
1490 {
1491 if (tokenId != INVALID_TOKEN)
1492 {
1493 token.id = tokenId;
1494 }
1495 else
1496 {
1497 token.match = prevMatch;
1498 }
1499 }
1500 switch (i)
1501 {
1502 case 31:
1503 {
1504 return 53;
1505 }
1506 default:
1507 {
1508 return -1;
1509 }
1510 }
1511 return -1;
1512 }
1513 case 37:
1514 {
1515 switch (i)
1516 {
1517 case 21: case 22:
1518 {
1519 return 63;
1520 }
1521 case 31:
1522 {
1523 return 64;
1524 }
1525 default:
1526 {
1527 return -1;
1528 }
1529 }
1530 return -1;
1531 }
1532 case 64:
1533 {
1534 switch (i)
1535 {
1536 case 21: case 22:
1537 {
1538 return 63;
1539 }
1540 case 31:
1541 {
1542 return 65;
1543 }
1544 default:
1545 {
1546 return -1;
1547 }
1548 }
1549 return -1;
1550 }
1551 case 65:
1552 {
1553 switch (i)
1554 {
1555 case 21: case 22:
1556 {
1557 return 63;
1558 }
1559 default:
1560 {
1561 return -1;
1562 }
1563 }
1564 return -1;
1565 }
1566 case 63:
1567 {
1568 System.Lex.Lexeme prevMatch = token.match;
1569 token.match = lexeme;
1570 int tokenId = GetTokenId(9);
1571 if (tokenId == CONTINUE_TOKEN)
1572 {
1573 token.id = CONTINUE_TOKEN;
1574 return -1;
1575 }
1576 else
1577 {
1578 if (tokenId != INVALID_TOKEN)
1579 {
1580 token.id = tokenId;
1581 }
1582 else
1583 {
1584 token.match = prevMatch;
1585 }
1586 }
1587 switch (i)
1588 {
1589 case 21: case 22:
1590 {
1591 return 63;
1592 }
1593 case 31:
1594 {
1595 return 66;
1596 }
1597 default:
1598 {
1599 return -1;
1600 }
1601 }
1602 return -1;
1603 }
1604 case 66:
1605 {
1606 System.Lex.Lexeme prevMatch = token.match;
1607 token.match = lexeme;
1608 int tokenId = GetTokenId(9);
1609 if (tokenId == CONTINUE_TOKEN)
1610 {
1611 token.id = CONTINUE_TOKEN;
1612 return -1;
1613 }
1614 else
1615 {
1616 if (tokenId != INVALID_TOKEN)
1617 {
1618 token.id = tokenId;
1619 }
1620 else
1621 {
1622 token.match = prevMatch;
1623 }
1624 }
1625 switch (i)
1626 {
1627 case 21: case 22:
1628 {
1629 return 63;
1630 }
1631 case 31:
1632 {
1633 return 67;
1634 }
1635 default:
1636 {
1637 return -1;
1638 }
1639 }
1640 return -1;
1641 }
1642 case 67:
1643 {
1644 System.Lex.Lexeme prevMatch = token.match;
1645 token.match = lexeme;
1646 int tokenId = GetTokenId(9);
1647 if (tokenId == CONTINUE_TOKEN)
1648 {
1649 token.id = CONTINUE_TOKEN;
1650 return -1;
1651 }
1652 else
1653 {
1654 if (tokenId != INVALID_TOKEN)
1655 {
1656 token.id = tokenId;
1657 }
1658 else
1659 {
1660 token.match = prevMatch;
1661 }
1662 }
1663 switch (i)
1664 {
1665 case 31:
1666 {
1667 return 60;
1668 }
1669 default:
1670 {
1671 return -1;
1672 }
1673 }
1674 return -1;
1675 }
1676 case 36:
1677 {
1678 switch (i)
1679 {
1680 case 21: case 22:
1681 {
1682 return 63;
1683 }
1684 case 31:
1685 {
1686 return 64;
1687 }
1688 default:
1689 {
1690 return -1;
1691 }
1692 }
1693 return -1;
1694 }
1695 case 35:
1696 {
1697 switch (i)
1698 {
1699 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1700 {
1701 return 68;
1702 }
1703 default:
1704 {
1705 return -1;
1706 }
1707 }
1708 return -1;
1709 }
1710 case 68:
1711 {
1712 switch (i)
1713 {
1714 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1715 {
1716 return 69;
1717 }
1718 default:
1719 {
1720 return -1;
1721 }
1722 }
1723 return -1;
1724 }
1725 case 69:
1726 {
1727 switch (i)
1728 {
1729 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1730 {
1731 return 70;
1732 }
1733 default:
1734 {
1735 return -1;
1736 }
1737 }
1738 return -1;
1739 }
1740 case 70:
1741 {
1742 switch (i)
1743 {
1744 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1745 {
1746 return 71;
1747 }
1748 default:
1749 {
1750 return -1;
1751 }
1752 }
1753 return -1;
1754 }
1755 case 71:
1756 {
1757 System.Lex.Lexeme prevMatch = token.match;
1758 token.match = lexeme;
1759 int tokenId = GetTokenId(9);
1760 if (tokenId == CONTINUE_TOKEN)
1761 {
1762 token.id = CONTINUE_TOKEN;
1763 return -1;
1764 }
1765 else
1766 {
1767 if (tokenId != INVALID_TOKEN)
1768 {
1769 token.id = tokenId;
1770 }
1771 else
1772 {
1773 token.match = prevMatch;
1774 }
1775 }
1776 switch (i)
1777 {
1778 case 31:
1779 {
1780 return 61;
1781 }
1782 default:
1783 {
1784 return -1;
1785 }
1786 }
1787 return -1;
1788 }
1789 case 34:
1790 {
1791 switch (i)
1792 {
1793 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1794 {
1795 return 72;
1796 }
1797 case 31:
1798 {
1799 return 73;
1800 }
1801 default:
1802 {
1803 return -1;
1804 }
1805 }
1806 return -1;
1807 }
1808 case 73:
1809 {
1810 switch (i)
1811 {
1812 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1813 {
1814 return 72;
1815 }
1816 case 31:
1817 {
1818 return 74;
1819 }
1820 default:
1821 {
1822 return -1;
1823 }
1824 }
1825 return -1;
1826 }
1827 case 74:
1828 {
1829 switch (i)
1830 {
1831 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1832 {
1833 return 72;
1834 }
1835 default:
1836 {
1837 return -1;
1838 }
1839 }
1840 return -1;
1841 }
1842 case 72:
1843 {
1844 System.Lex.Lexeme prevMatch = token.match;
1845 token.match = lexeme;
1846 int tokenId = GetTokenId(9);
1847 if (tokenId == CONTINUE_TOKEN)
1848 {
1849 token.id = CONTINUE_TOKEN;
1850 return -1;
1851 }
1852 else
1853 {
1854 if (tokenId != INVALID_TOKEN)
1855 {
1856 token.id = tokenId;
1857 }
1858 else
1859 {
1860 token.match = prevMatch;
1861 }
1862 }
1863 switch (i)
1864 {
1865 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1866 {
1867 return 72;
1868 }
1869 case 31:
1870 {
1871 return 75;
1872 }
1873 default:
1874 {
1875 return -1;
1876 }
1877 }
1878 return -1;
1879 }
1880 case 75:
1881 {
1882 System.Lex.Lexeme prevMatch = token.match;
1883 token.match = lexeme;
1884 int tokenId = GetTokenId(9);
1885 if (tokenId == CONTINUE_TOKEN)
1886 {
1887 token.id = CONTINUE_TOKEN;
1888 return -1;
1889 }
1890 else
1891 {
1892 if (tokenId != INVALID_TOKEN)
1893 {
1894 token.id = tokenId;
1895 }
1896 else
1897 {
1898 token.match = prevMatch;
1899 }
1900 }
1901 switch (i)
1902 {
1903 case 31:
1904 {
1905 return 67;
1906 }
1907 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1908 {
1909 return 72;
1910 }
1911 default:
1912 {
1913 return -1;
1914 }
1915 }
1916 return -1;
1917 }
1918 case 33:
1919 {
1920 switch (i)
1921 {
1922 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
1923 {
1924 return 72;
1925 }
1926 case 31:
1927 {
1928 return 73;
1929 }
1930 default:
1931 {
1932 return -1;
1933 }
1934 }
1935 return -1;
1936 }
1937 case 29:
1938 {
1939 System.Lex.Lexeme prevMatch = token.match;
1940 token.match = lexeme;
1941 int tokenId = GetTokenId(9);
1942 if (tokenId == CONTINUE_TOKEN)
1943 {
1944 token.id = CONTINUE_TOKEN;
1945 return -1;
1946 }
1947 else
1948 {
1949 if (tokenId != INVALID_TOKEN)
1950 {
1951 token.id = tokenId;
1952 }
1953 else
1954 {
1955 token.match = prevMatch;
1956 }
1957 }
1958 switch (i)
1959 {
1960 case 31:
1961 {
1962 return 51;
1963 }
1964 default:
1965 {
1966 return -1;
1967 }
1968 }
1969 return -1;
1970 }
1971 case 28:
1972 {
1973 System.Lex.Lexeme prevMatch = token.match;
1974 token.match = lexeme;
1975 int tokenId = GetTokenId(9);
1976 if (tokenId == CONTINUE_TOKEN)
1977 {
1978 token.id = CONTINUE_TOKEN;
1979 return -1;
1980 }
1981 else
1982 {
1983 if (tokenId != INVALID_TOKEN)
1984 {
1985 token.id = tokenId;
1986 }
1987 else
1988 {
1989 token.match = prevMatch;
1990 }
1991 }
1992 switch (i)
1993 {
1994 case 31:
1995 {
1996 return 54;
1997 }
1998 default:
1999 {
2000 return -1;
2001 }
2002 }
2003 return -1;
2004 }
2005 case 27:
2006 {
2007 System.Lex.Lexeme prevMatch = token.match;
2008 token.match = lexeme;
2009 int tokenId = GetTokenId(9);
2010 if (tokenId == CONTINUE_TOKEN)
2011 {
2012 token.id = CONTINUE_TOKEN;
2013 return -1;
2014 }
2015 else
2016 {
2017 if (tokenId != INVALID_TOKEN)
2018 {
2019 token.id = tokenId;
2020 }
2021 else
2022 {
2023 token.match = prevMatch;
2024 }
2025 }
2026 switch (i)
2027 {
2028 case 31:
2029 {
2030 return 55;
2031 }
2032 default:
2033 {
2034 return -1;
2035 }
2036 }
2037 return -1;
2038 }
2039 case 26:
2040 {
2041 System.Lex.Lexeme prevMatch = token.match;
2042 token.match = lexeme;
2043 int tokenId = GetTokenId(9);
2044 if (tokenId == CONTINUE_TOKEN)
2045 {
2046 token.id = CONTINUE_TOKEN;
2047 return -1;
2048 }
2049 else
2050 {
2051 if (tokenId != INVALID_TOKEN)
2052 {
2053 token.id = tokenId;
2054 }
2055 else
2056 {
2057 token.match = prevMatch;
2058 }
2059 }
2060 switch (i)
2061 {
2062 case 31:
2063 {
2064 return 56;
2065 }
2066 default:
2067 {
2068 return -1;
2069 }
2070 }
2071 return -1;
2072 }
2073 case 25:
2074 {
2075 System.Lex.Lexeme prevMatch = token.match;
2076 token.match = lexeme;
2077 int tokenId = GetTokenId(9);
2078 if (tokenId == CONTINUE_TOKEN)
2079 {
2080 token.id = CONTINUE_TOKEN;
2081 return -1;
2082 }
2083 else
2084 {
2085 if (tokenId != INVALID_TOKEN)
2086 {
2087 token.id = tokenId;
2088 }
2089 else
2090 {
2091 token.match = prevMatch;
2092 }
2093 }
2094 switch (i)
2095 {
2096 case 31:
2097 {
2098 return 57;
2099 }
2100 default:
2101 {
2102 return -1;
2103 }
2104 }
2105 return -1;
2106 }
2107 case 24:
2108 {
2109 System.Lex.Lexeme prevMatch = token.match;
2110 token.match = lexeme;
2111 int tokenId = GetTokenId(9);
2112 if (tokenId == CONTINUE_TOKEN)
2113 {
2114 token.id = CONTINUE_TOKEN;
2115 return -1;
2116 }
2117 else
2118 {
2119 if (tokenId != INVALID_TOKEN)
2120 {
2121 token.id = tokenId;
2122 }
2123 else
2124 {
2125 token.match = prevMatch;
2126 }
2127 }
2128 switch (i)
2129 {
2130 case 31:
2131 {
2132 return 58;
2133 }
2134 default:
2135 {
2136 return -1;
2137 }
2138 }
2139 return -1;
2140 }
2141 case 23:
2142 {
2143 System.Lex.Lexeme prevMatch = token.match;
2144 token.match = lexeme;
2145 int tokenId = GetTokenId(9);
2146 if (tokenId == CONTINUE_TOKEN)
2147 {
2148 token.id = CONTINUE_TOKEN;
2149 return -1;
2150 }
2151 else
2152 {
2153 if (tokenId != INVALID_TOKEN)
2154 {
2155 token.id = tokenId;
2156 }
2157 else
2158 {
2159 token.match = prevMatch;
2160 }
2161 }
2162 switch (i)
2163 {
2164 case 31:
2165 {
2166 return 58;
2167 }
2168 default:
2169 {
2170 return -1;
2171 }
2172 }
2173 return -1;
2174 }
2175 case 22:
2176 {
2177 System.Lex.Lexeme prevMatch = token.match;
2178 token.match = lexeme;
2179 int tokenId = GetTokenId(9);
2180 if (tokenId == CONTINUE_TOKEN)
2181 {
2182 token.id = CONTINUE_TOKEN;
2183 return -1;
2184 }
2185 else
2186 {
2187 if (tokenId != INVALID_TOKEN)
2188 {
2189 token.id = tokenId;
2190 }
2191 else
2192 {
2193 token.match = prevMatch;
2194 }
2195 }
2196 switch (i)
2197 {
2198 case 22:
2199 {
2200 return 38;
2201 }
2202 case 31:
2203 {
2204 return 76;
2205 }
2206 default:
2207 {
2208 return -1;
2209 }
2210 }
2211 return -1;
2212 }
2213 case 76:
2214 {
2215 System.Lex.Lexeme prevMatch = token.match;
2216 token.match = lexeme;
2217 int tokenId = GetTokenId(9);
2218 if (tokenId == CONTINUE_TOKEN)
2219 {
2220 token.id = CONTINUE_TOKEN;
2221 return -1;
2222 }
2223 else
2224 {
2225 if (tokenId != INVALID_TOKEN)
2226 {
2227 token.id = tokenId;
2228 }
2229 else
2230 {
2231 token.match = prevMatch;
2232 }
2233 }
2234 switch (i)
2235 {
2236 case 22:
2237 {
2238 return 38;
2239 }
2240 case 31:
2241 {
2242 return 60;
2243 }
2244 default:
2245 {
2246 return -1;
2247 }
2248 }
2249 return -1;
2250 }
2251 case 21:
2252 {
2253 System.Lex.Lexeme prevMatch = token.match;
2254 token.match = lexeme;
2255 int tokenId = GetTokenId(9);
2256 if (tokenId == CONTINUE_TOKEN)
2257 {
2258 token.id = CONTINUE_TOKEN;
2259 return -1;
2260 }
2261 else
2262 {
2263 if (tokenId != INVALID_TOKEN)
2264 {
2265 token.id = tokenId;
2266 }
2267 else
2268 {
2269 token.match = prevMatch;
2270 }
2271 }
2272 switch (i)
2273 {
2274 case 21: case 22:
2275 {
2276 return 63;
2277 }
2278 case 31:
2279 {
2280 return 77;
2281 }
2282 default:
2283 {
2284 return -1;
2285 }
2286 }
2287 return -1;
2288 }
2289 case 77:
2290 {
2291 System.Lex.Lexeme prevMatch = token.match;
2292 token.match = lexeme;
2293 int tokenId = GetTokenId(9);
2294 if (tokenId == CONTINUE_TOKEN)
2295 {
2296 token.id = CONTINUE_TOKEN;
2297 return -1;
2298 }
2299 else
2300 {
2301 if (tokenId != INVALID_TOKEN)
2302 {
2303 token.id = tokenId;
2304 }
2305 else
2306 {
2307 token.match = prevMatch;
2308 }
2309 }
2310 switch (i)
2311 {
2312 case 21: case 22:
2313 {
2314 return 63;
2315 }
2316 case 31:
2317 {
2318 return 78;
2319 }
2320 default:
2321 {
2322 return -1;
2323 }
2324 }
2325 return -1;
2326 }
2327 case 78:
2328 {
2329 System.Lex.Lexeme prevMatch = token.match;
2330 token.match = lexeme;
2331 int tokenId = GetTokenId(9);
2332 if (tokenId == CONTINUE_TOKEN)
2333 {
2334 token.id = CONTINUE_TOKEN;
2335 return -1;
2336 }
2337 else
2338 {
2339 if (tokenId != INVALID_TOKEN)
2340 {
2341 token.id = tokenId;
2342 }
2343 else
2344 {
2345 token.match = prevMatch;
2346 }
2347 }
2348 switch (i)
2349 {
2350 case 21: case 22:
2351 {
2352 return 63;
2353 }
2354 default:
2355 {
2356 return -1;
2357 }
2358 }
2359 return -1;
2360 }
2361 case 20:
2362 {
2363 System.Lex.Lexeme prevMatch = token.match;
2364 token.match = lexeme;
2365 int tokenId = GetTokenId(9);
2366 if (tokenId == CONTINUE_TOKEN)
2367 {
2368 token.id = CONTINUE_TOKEN;
2369 return -1;
2370 }
2371 else
2372 {
2373 if (tokenId != INVALID_TOKEN)
2374 {
2375 token.id = tokenId;
2376 }
2377 else
2378 {
2379 token.match = prevMatch;
2380 }
2381 }
2382 switch (i)
2383 {
2384 case 21: case 22:
2385 {
2386 return 63;
2387 }
2388 case 31:
2389 {
2390 return 77;
2391 }
2392 default:
2393 {
2394 return -1;
2395 }
2396 }
2397 return -1;
2398 }
2399 case 19:
2400 {
2401 System.Lex.Lexeme prevMatch = token.match;
2402 token.match = lexeme;
2403 int tokenId = GetTokenId(9);
2404 if (tokenId == CONTINUE_TOKEN)
2405 {
2406 token.id = CONTINUE_TOKEN;
2407 return -1;
2408 }
2409 else
2410 {
2411 if (tokenId != INVALID_TOKEN)
2412 {
2413 token.id = tokenId;
2414 }
2415 else
2416 {
2417 token.match = prevMatch;
2418 }
2419 }
2420 switch (i)
2421 {
2422 case 31:
2423 {
2424 return 52;
2425 }
2426 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2427 {
2428 return 79;
2429 }
2430 default:
2431 {
2432 return -1;
2433 }
2434 }
2435 return -1;
2436 }
2437 case 79:
2438 {
2439 switch (i)
2440 {
2441 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2442 {
2443 return 80;
2444 }
2445 default:
2446 {
2447 return -1;
2448 }
2449 }
2450 return -1;
2451 }
2452 case 80:
2453 {
2454 switch (i)
2455 {
2456 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2457 {
2458 return 81;
2459 }
2460 default:
2461 {
2462 return -1;
2463 }
2464 }
2465 return -1;
2466 }
2467 case 81:
2468 {
2469 switch (i)
2470 {
2471 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2472 {
2473 return 82;
2474 }
2475 default:
2476 {
2477 return -1;
2478 }
2479 }
2480 return -1;
2481 }
2482 case 82:
2483 {
2484 switch (i)
2485 {
2486 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2487 {
2488 return 83;
2489 }
2490 default:
2491 {
2492 return -1;
2493 }
2494 }
2495 return -1;
2496 }
2497 case 83:
2498 {
2499 switch (i)
2500 {
2501 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2502 {
2503 return 84;
2504 }
2505 default:
2506 {
2507 return -1;
2508 }
2509 }
2510 return -1;
2511 }
2512 case 84:
2513 {
2514 switch (i)
2515 {
2516 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2517 {
2518 return 85;
2519 }
2520 default:
2521 {
2522 return -1;
2523 }
2524 }
2525 return -1;
2526 }
2527 case 85:
2528 {
2529 switch (i)
2530 {
2531 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2532 {
2533 return 86;
2534 }
2535 default:
2536 {
2537 return -1;
2538 }
2539 }
2540 return -1;
2541 }
2542 case 86:
2543 {
2544 System.Lex.Lexeme prevMatch = token.match;
2545 token.match = lexeme;
2546 int tokenId = GetTokenId(9);
2547 if (tokenId == CONTINUE_TOKEN)
2548 {
2549 token.id = CONTINUE_TOKEN;
2550 return -1;
2551 }
2552 else
2553 {
2554 if (tokenId != INVALID_TOKEN)
2555 {
2556 token.id = tokenId;
2557 }
2558 else
2559 {
2560 token.match = prevMatch;
2561 }
2562 }
2563 switch (i)
2564 {
2565 case 31:
2566 {
2567 return 62;
2568 }
2569 default:
2570 {
2571 return -1;
2572 }
2573 }
2574 return -1;
2575 }
2576 case 18:
2577 {
2578 System.Lex.Lexeme prevMatch = token.match;
2579 token.match = lexeme;
2580 int tokenId = GetTokenId(9);
2581 if (tokenId == CONTINUE_TOKEN)
2582 {
2583 token.id = CONTINUE_TOKEN;
2584 return -1;
2585 }
2586 else
2587 {
2588 if (tokenId != INVALID_TOKEN)
2589 {
2590 token.id = tokenId;
2591 }
2592 else
2593 {
2594 token.match = prevMatch;
2595 }
2596 }
2597 switch (i)
2598 {
2599 case 31:
2600 {
2601 return 52;
2602 }
2603 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2604 {
2605 return 68;
2606 }
2607 default:
2608 {
2609 return -1;
2610 }
2611 }
2612 return -1;
2613 }
2614 case 17:
2615 {
2616 System.Lex.Lexeme prevMatch = token.match;
2617 token.match = lexeme;
2618 int tokenId = GetTokenId(9);
2619 if (tokenId == CONTINUE_TOKEN)
2620 {
2621 token.id = CONTINUE_TOKEN;
2622 return -1;
2623 }
2624 else
2625 {
2626 if (tokenId != INVALID_TOKEN)
2627 {
2628 token.id = tokenId;
2629 }
2630 else
2631 {
2632 token.match = prevMatch;
2633 }
2634 }
2635 switch (i)
2636 {
2637 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2638 {
2639 return 72;
2640 }
2641 case 31:
2642 {
2643 return 87;
2644 }
2645 default:
2646 {
2647 return -1;
2648 }
2649 }
2650 return -1;
2651 }
2652 case 87:
2653 {
2654 System.Lex.Lexeme prevMatch = token.match;
2655 token.match = lexeme;
2656 int tokenId = GetTokenId(9);
2657 if (tokenId == CONTINUE_TOKEN)
2658 {
2659 token.id = CONTINUE_TOKEN;
2660 return -1;
2661 }
2662 else
2663 {
2664 if (tokenId != INVALID_TOKEN)
2665 {
2666 token.id = tokenId;
2667 }
2668 else
2669 {
2670 token.match = prevMatch;
2671 }
2672 }
2673 switch (i)
2674 {
2675 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2676 {
2677 return 72;
2678 }
2679 case 31:
2680 {
2681 return 88;
2682 }
2683 default:
2684 {
2685 return -1;
2686 }
2687 }
2688 return -1;
2689 }
2690 case 88:
2691 {
2692 System.Lex.Lexeme prevMatch = token.match;
2693 token.match = lexeme;
2694 int tokenId = GetTokenId(9);
2695 if (tokenId == CONTINUE_TOKEN)
2696 {
2697 token.id = CONTINUE_TOKEN;
2698 return -1;
2699 }
2700 else
2701 {
2702 if (tokenId != INVALID_TOKEN)
2703 {
2704 token.id = tokenId;
2705 }
2706 else
2707 {
2708 token.match = prevMatch;
2709 }
2710 }
2711 switch (i)
2712 {
2713 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2714 {
2715 return 72;
2716 }
2717 default:
2718 {
2719 return -1;
2720 }
2721 }
2722 return -1;
2723 }
2724 case 16:
2725 {
2726 System.Lex.Lexeme prevMatch = token.match;
2727 token.match = lexeme;
2728 int tokenId = GetTokenId(9);
2729 if (tokenId == CONTINUE_TOKEN)
2730 {
2731 token.id = CONTINUE_TOKEN;
2732 return -1;
2733 }
2734 else
2735 {
2736 if (tokenId != INVALID_TOKEN)
2737 {
2738 token.id = tokenId;
2739 }
2740 else
2741 {
2742 token.match = prevMatch;
2743 }
2744 }
2745 switch (i)
2746 {
2747 case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
2748 {
2749 return 72;
2750 }
2751 case 31:
2752 {
2753 return 87;
2754 }
2755 default:
2756 {
2757 return -1;
2758 }
2759 }
2760 return -1;
2761 }
2762 case 15:
2763 {
2764 System.Lex.Lexeme prevMatch = token.match;
2765 token.match = lexeme;
2766 int tokenId = GetTokenId(9);
2767 if (tokenId == CONTINUE_TOKEN)
2768 {
2769 token.id = CONTINUE_TOKEN;
2770 return -1;
2771 }
2772 else
2773 {
2774 if (tokenId != INVALID_TOKEN)
2775 {
2776 token.id = tokenId;
2777 }
2778 else
2779 {
2780 token.match = prevMatch;
2781 }
2782 }
2783 switch (i)
2784 {
2785 case 31:
2786 {
2787 return 52;
2788 }
2789 default:
2790 {
2791 return -1;
2792 }
2793 }
2794 return -1;
2795 }
2796 case 9:
2797 {
2798 System.Lex.Lexeme prevMatch = token.match;
2799 token.match = lexeme;
2800 int tokenId = GetTokenId(8);
2801 if (tokenId == CONTINUE_TOKEN)
2802 {
2803 token.id = CONTINUE_TOKEN;
2804 return -1;
2805 }
2806 else
2807 {
2808 if (tokenId != INVALID_TOKEN)
2809 {
2810 token.id = tokenId;
2811 }
2812 else
2813 {
2814 token.match = prevMatch;
2815 }
2816 }
2817 return -1;
2818 }
2819 case 8:
2820 {
2821 System.Lex.Lexeme prevMatch = token.match;
2822 token.match = lexeme;
2823 int tokenId = GetTokenId(7);
2824 if (tokenId == CONTINUE_TOKEN)
2825 {
2826 token.id = CONTINUE_TOKEN;
2827 return -1;
2828 }
2829 else
2830 {
2831 if (tokenId != INVALID_TOKEN)
2832 {
2833 token.id = tokenId;
2834 }
2835 else
2836 {
2837 token.match = prevMatch;
2838 }
2839 }
2840 return -1;
2841 }
2842 case 7:
2843 {
2844 System.Lex.Lexeme prevMatch = token.match;
2845 token.match = lexeme;
2846 int tokenId = GetTokenId(6);
2847 if (tokenId == CONTINUE_TOKEN)
2848 {
2849 token.id = CONTINUE_TOKEN;
2850 return -1;
2851 }
2852 else
2853 {
2854 if (tokenId != INVALID_TOKEN)
2855 {
2856 token.id = tokenId;
2857 }
2858 else
2859 {
2860 token.match = prevMatch;
2861 }
2862 }
2863 return -1;
2864 }
2865 case 6:
2866 {
2867 System.Lex.Lexeme prevMatch = token.match;
2868 token.match = lexeme;
2869 int tokenId = GetTokenId(5);
2870 if (tokenId == CONTINUE_TOKEN)
2871 {
2872 token.id = CONTINUE_TOKEN;
2873 return -1;
2874 }
2875 else
2876 {
2877 if (tokenId != INVALID_TOKEN)
2878 {
2879 token.id = tokenId;
2880 }
2881 else
2882 {
2883 token.match = prevMatch;
2884 }
2885 }
2886 return -1;
2887 }
2888 case 5:
2889 {
2890 System.Lex.Lexeme prevMatch = token.match;
2891 token.match = lexeme;
2892 int tokenId = GetTokenId(4);
2893 if (tokenId == CONTINUE_TOKEN)
2894 {
2895 token.id = CONTINUE_TOKEN;
2896 return -1;
2897 }
2898 else
2899 {
2900 if (tokenId != INVALID_TOKEN)
2901 {
2902 token.id = tokenId;
2903 }
2904 else
2905 {
2906 token.match = prevMatch;
2907 }
2908 }
2909 return -1;
2910 }
2911 case 4:
2912 {
2913 System.Lex.Lexeme prevMatch = token.match;
2914 token.match = lexeme;
2915 int tokenId = GetTokenId(3);
2916 if (tokenId == CONTINUE_TOKEN)
2917 {
2918 token.id = CONTINUE_TOKEN;
2919 return -1;
2920 }
2921 else
2922 {
2923 if (tokenId != INVALID_TOKEN)
2924 {
2925 token.id = tokenId;
2926 }
2927 else
2928 {
2929 token.match = prevMatch;
2930 }
2931 }
2932 return -1;
2933 }
2934 case 3:
2935 {
2936 System.Lex.Lexeme prevMatch = token.match;
2937 token.match = lexeme;
2938 int tokenId = GetTokenId(2);
2939 if (tokenId == CONTINUE_TOKEN)
2940 {
2941 token.id = CONTINUE_TOKEN;
2942 return -1;
2943 }
2944 else
2945 {
2946 if (tokenId != INVALID_TOKEN)
2947 {
2948 token.id = tokenId;
2949 }
2950 else
2951 {
2952 token.match = prevMatch;
2953 }
2954 }
2955 return -1;
2956 }
2957 case 2:
2958 {
2959 System.Lex.Lexeme prevMatch = token.match;
2960 token.match = lexeme;
2961 int tokenId = GetTokenId(1);
2962 if (tokenId == CONTINUE_TOKEN)
2963 {
2964 token.id = CONTINUE_TOKEN;
2965 return -1;
2966 }
2967 else
2968 {
2969 if (tokenId != INVALID_TOKEN)
2970 {
2971 token.id = tokenId;
2972 }
2973 else
2974 {
2975 token.match = prevMatch;
2976 }
2977 }
2978 return -1;
2979 }
2980 case 1:
2981 {
2982 System.Lex.Lexeme prevMatch = token.match;
2983 token.match = lexeme;
2984 int tokenId = GetTokenId(0);
2985 if (tokenId == CONTINUE_TOKEN)
2986 {
2987 token.id = CONTINUE_TOKEN;
2988 return -1;
2989 }
2990 else
2991 {
2992 if (tokenId != INVALID_TOKEN)
2993 {
2994 token.id = tokenId;
2995 }
2996 else
2997 {
2998 token.match = prevMatch;
2999 }
3000 }
3001 return -1;
3002 }
3003 }
3004 return -1;
3005 }
3006 private int GetTokenId(int statementIndex)
3007 {
3008 switch (statementIndex)
3009 {
3010 case 0:
3011 {
3012 Retract();
3013 return LPAREN;
3014 break;
3015 }
3016 case 1:
3017 {
3018 Retract();
3019 return RPAREN;
3020 break;
3021 }
3022 case 2:
3023 {
3024 Retract();
3025 return LBRACKET;
3026 break;
3027 }
3028 case 3:
3029 {
3030 Retract();
3031 return RBRACKET;
3032 break;
3033 }
3034 case 4:
3035 {
3036 Retract();
3037 return ALT;
3038 break;
3039 }
3040 case 5:
3041 {
3042 Retract();
3043 return STAR;
3044 break;
3045 }
3046 case 6:
3047 {
3048 Retract();
3049 return PLUS;
3050 break;
3051 }
3052 case 7:
3053 {
3054 Retract();
3055 return QUEST;
3056 break;
3057 }
3058 case 8:
3059 {
3060 Retract();
3061 return DOT;
3062 break;
3063 }
3064 case 9:
3065 {
3066 Retract();
3067 return ESCAPE;
3068 break;
3069 }
3070 case 10:
3071 {
3072 Retract();
3073 return INVERSE;
3074 break;
3075 }
3076 case 11:
3077 {
3078 Retract();
3079 return MINUS;
3080 break;
3081 }
3082 case 12:
3083 {
3084 Retract();
3085 return CHAR;
3086 break;
3087 }
3088 }
3089 return CONTINUE_TOKEN;
3090 }
3091 }