1 using System;
2 using System.Lex;
3 using AssemblyTokens;
4
5
6
7 public class AssemblyLexer : System.Lex.Lexer
8 {
9 public AssemblyLexer(const ustring& content_, const string& fileName_, int fileIndex_) :
10 base(content_, fileName_, fileIndex_)
11 {
12 AssemblyClassMap.Init();
13 }
14 public AssemblyLexer(const uchar* start_, const uchar* end_, const string& fileName_, int fileIndex_) :
15 base(start_, end_, fileName_, fileIndex_)
16 {
17 AssemblyClassMap.Init();
18 }
19 public override int NextState(int state, uchar c)
20 {
21 int i = AssemblyClassMap.GetClass(c);
22 switch (state)
23 {
24 case 0:
25 {
26 System.Lex.Lexeme prevMatch = token.match;
27 token.match = lexeme;
28 int tokenId = GetTokenId(28);
29 if (tokenId == CONTINUE_TOKEN)
30 {
31 token.id = CONTINUE_TOKEN;
32 return -1;
33 }
34 else
35 {
36 if (tokenId != INVALID_TOKEN)
37 {
38 token.id = tokenId;
39 }
40 else
41 {
42 token.match = prevMatch;
43 }
44 }
45 switch (i)
46 {
47 case 0:
48 {
49 return 1;
50 }
51 case 1:
52 {
53 return 2;
54 }
55 case 2:
56 {
57 return 3;
58 }
59 case 3:
60 {
61 return 4;
62 }
63 case 4: case 11: case 12: case 13: case 15: case 16: case 17:
64 {
65 return 5;
66 }
67 case 5: case 9:
68 {
69 return 6;
70 }
71 case 6: case 7:
72 {
73 return 7;
74 }
75 case 8:
76 {
77 return 8;
78 }
79 case 10:
80 {
81 return 9;
82 }
83 case 14:
84 {
85 return 10;
86 }
87 case 18:
88 {
89 return 11;
90 }
91 case 19:
92 {
93 return 12;
94 }
95 case 20:
96 {
97 return 13;
98 }
99 case 21:
100 {
101 return 14;
102 }
103 case 22:
104 {
105 return 15;
106 }
107 case 23:
108 {
109 return 16;
110 }
111 case 24:
112 {
113 return 17;
114 }
115 case 25:
116 {
117 return 18;
118 }
119 case 26:
120 {
121 return 19;
122 }
123 case 27:
124 {
125 return 20;
126 }
127 case 28:
128 {
129 return 21;
130 }
131 case 29:
132 {
133 return 22;
134 }
135 case 30:
136 {
137 return 23;
138 }
139 case 31:
140 {
141 return 24;
142 }
143 case 32:
144 {
145 return 25;
146 }
147 case 33:
148 {
149 return 26;
150 }
151 case 34:
152 {
153 return 27;
154 }
155 case 35:
156 {
157 return 28;
158 }
159 case 36:
160 {
161 return 29;
162 }
163 default:
164 {
165 return -1;
166 }
167 }
168 return -1;
169 }
170 case 29:
171 {
172 System.Lex.Lexeme prevMatch = token.match;
173 token.match = lexeme;
174 int tokenId = GetTokenId(27);
175 if (tokenId == CONTINUE_TOKEN)
176 {
177 token.id = CONTINUE_TOKEN;
178 return -1;
179 }
180 else
181 {
182 if (tokenId != INVALID_TOKEN)
183 {
184 token.id = tokenId;
185 }
186 else
187 {
188 token.match = prevMatch;
189 }
190 }
191 return -1;
192 }
193 case 28:
194 {
195 System.Lex.Lexeme prevMatch = token.match;
196 token.match = lexeme;
197 int tokenId = GetTokenId(26);
198 if (tokenId == CONTINUE_TOKEN)
199 {
200 token.id = CONTINUE_TOKEN;
201 return -1;
202 }
203 else
204 {
205 if (tokenId != INVALID_TOKEN)
206 {
207 token.id = tokenId;
208 }
209 else
210 {
211 token.match = prevMatch;
212 }
213 }
214 return -1;
215 }
216 case 27:
217 {
218 System.Lex.Lexeme prevMatch = token.match;
219 token.match = lexeme;
220 int tokenId = GetTokenId(23);
221 if (tokenId == CONTINUE_TOKEN)
222 {
223 token.id = CONTINUE_TOKEN;
224 return -1;
225 }
226 else
227 {
228 if (tokenId != INVALID_TOKEN)
229 {
230 token.id = tokenId;
231 }
232 else
233 {
234 token.match = prevMatch;
235 }
236 }
237 return -1;
238 }
239 case 26:
240 {
241 System.Lex.Lexeme prevMatch = token.match;
242 token.match = lexeme;
243 int tokenId = GetTokenId(22);
244 if (tokenId == CONTINUE_TOKEN)
245 {
246 token.id = CONTINUE_TOKEN;
247 return -1;
248 }
249 else
250 {
251 if (tokenId != INVALID_TOKEN)
252 {
253 token.id = tokenId;
254 }
255 else
256 {
257 token.match = prevMatch;
258 }
259 }
260 return -1;
261 }
262 case 25:
263 {
264 System.Lex.Lexeme prevMatch = token.match;
265 token.match = lexeme;
266 int tokenId = GetTokenId(21);
267 if (tokenId == CONTINUE_TOKEN)
268 {
269 token.id = CONTINUE_TOKEN;
270 return -1;
271 }
272 else
273 {
274 if (tokenId != INVALID_TOKEN)
275 {
276 token.id = tokenId;
277 }
278 else
279 {
280 token.match = prevMatch;
281 }
282 }
283 return -1;
284 }
285 case 24:
286 {
287 System.Lex.Lexeme prevMatch = token.match;
288 token.match = lexeme;
289 int tokenId = GetTokenId(28);
290 if (tokenId == CONTINUE_TOKEN)
291 {
292 token.id = CONTINUE_TOKEN;
293 return -1;
294 }
295 else
296 {
297 if (tokenId != INVALID_TOKEN)
298 {
299 token.id = tokenId;
300 }
301 else
302 {
303 token.match = prevMatch;
304 }
305 }
306 switch (i)
307 {
308 case 31:
309 {
310 return 30;
311 }
312 default:
313 {
314 return -1;
315 }
316 }
317 return -1;
318 }
319 case 30:
320 {
321 System.Lex.Lexeme prevMatch = token.match;
322 token.match = lexeme;
323 int tokenId = GetTokenId(20);
324 if (tokenId == CONTINUE_TOKEN)
325 {
326 token.id = CONTINUE_TOKEN;
327 return -1;
328 }
329 else
330 {
331 if (tokenId != INVALID_TOKEN)
332 {
333 token.id = tokenId;
334 }
335 else
336 {
337 token.match = prevMatch;
338 }
339 }
340 return -1;
341 }
342 case 23:
343 {
344 System.Lex.Lexeme prevMatch = token.match;
345 token.match = lexeme;
346 int tokenId = GetTokenId(28);
347 if (tokenId == CONTINUE_TOKEN)
348 {
349 token.id = CONTINUE_TOKEN;
350 return -1;
351 }
352 else
353 {
354 if (tokenId != INVALID_TOKEN)
355 {
356 token.id = tokenId;
357 }
358 else
359 {
360 token.match = prevMatch;
361 }
362 }
363 switch (i)
364 {
365 case 30:
366 {
367 return 31;
368 }
369 default:
370 {
371 return -1;
372 }
373 }
374 return -1;
375 }
376 case 31:
377 {
378 System.Lex.Lexeme prevMatch = token.match;
379 token.match = lexeme;
380 int tokenId = GetTokenId(19);
381 if (tokenId == CONTINUE_TOKEN)
382 {
383 token.id = CONTINUE_TOKEN;
384 return -1;
385 }
386 else
387 {
388 if (tokenId != INVALID_TOKEN)
389 {
390 token.id = tokenId;
391 }
392 else
393 {
394 token.match = prevMatch;
395 }
396 }
397 return -1;
398 }
399 case 22:
400 {
401 System.Lex.Lexeme prevMatch = token.match;
402 token.match = lexeme;
403 int tokenId = GetTokenId(18);
404 if (tokenId == CONTINUE_TOKEN)
405 {
406 token.id = CONTINUE_TOKEN;
407 return -1;
408 }
409 else
410 {
411 if (tokenId != INVALID_TOKEN)
412 {
413 token.id = tokenId;
414 }
415 else
416 {
417 token.match = prevMatch;
418 }
419 }
420 return -1;
421 }
422 case 21:
423 {
424 System.Lex.Lexeme prevMatch = token.match;
425 token.match = lexeme;
426 int tokenId = GetTokenId(17);
427 if (tokenId == CONTINUE_TOKEN)
428 {
429 token.id = CONTINUE_TOKEN;
430 return -1;
431 }
432 else
433 {
434 if (tokenId != INVALID_TOKEN)
435 {
436 token.id = tokenId;
437 }
438 else
439 {
440 token.match = prevMatch;
441 }
442 }
443 switch (i)
444 {
445 case 28:
446 {
447 return 32;
448 }
449 default:
450 {
451 return -1;
452 }
453 }
454 return -1;
455 }
456 case 32:
457 {
458 System.Lex.Lexeme prevMatch = token.match;
459 token.match = lexeme;
460 int tokenId = GetTokenId(16);
461 if (tokenId == CONTINUE_TOKEN)
462 {
463 token.id = CONTINUE_TOKEN;
464 return -1;
465 }
466 else
467 {
468 if (tokenId != INVALID_TOKEN)
469 {
470 token.id = tokenId;
471 }
472 else
473 {
474 token.match = prevMatch;
475 }
476 }
477 return -1;
478 }
479 case 20:
480 {
481 System.Lex.Lexeme prevMatch = token.match;
482 token.match = lexeme;
483 int tokenId = GetTokenId(15);
484 if (tokenId == CONTINUE_TOKEN)
485 {
486 token.id = CONTINUE_TOKEN;
487 return -1;
488 }
489 else
490 {
491 if (tokenId != INVALID_TOKEN)
492 {
493 token.id = tokenId;
494 }
495 else
496 {
497 token.match = prevMatch;
498 }
499 }
500 return -1;
501 }
502 case 19:
503 {
504 System.Lex.Lexeme prevMatch = token.match;
505 token.match = lexeme;
506 int tokenId = GetTokenId(14);
507 if (tokenId == CONTINUE_TOKEN)
508 {
509 token.id = CONTINUE_TOKEN;
510 return -1;
511 }
512 else
513 {
514 if (tokenId != INVALID_TOKEN)
515 {
516 token.id = tokenId;
517 }
518 else
519 {
520 token.match = prevMatch;
521 }
522 }
523 return -1;
524 }
525 case 18:
526 {
527 System.Lex.Lexeme prevMatch = token.match;
528 token.match = lexeme;
529 int tokenId = GetTokenId(12);
530 if (tokenId == CONTINUE_TOKEN)
531 {
532 token.id = CONTINUE_TOKEN;
533 return -1;
534 }
535 else
536 {
537 if (tokenId != INVALID_TOKEN)
538 {
539 token.id = tokenId;
540 }
541 else
542 {
543 token.match = prevMatch;
544 }
545 }
546 return -1;
547 }
548 case 17:
549 {
550 System.Lex.Lexeme prevMatch = token.match;
551 token.match = lexeme;
552 int tokenId = GetTokenId(11);
553 if (tokenId == CONTINUE_TOKEN)
554 {
555 token.id = CONTINUE_TOKEN;
556 return -1;
557 }
558 else
559 {
560 if (tokenId != INVALID_TOKEN)
561 {
562 token.id = tokenId;
563 }
564 else
565 {
566 token.match = prevMatch;
567 }
568 }
569 return -1;
570 }
571 case 16:
572 {
573 System.Lex.Lexeme prevMatch = token.match;
574 token.match = lexeme;
575 int tokenId = GetTokenId(10);
576 if (tokenId == CONTINUE_TOKEN)
577 {
578 token.id = CONTINUE_TOKEN;
579 return -1;
580 }
581 else
582 {
583 if (tokenId != INVALID_TOKEN)
584 {
585 token.id = tokenId;
586 }
587 else
588 {
589 token.match = prevMatch;
590 }
591 }
592 return -1;
593 }
594 case 15:
595 {
596 System.Lex.Lexeme prevMatch = token.match;
597 token.match = lexeme;
598 int tokenId = GetTokenId(8);
599 if (tokenId == CONTINUE_TOKEN)
600 {
601 token.id = CONTINUE_TOKEN;
602 return -1;
603 }
604 else
605 {
606 if (tokenId != INVALID_TOKEN)
607 {
608 token.id = tokenId;
609 }
610 else
611 {
612 token.match = prevMatch;
613 }
614 }
615 switch (i)
616 {
617 case 4: case 5: case 11: case 12: case 13: case 15: case 16: case 17: case 20:
618 {
619 return 33;
620 }
621 case 19:
622 {
623 return 34;
624 }
625 case 21:
626 {
627 return 35;
628 }
629 case 22:
630 {
631 return 36;
632 }
633 default:
634 {
635 return -1;
636 }
637 }
638 return -1;
639 }
640 case 36:
641 {
642 System.Lex.Lexeme prevMatch = token.match;
643 token.match = lexeme;
644 int tokenId = GetTokenId(8);
645 if (tokenId == CONTINUE_TOKEN)
646 {
647 token.id = CONTINUE_TOKEN;
648 return -1;
649 }
650 else
651 {
652 if (tokenId != INVALID_TOKEN)
653 {
654 token.id = tokenId;
655 }
656 else
657 {
658 token.match = prevMatch;
659 }
660 }
661 switch (i)
662 {
663 case 4: case 5: case 11: case 12: case 13: case 15: case 16: case 17: case 20:
664 {
665 return 33;
666 }
667 case 19:
668 {
669 return 34;
670 }
671 case 21:
672 {
673 return 35;
674 }
675 case 22:
676 {
677 return 36;
678 }
679 default:
680 {
681 return -1;
682 }
683 }
684 return -1;
685 }
686 case 35:
687 {
688 System.Lex.Lexeme prevMatch = token.match;
689 token.match = lexeme;
690 int tokenId = GetTokenId(8);
691 if (tokenId == CONTINUE_TOKEN)
692 {
693 token.id = CONTINUE_TOKEN;
694 return -1;
695 }
696 else
697 {
698 if (tokenId != INVALID_TOKEN)
699 {
700 token.id = tokenId;
701 }
702 else
703 {
704 token.match = prevMatch;
705 }
706 }
707 switch (i)
708 {
709 case 4: case 5: case 11: case 12: case 13: case 15: case 16: case 17: case 20:
710 {
711 return 33;
712 }
713 case 19:
714 {
715 return 34;
716 }
717 case 21:
718 {
719 return 35;
720 }
721 case 22:
722 {
723 return 36;
724 }
725 default:
726 {
727 return -1;
728 }
729 }
730 return -1;
731 }
732 case 34:
733 {
734 System.Lex.Lexeme prevMatch = token.match;
735 token.match = lexeme;
736 int tokenId = GetTokenId(8);
737 if (tokenId == CONTINUE_TOKEN)
738 {
739 token.id = CONTINUE_TOKEN;
740 return -1;
741 }
742 else
743 {
744 if (tokenId != INVALID_TOKEN)
745 {
746 token.id = tokenId;
747 }
748 else
749 {
750 token.match = prevMatch;
751 }
752 }
753 switch (i)
754 {
755 case 4: case 5: case 11: case 12: case 13: case 15: case 16: case 17: case 20:
756 {
757 return 33;
758 }
759 case 19:
760 {
761 return 34;
762 }
763 case 21:
764 {
765 return 35;
766 }
767 case 22:
768 {
769 return 36;
770 }
771 default:
772 {
773 return -1;
774 }
775 }
776 return -1;
777 }
778 case 33:
779 {
780 System.Lex.Lexeme prevMatch = token.match;
781 token.match = lexeme;
782 int tokenId = GetTokenId(8);
783 if (tokenId == CONTINUE_TOKEN)
784 {
785 token.id = CONTINUE_TOKEN;
786 return -1;
787 }
788 else
789 {
790 if (tokenId != INVALID_TOKEN)
791 {
792 token.id = tokenId;
793 }
794 else
795 {
796 token.match = prevMatch;
797 }
798 }
799 switch (i)
800 {
801 case 4: case 5: case 11: case 12: case 13: case 15: case 16: case 17: case 20:
802 {
803 return 33;
804 }
805 case 19:
806 {
807 return 34;
808 }
809 case 21:
810 {
811 return 35;
812 }
813 case 22:
814 {
815 return 36;
816 }
817 default:
818 {
819 return -1;
820 }
821 }
822 return -1;
823 }
824 case 14:
825 {
826 System.Lex.Lexeme prevMatch = token.match;
827 token.match = lexeme;
828 int tokenId = GetTokenId(8);
829 if (tokenId == CONTINUE_TOKEN)
830 {
831 token.id = CONTINUE_TOKEN;
832 return -1;
833 }
834 else
835 {
836 if (tokenId != INVALID_TOKEN)
837 {
838 token.id = tokenId;
839 }
840 else
841 {
842 token.match = prevMatch;
843 }
844 }
845 switch (i)
846 {
847 case 4: case 5: case 11: case 12: case 13: case 15: case 16: case 17: case 20:
848 {
849 return 33;
850 }
851 case 19:
852 {
853 return 34;
854 }
855 case 21:
856 {
857 return 35;
858 }
859 case 22:
860 {
861 return 36;
862 }
863 default:
864 {
865 return -1;
866 }
867 }
868 return -1;
869 }
870 case 13:
871 {
872 System.Lex.Lexeme prevMatch = token.match;
873 token.match = lexeme;
874 int tokenId = GetTokenId(2);
875 if (tokenId == CONTINUE_TOKEN)
876 {
877 token.id = CONTINUE_TOKEN;
878 return -1;
879 }
880 else
881 {
882 if (tokenId != INVALID_TOKEN)
883 {
884 token.id = tokenId;
885 }
886 else
887 {
888 token.match = prevMatch;
889 }
890 }
891 switch (i)
892 {
893 case 20:
894 {
895 return 37;
896 }
897 default:
898 {
899 return -1;
900 }
901 }
902 return -1;
903 }
904 case 37:
905 {
906 System.Lex.Lexeme prevMatch = token.match;
907 token.match = lexeme;
908 int tokenId = GetTokenId(2);
909 if (tokenId == CONTINUE_TOKEN)
910 {
911 token.id = CONTINUE_TOKEN;
912 return -1;
913 }
914 else
915 {
916 if (tokenId != INVALID_TOKEN)
917 {
918 token.id = tokenId;
919 }
920 else
921 {
922 token.match = prevMatch;
923 }
924 }
925 switch (i)
926 {
927 case 20:
928 {
929 return 37;
930 }
931 default:
932 {
933 return -1;
934 }
935 }
936 return -1;
937 }
938 case 12:
939 {
940 System.Lex.Lexeme prevMatch = token.match;
941 token.match = lexeme;
942 int tokenId = GetTokenId(9);
943 if (tokenId == CONTINUE_TOKEN)
944 {
945 token.id = CONTINUE_TOKEN;
946 return -1;
947 }
948 else
949 {
950 if (tokenId != INVALID_TOKEN)
951 {
952 token.id = tokenId;
953 }
954 else
955 {
956 token.match = prevMatch;
957 }
958 }
959 switch (i)
960 {
961 case 20:
962 {
963 return 38;
964 }
965 default:
966 {
967 return -1;
968 }
969 }
970 return -1;
971 }
972 case 38:
973 {
974 System.Lex.Lexeme prevMatch = token.match;
975 token.match = lexeme;
976 int tokenId = GetTokenId(7);
977 if (tokenId == CONTINUE_TOKEN)
978 {
979 token.id = CONTINUE_TOKEN;
980 return -1;
981 }
982 else
983 {
984 if (tokenId != INVALID_TOKEN)
985 {
986 token.id = tokenId;
987 }
988 else
989 {
990 token.match = prevMatch;
991 }
992 }
993 switch (i)
994 {
995 case 20:
996 {
997 return 38;
998 }
999 default:
1000 {
1001 return -1;
1002 }
1003 }
1004 return -1;
1005 }
1006 case 11:
1007 {
1008 System.Lex.Lexeme prevMatch = token.match;
1009 token.match = lexeme;
1010 int tokenId = GetTokenId(25);
1011 if (tokenId == CONTINUE_TOKEN)
1012 {
1013 token.id = CONTINUE_TOKEN;
1014 return -1;
1015 }
1016 else
1017 {
1018 if (tokenId != INVALID_TOKEN)
1019 {
1020 token.id = tokenId;
1021 }
1022 else
1023 {
1024 token.match = prevMatch;
1025 }
1026 }
1027 return -1;
1028 }
1029 case 10:
1030 {
1031 System.Lex.Lexeme prevMatch = token.match;
1032 token.match = lexeme;
1033 int tokenId = GetTokenId(24);
1034 if (tokenId == CONTINUE_TOKEN)
1035 {
1036 token.id = CONTINUE_TOKEN;
1037 return -1;
1038 }
1039 else
1040 {
1041 if (tokenId != INVALID_TOKEN)
1042 {
1043 token.id = tokenId;
1044 }
1045 else
1046 {
1047 token.match = prevMatch;
1048 }
1049 }
1050 return -1;
1051 }
1052 case 9:
1053 {
1054 System.Lex.Lexeme prevMatch = token.match;
1055 token.match = lexeme;
1056 int tokenId = GetTokenId(13);
1057 if (tokenId == CONTINUE_TOKEN)
1058 {
1059 token.id = CONTINUE_TOKEN;
1060 return -1;
1061 }
1062 else
1063 {
1064 if (tokenId != INVALID_TOKEN)
1065 {
1066 token.id = tokenId;
1067 }
1068 else
1069 {
1070 token.match = prevMatch;
1071 }
1072 }
1073 switch (i)
1074 {
1075 case 16:
1076 {
1077 return 39;
1078 }
1079 default:
1080 {
1081 return -1;
1082 }
1083 }
1084 return -1;
1085 }
1086 case 39:
1087 {
1088 switch (i)
1089 {
1090 case 11:
1091 {
1092 return 40;
1093 }
1094 default:
1095 {
1096 return -1;
1097 }
1098 }
1099 return -1;
1100 }
1101 case 40:
1102 {
1103 switch (i)
1104 {
1105 case 12:
1106 {
1107 return 41;
1108 }
1109 default:
1110 {
1111 return -1;
1112 }
1113 }
1114 return -1;
1115 }
1116 case 41:
1117 {
1118 switch (i)
1119 {
1120 case 13:
1121 {
1122 return 42;
1123 }
1124 default:
1125 {
1126 return -1;
1127 }
1128 }
1129 return -1;
1130 }
1131 case 42:
1132 {
1133 switch (i)
1134 {
1135 case 17:
1136 {
1137 return 43;
1138 }
1139 default:
1140 {
1141 return -1;
1142 }
1143 }
1144 return -1;
1145 }
1146 case 43:
1147 {
1148 switch (i)
1149 {
1150 case 14:
1151 {
1152 return 44;
1153 }
1154 default:
1155 {
1156 return -1;
1157 }
1158 }
1159 return -1;
1160 }
1161 case 44:
1162 {
1163 switch (i)
1164 {
1165 case 15: case 16: case 17: case 20:
1166 {
1167 return 45;
1168 }
1169 default:
1170 {
1171 return -1;
1172 }
1173 }
1174 return -1;
1175 }
1176 case 45:
1177 {
1178 switch (i)
1179 {
1180 case 15: case 16: case 17: case 20:
1181 {
1182 return 45;
1183 }
1184 case 18:
1185 {
1186 return 46;
1187 }
1188 default:
1189 {
1190 return -1;
1191 }
1192 }
1193 return -1;
1194 }
1195 case 46:
1196 {
1197 System.Lex.Lexeme prevMatch = token.match;
1198 token.match = lexeme;
1199 int tokenId = GetTokenId(6);
1200 if (tokenId == CONTINUE_TOKEN)
1201 {
1202 token.id = CONTINUE_TOKEN;
1203 return -1;
1204 }
1205 else
1206 {
1207 if (tokenId != INVALID_TOKEN)
1208 {
1209 token.id = tokenId;
1210 }
1211 else
1212 {
1213 token.match = prevMatch;
1214 }
1215 }
1216 return -1;
1217 }
1218 case 8:
1219 {
1220 System.Lex.Lexeme prevMatch = token.match;
1221 token.match = lexeme;
1222 int tokenId = GetTokenId(28);
1223 if (tokenId == CONTINUE_TOKEN)
1224 {
1225 token.id = CONTINUE_TOKEN;
1226 return -1;
1227 }
1228 else
1229 {
1230 if (tokenId != INVALID_TOKEN)
1231 {
1232 token.id = tokenId;
1233 }
1234 else
1235 {
1236 token.match = prevMatch;
1237 }
1238 }
1239 switch (i)
1240 {
1241 case 15: case 16: case 17: case 20:
1242 {
1243 return 47;
1244 }
1245 default:
1246 {
1247 return -1;
1248 }
1249 }
1250 return -1;
1251 }
1252 case 47:
1253 {
1254 System.Lex.Lexeme prevMatch = token.match;
1255 token.match = lexeme;
1256 int tokenId = GetTokenId(3);
1257 if (tokenId == CONTINUE_TOKEN)
1258 {
1259 token.id = CONTINUE_TOKEN;
1260 return -1;
1261 }
1262 else
1263 {
1264 if (tokenId != INVALID_TOKEN)
1265 {
1266 token.id = tokenId;
1267 }
1268 else
1269 {
1270 token.match = prevMatch;
1271 }
1272 }
1273 switch (i)
1274 {
1275 case 15: case 16: case 17: case 20:
1276 {
1277 return 47;
1278 }
1279 default:
1280 {
1281 return -1;
1282 }
1283 }
1284 return -1;
1285 }
1286 case 7:
1287 {
1288 System.Lex.Lexeme prevMatch = token.match;
1289 token.match = lexeme;
1290 int tokenId = GetTokenId(0);
1291 if (tokenId == CONTINUE_TOKEN)
1292 {
1293 token.id = CONTINUE_TOKEN;
1294 return -1;
1295 }
1296 else
1297 {
1298 if (tokenId != INVALID_TOKEN)
1299 {
1300 token.id = tokenId;
1301 }
1302 else
1303 {
1304 token.match = prevMatch;
1305 }
1306 }
1307 switch (i)
1308 {
1309 case 6: case 7:
1310 {
1311 return 48;
1312 }
1313 default:
1314 {
1315 return -1;
1316 }
1317 }
1318 return -1;
1319 }
1320 case 48:
1321 {
1322 System.Lex.Lexeme prevMatch = token.match;
1323 token.match = lexeme;
1324 int tokenId = GetTokenId(0);
1325 if (tokenId == CONTINUE_TOKEN)
1326 {
1327 token.id = CONTINUE_TOKEN;
1328 return -1;
1329 }
1330 else
1331 {
1332 if (tokenId != INVALID_TOKEN)
1333 {
1334 token.id = tokenId;
1335 }
1336 else
1337 {
1338 token.match = prevMatch;
1339 }
1340 }
1341 switch (i)
1342 {
1343 case 6: case 7:
1344 {
1345 return 48;
1346 }
1347 default:
1348 {
1349 return -1;
1350 }
1351 }
1352 return -1;
1353 }
1354 case 6:
1355 {
1356 System.Lex.Lexeme prevMatch = token.match;
1357 token.match = lexeme;
1358 int tokenId = GetTokenId(28);
1359 if (tokenId == CONTINUE_TOKEN)
1360 {
1361 token.id = CONTINUE_TOKEN;
1362 return -1;
1363 }
1364 else
1365 {
1366 if (tokenId != INVALID_TOKEN)
1367 {
1368 token.id = tokenId;
1369 }
1370 else
1371 {
1372 token.match = prevMatch;
1373 }
1374 }
1375 return -1;
1376 }
1377 case 5:
1378 {
1379 System.Lex.Lexeme prevMatch = token.match;
1380 token.match = lexeme;
1381 int tokenId = GetTokenId(8);
1382 if (tokenId == CONTINUE_TOKEN)
1383 {
1384 token.id = CONTINUE_TOKEN;
1385 return -1;
1386 }
1387 else
1388 {
1389 if (tokenId != INVALID_TOKEN)
1390 {
1391 token.id = tokenId;
1392 }
1393 else
1394 {
1395 token.match = prevMatch;
1396 }
1397 }
1398 switch (i)
1399 {
1400 case 4: case 5: case 11: case 12: case 13: case 15: case 16: case 17: case 20:
1401 {
1402 return 33;
1403 }
1404 case 19:
1405 {
1406 return 34;
1407 }
1408 case 21:
1409 {
1410 return 35;
1411 }
1412 case 22:
1413 {
1414 return 36;
1415 }
1416 default:
1417 {
1418 return -1;
1419 }
1420 }
1421 return -1;
1422 }
1423 case 4:
1424 {
1425 System.Lex.Lexeme prevMatch = token.match;
1426 token.match = lexeme;
1427 int tokenId = GetTokenId(28);
1428 if (tokenId == CONTINUE_TOKEN)
1429 {
1430 token.id = CONTINUE_TOKEN;
1431 return -1;
1432 }
1433 else
1434 {
1435 if (tokenId != INVALID_TOKEN)
1436 {
1437 token.id = tokenId;
1438 }
1439 else
1440 {
1441 token.match = prevMatch;
1442 }
1443 }
1444 switch (i)
1445 {
1446 case 2: 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 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: case 33: case 34: case 35: case 36:
1447 {
1448 return 49;
1449 }
1450 case 3:
1451 {
1452 return 50;
1453 }
1454 default:
1455 {
1456 return -1;
1457 }
1458 }
1459 return -1;
1460 }
1461 case 50:
1462 {
1463 System.Lex.Lexeme prevMatch = token.match;
1464 token.match = lexeme;
1465 int tokenId = GetTokenId(4);
1466 if (tokenId == CONTINUE_TOKEN)
1467 {
1468 token.id = CONTINUE_TOKEN;
1469 return -1;
1470 }
1471 else
1472 {
1473 if (tokenId != INVALID_TOKEN)
1474 {
1475 token.id = tokenId;
1476 }
1477 else
1478 {
1479 token.match = prevMatch;
1480 }
1481 }
1482 return -1;
1483 }
1484 case 49:
1485 {
1486 switch (i)
1487 {
1488 case 3:
1489 {
1490 return 50;
1491 }
1492 default:
1493 {
1494 return -1;
1495 }
1496 }
1497 return -1;
1498 }
1499 case 3:
1500 {
1501 System.Lex.Lexeme prevMatch = token.match;
1502 token.match = lexeme;
1503 int tokenId = GetTokenId(28);
1504 if (tokenId == CONTINUE_TOKEN)
1505 {
1506 token.id = CONTINUE_TOKEN;
1507 return -1;
1508 }
1509 else
1510 {
1511 if (tokenId != INVALID_TOKEN)
1512 {
1513 token.id = tokenId;
1514 }
1515 else
1516 {
1517 token.match = prevMatch;
1518 }
1519 }
1520 switch (i)
1521 {
1522 case 2:
1523 {
1524 return 51;
1525 }
1526 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 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: case 33: case 34: case 35: case 36:
1527 {
1528 return 52;
1529 }
1530 default:
1531 {
1532 return -1;
1533 }
1534 }
1535 return -1;
1536 }
1537 case 52:
1538 {
1539 switch (i)
1540 {
1541 case 2:
1542 {
1543 return 51;
1544 }
1545 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 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: case 33: case 34: case 35: case 36:
1546 {
1547 return 52;
1548 }
1549 default:
1550 {
1551 return -1;
1552 }
1553 }
1554 return -1;
1555 }
1556 case 51:
1557 {
1558 System.Lex.Lexeme prevMatch = token.match;
1559 token.match = lexeme;
1560 int tokenId = GetTokenId(5);
1561 if (tokenId == CONTINUE_TOKEN)
1562 {
1563 token.id = CONTINUE_TOKEN;
1564 return -1;
1565 }
1566 else
1567 {
1568 if (tokenId != INVALID_TOKEN)
1569 {
1570 token.id = tokenId;
1571 }
1572 else
1573 {
1574 token.match = prevMatch;
1575 }
1576 }
1577 return -1;
1578 }
1579 case 2:
1580 {
1581 System.Lex.Lexeme prevMatch = token.match;
1582 token.match = lexeme;
1583 int tokenId = GetTokenId(1);
1584 if (tokenId == CONTINUE_TOKEN)
1585 {
1586 token.id = CONTINUE_TOKEN;
1587 return -1;
1588 }
1589 else
1590 {
1591 if (tokenId != INVALID_TOKEN)
1592 {
1593 token.id = tokenId;
1594 }
1595 else
1596 {
1597 token.match = prevMatch;
1598 }
1599 }
1600 return -1;
1601 }
1602 case 1:
1603 {
1604 System.Lex.Lexeme prevMatch = token.match;
1605 token.match = lexeme;
1606 int tokenId = GetTokenId(1);
1607 if (tokenId == CONTINUE_TOKEN)
1608 {
1609 token.id = CONTINUE_TOKEN;
1610 return -1;
1611 }
1612 else
1613 {
1614 if (tokenId != INVALID_TOKEN)
1615 {
1616 token.id = tokenId;
1617 }
1618 else
1619 {
1620 token.match = prevMatch;
1621 }
1622 }
1623 switch (i)
1624 {
1625 case 1:
1626 {
1627 return 53;
1628 }
1629 default:
1630 {
1631 return -1;
1632 }
1633 }
1634 return -1;
1635 }
1636 case 53:
1637 {
1638 System.Lex.Lexeme prevMatch = token.match;
1639 token.match = lexeme;
1640 int tokenId = GetTokenId(1);
1641 if (tokenId == CONTINUE_TOKEN)
1642 {
1643 token.id = CONTINUE_TOKEN;
1644 return -1;
1645 }
1646 else
1647 {
1648 if (tokenId != INVALID_TOKEN)
1649 {
1650 token.id = tokenId;
1651 }
1652 else
1653 {
1654 token.match = prevMatch;
1655 }
1656 }
1657 return -1;
1658 }
1659 }
1660 return -1;
1661 }
1662 private int GetTokenId(int statementIndex)
1663 {
1664 switch (statementIndex)
1665 {
1666 case 0:
1667 {
1668 Retract();
1669 return SPACE;
1670 break;
1671 }
1672 case 1:
1673 {
1674 Retract();
1675 return NEWLINE;
1676 break;
1677 }
1678 case 2:
1679 {
1680 Retract();
1681 return DECIMAL_CONSTANT;
1682 break;
1683 }
1684 case 3:
1685 {
1686 Retract();
1687 return HEX_CONSTANT;
1688 break;
1689 }
1690 case 4:
1691 {
1692 Retract();
1693 return CHAR_CONSTANT;
1694 break;
1695 }
1696 case 5:
1697 {
1698 Retract();
1699 return STRING_CONSTANT;
1700 break;
1701 }
1702 case 6:
1703 {
1704 Retract();
1705 return CLSID_CONSTANT;
1706 break;
1707 }
1708 case 7:
1709 {
1710 Retract();
1711 return LOCAL_SYMBOL;
1712 break;
1713 }
1714 case 8:
1715 {
1716 Retract();
1717 return SYMBOL;
1718 break;
1719 }
1720 case 9:
1721 {
1722 Retract();
1723 return AT;
1724 break;
1725 }
1726 case 10:
1727 {
1728 Retract();
1729 return PLUS;
1730 break;
1731 }
1732 case 11:
1733 {
1734 Retract();
1735 return MINUS;
1736 break;
1737 }
1738 case 12:
1739 {
1740 Retract();
1741 return TILDE;
1742 break;
1743 }
1744 case 13:
1745 {
1746 Retract();
1747 return DOLLAR;
1748 break;
1749 }
1750 case 14:
1751 {
1752 Retract();
1753 return AMP;
1754 break;
1755 }
1756 case 15:
1757 {
1758 Retract();
1759 return AST;
1760 break;
1761 }
1762 case 16:
1763 {
1764 Retract();
1765 return SLASHSLASH;
1766 break;
1767 }
1768 case 17:
1769 {
1770 Retract();
1771 return SLASH;
1772 break;
1773 }
1774 case 18:
1775 {
1776 Retract();
1777 return PERCENT;
1778 break;
1779 }
1780 case 19:
1781 {
1782 Retract();
1783 return SHIFT_LEFT;
1784 break;
1785 }
1786 case 20:
1787 {
1788 Retract();
1789 return SHIFT_RIGHT;
1790 break;
1791 }
1792 case 21:
1793 {
1794 Retract();
1795 return BAR;
1796 break;
1797 }
1798 case 22:
1799 {
1800 Retract();
1801 return CARET;
1802 break;
1803 }
1804 case 23:
1805 {
1806 Retract();
1807 return DOT;
1808 break;
1809 }
1810 case 24:
1811 {
1812 Retract();
1813 return LPAREN;
1814 break;
1815 }
1816 case 25:
1817 {
1818 Retract();
1819 return RPAREN;
1820 break;
1821 }
1822 case 26:
1823 {
1824 Retract();
1825 return SEMICOLON;
1826 break;
1827 }
1828 case 27:
1829 {
1830 Retract();
1831 return COMMA;
1832 break;
1833 }
1834 case 28:
1835 {
1836 Retract();
1837 return CHAR;
1838 break;
1839 }
1840 }
1841 return CONTINUE_TOKEN;
1842 }
1843 }