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