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