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