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