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