1 using System;
2 using System.Lex;
3 using ProjectFileTokens;
4
5
6
7 public class ProjectFileLexer : System.Lex.Lexer
8 {
9 public ProjectFileLexer(const ustring& content_, const string& fileName_, int fileIndex_) :
10 base(content_, fileName_, fileIndex_), filePath()
11 {
12 SetKeywordMap(ProjectFileKeywords.GetKeywordMap());
13 ProjectFileClassMap.Init();
14 }
15 public ProjectFileLexer(const uchar* start_, const uchar* end_, const string& fileName_, int fileIndex_) :
16 base(start_, end_, fileName_, fileIndex_), filePath()
17 {
18 SetKeywordMap(ProjectFileKeywords.GetKeywordMap());
19 ProjectFileClassMap.Init();
20 }
21 public override int NextState(int state, uchar c)
22 {
23 int i = ProjectFileClassMap.GetClass(c);
24 switch (state)
25 {
26 case 0:
27 {
28 switch (i)
29 {
30 case 0: case 3: case 6: case 7:
31 {
32 return 1;
33 }
34 case 1:
35 {
36 return 2;
37 }
38 case 4:
39 {
40 return 3;
41 }
42 case 9:
43 {
44 return 4;
45 }
46 case 11:
47 {
48 return 5;
49 }
50 case 12:
51 {
52 return 6;
53 }
54 default:
55 {
56 return -1;
57 }
58 }
59 return -1;
60 }
61 case 6:
62 {
63 System.Lex.Lexeme prevMatch = token.match;
64 token.match = lexeme;
65 int tokenId = GetTokenId(4);
66 if (tokenId == CONTINUE_TOKEN)
67 {
68 token.id = CONTINUE_TOKEN;
69 return -1;
70 }
71 else
72 {
73 if (tokenId != INVALID_TOKEN)
74 {
75 token.id = tokenId;
76 }
77 else
78 {
79 token.match = prevMatch;
80 }
81 }
82 return -1;
83 }
84 case 5:
85 {
86 System.Lex.Lexeme prevMatch = token.match;
87 token.match = lexeme;
88 int tokenId = GetTokenId(3);
89 if (tokenId == CONTINUE_TOKEN)
90 {
91 token.id = CONTINUE_TOKEN;
92 return -1;
93 }
94 else
95 {
96 if (tokenId != INVALID_TOKEN)
97 {
98 token.id = tokenId;
99 }
100 else
101 {
102 token.match = prevMatch;
103 }
104 }
105 return -1;
106 }
107 case 4:
108 {
109 switch (i)
110 {
111 case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 11: case 12:
112 {
113 return 7;
114 }
115 case 10:
116 {
117 return 8;
118 }
119 default:
120 {
121 return -1;
122 }
123 }
124 return -1;
125 }
126 case 8:
127 {
128 System.Lex.Lexeme prevMatch = token.match;
129 token.match = lexeme;
130 int tokenId = GetTokenId(2);
131 if (tokenId == CONTINUE_TOKEN)
132 {
133 token.id = CONTINUE_TOKEN;
134 return -1;
135 }
136 else
137 {
138 if (tokenId != INVALID_TOKEN)
139 {
140 token.id = tokenId;
141 }
142 else
143 {
144 token.match = prevMatch;
145 }
146 }
147 return -1;
148 }
149 case 7:
150 {
151 switch (i)
152 {
153 case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 11: case 12:
154 {
155 return 7;
156 }
157 case 10:
158 {
159 return 8;
160 }
161 default:
162 {
163 return -1;
164 }
165 }
166 return -1;
167 }
168 case 3:
169 {
170 System.Lex.Lexeme prevMatch = token.match;
171 token.match = lexeme;
172 int tokenId = GetTokenId(1);
173 if (tokenId == CONTINUE_TOKEN)
174 {
175 token.id = CONTINUE_TOKEN;
176 return -1;
177 }
178 else
179 {
180 if (tokenId != INVALID_TOKEN)
181 {
182 token.id = tokenId;
183 }
184 else
185 {
186 token.match = prevMatch;
187 }
188 }
189 switch (i)
190 {
191 case 4: case 5:
192 {
193 return 9;
194 }
195 default:
196 {
197 return -1;
198 }
199 }
200 return -1;
201 }
202 case 9:
203 {
204 System.Lex.Lexeme prevMatch = token.match;
205 token.match = lexeme;
206 int tokenId = GetTokenId(1);
207 if (tokenId == CONTINUE_TOKEN)
208 {
209 token.id = CONTINUE_TOKEN;
210 return -1;
211 }
212 else
213 {
214 if (tokenId != INVALID_TOKEN)
215 {
216 token.id = tokenId;
217 }
218 else
219 {
220 token.match = prevMatch;
221 }
222 }
223 switch (i)
224 {
225 case 4: case 5:
226 {
227 return 9;
228 }
229 default:
230 {
231 return -1;
232 }
233 }
234 return -1;
235 }
236 case 2:
237 {
238 switch (i)
239 {
240 case 1:
241 {
242 return 10;
243 }
244 case 2:
245 {
246 return 11;
247 }
248 default:
249 {
250 return -1;
251 }
252 }
253 return -1;
254 }
255 case 11:
256 {
257 switch (i)
258 {
259 case 0: case 1: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
260 {
261 return 12;
262 }
263 case 2:
264 {
265 return 13;
266 }
267 default:
268 {
269 return -1;
270 }
271 }
272 return -1;
273 }
274 case 13:
275 {
276 switch (i)
277 {
278 case 2:
279 {
280 return 13;
281 }
282 case 0: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
283 {
284 return 14;
285 }
286 case 1:
287 {
288 return 15;
289 }
290 default:
291 {
292 return -1;
293 }
294 }
295 return -1;
296 }
297 case 15:
298 {
299 System.Lex.Lexeme prevMatch = token.match;
300 token.match = lexeme;
301 int tokenId = GetTokenId(0);
302 if (tokenId == CONTINUE_TOKEN)
303 {
304 token.id = CONTINUE_TOKEN;
305 return -1;
306 }
307 else
308 {
309 if (tokenId != INVALID_TOKEN)
310 {
311 token.id = tokenId;
312 }
313 else
314 {
315 token.match = prevMatch;
316 }
317 }
318 switch (i)
319 {
320 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
321 {
322 return 12;
323 }
324 case 2:
325 {
326 return 13;
327 }
328 case 0: case 3: case 6: case 7:
329 {
330 return 16;
331 }
332 case 1:
333 {
334 return 17;
335 }
336 default:
337 {
338 return -1;
339 }
340 }
341 return -1;
342 }
343 case 17:
344 {
345 switch (i)
346 {
347 case 0: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
348 {
349 return 12;
350 }
351 case 1:
352 {
353 return 18;
354 }
355 case 2:
356 {
357 return 19;
358 }
359 default:
360 {
361 return -1;
362 }
363 }
364 return -1;
365 }
366 case 19:
367 {
368 switch (i)
369 {
370 case 2:
371 {
372 return 13;
373 }
374 case 0: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
375 {
376 return 14;
377 }
378 case 1:
379 {
380 return 15;
381 }
382 default:
383 {
384 return -1;
385 }
386 }
387 return -1;
388 }
389 case 18:
390 {
391 switch (i)
392 {
393 case 0:
394 {
395 return 20;
396 }
397 case 1: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
398 {
399 return 21;
400 }
401 case 2:
402 {
403 return 22;
404 }
405 case 3:
406 {
407 return 23;
408 }
409 default:
410 {
411 return -1;
412 }
413 }
414 return -1;
415 }
416 case 23:
417 {
418 System.Lex.Lexeme prevMatch = token.match;
419 token.match = lexeme;
420 int tokenId = GetTokenId(0);
421 if (tokenId == CONTINUE_TOKEN)
422 {
423 token.id = CONTINUE_TOKEN;
424 return -1;
425 }
426 else
427 {
428 if (tokenId != INVALID_TOKEN)
429 {
430 token.id = tokenId;
431 }
432 else
433 {
434 token.match = prevMatch;
435 }
436 }
437 switch (i)
438 {
439 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
440 {
441 return 12;
442 }
443 case 2:
444 {
445 return 13;
446 }
447 case 3: case 6: case 7:
448 {
449 return 16;
450 }
451 case 1:
452 {
453 return 17;
454 }
455 case 0:
456 {
457 return 24;
458 }
459 default:
460 {
461 return -1;
462 }
463 }
464 return -1;
465 }
466 case 24:
467 {
468 System.Lex.Lexeme prevMatch = token.match;
469 token.match = lexeme;
470 int tokenId = GetTokenId(0);
471 if (tokenId == CONTINUE_TOKEN)
472 {
473 token.id = CONTINUE_TOKEN;
474 return -1;
475 }
476 else
477 {
478 if (tokenId != INVALID_TOKEN)
479 {
480 token.id = tokenId;
481 }
482 else
483 {
484 token.match = prevMatch;
485 }
486 }
487 switch (i)
488 {
489 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
490 {
491 return 12;
492 }
493 case 2:
494 {
495 return 13;
496 }
497 case 0: case 3: case 6: case 7:
498 {
499 return 16;
500 }
501 case 1:
502 {
503 return 17;
504 }
505 default:
506 {
507 return -1;
508 }
509 }
510 return -1;
511 }
512 case 22:
513 {
514 switch (i)
515 {
516 case 2:
517 {
518 return 22;
519 }
520 case 0:
521 {
522 return 25;
523 }
524 case 1:
525 {
526 return 26;
527 }
528 case 3:
529 {
530 return 27;
531 }
532 case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
533 {
534 return 28;
535 }
536 default:
537 {
538 return -1;
539 }
540 }
541 return -1;
542 }
543 case 28:
544 {
545 switch (i)
546 {
547 case 0:
548 {
549 return 20;
550 }
551 case 1: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
552 {
553 return 21;
554 }
555 case 2:
556 {
557 return 22;
558 }
559 case 3:
560 {
561 return 23;
562 }
563 default:
564 {
565 return -1;
566 }
567 }
568 return -1;
569 }
570 case 27:
571 {
572 System.Lex.Lexeme prevMatch = token.match;
573 token.match = lexeme;
574 int tokenId = GetTokenId(0);
575 if (tokenId == CONTINUE_TOKEN)
576 {
577 token.id = CONTINUE_TOKEN;
578 return -1;
579 }
580 else
581 {
582 if (tokenId != INVALID_TOKEN)
583 {
584 token.id = tokenId;
585 }
586 else
587 {
588 token.match = prevMatch;
589 }
590 }
591 switch (i)
592 {
593 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
594 {
595 return 12;
596 }
597 case 2:
598 {
599 return 13;
600 }
601 case 3: case 6: case 7:
602 {
603 return 16;
604 }
605 case 1:
606 {
607 return 17;
608 }
609 case 0:
610 {
611 return 24;
612 }
613 default:
614 {
615 return -1;
616 }
617 }
618 return -1;
619 }
620 case 26:
621 {
622 System.Lex.Lexeme prevMatch = token.match;
623 token.match = lexeme;
624 int tokenId = GetTokenId(0);
625 if (tokenId == CONTINUE_TOKEN)
626 {
627 token.id = CONTINUE_TOKEN;
628 return -1;
629 }
630 else
631 {
632 if (tokenId != INVALID_TOKEN)
633 {
634 token.id = tokenId;
635 }
636 else
637 {
638 token.match = prevMatch;
639 }
640 }
641 switch (i)
642 {
643 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
644 {
645 return 21;
646 }
647 case 2:
648 {
649 return 22;
650 }
651 case 0:
652 {
653 return 29;
654 }
655 case 1:
656 {
657 return 30;
658 }
659 case 3:
660 {
661 return 31;
662 }
663 case 6: case 7:
664 {
665 return 32;
666 }
667 default:
668 {
669 return -1;
670 }
671 }
672 return -1;
673 }
674 case 32:
675 {
676 System.Lex.Lexeme prevMatch = token.match;
677 token.match = lexeme;
678 int tokenId = GetTokenId(0);
679 if (tokenId == CONTINUE_TOKEN)
680 {
681 token.id = CONTINUE_TOKEN;
682 return -1;
683 }
684 else
685 {
686 if (tokenId != INVALID_TOKEN)
687 {
688 token.id = tokenId;
689 }
690 else
691 {
692 token.match = prevMatch;
693 }
694 }
695 switch (i)
696 {
697 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
698 {
699 return 21;
700 }
701 case 2:
702 {
703 return 22;
704 }
705 case 0:
706 {
707 return 29;
708 }
709 case 1:
710 {
711 return 30;
712 }
713 case 3:
714 {
715 return 31;
716 }
717 case 6: case 7:
718 {
719 return 32;
720 }
721 default:
722 {
723 return -1;
724 }
725 }
726 return -1;
727 }
728 case 31:
729 {
730 System.Lex.Lexeme prevMatch = token.match;
731 token.match = lexeme;
732 int tokenId = GetTokenId(0);
733 if (tokenId == CONTINUE_TOKEN)
734 {
735 token.id = CONTINUE_TOKEN;
736 return -1;
737 }
738 else
739 {
740 if (tokenId != INVALID_TOKEN)
741 {
742 token.id = tokenId;
743 }
744 else
745 {
746 token.match = prevMatch;
747 }
748 }
749 switch (i)
750 {
751 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
752 {
753 return 12;
754 }
755 case 2:
756 {
757 return 13;
758 }
759 case 3: case 6: case 7:
760 {
761 return 16;
762 }
763 case 1:
764 {
765 return 17;
766 }
767 case 0:
768 {
769 return 24;
770 }
771 default:
772 {
773 return -1;
774 }
775 }
776 return -1;
777 }
778 case 30:
779 {
780 switch (i)
781 {
782 case 1:
783 {
784 return 18;
785 }
786 case 0:
787 {
788 return 20;
789 }
790 case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
791 {
792 return 21;
793 }
794 case 3:
795 {
796 return 23;
797 }
798 case 2:
799 {
800 return 33;
801 }
802 default:
803 {
804 return -1;
805 }
806 }
807 return -1;
808 }
809 case 33:
810 {
811 switch (i)
812 {
813 case 2:
814 {
815 return 22;
816 }
817 case 0:
818 {
819 return 25;
820 }
821 case 1:
822 {
823 return 26;
824 }
825 case 3:
826 {
827 return 27;
828 }
829 case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
830 {
831 return 28;
832 }
833 default:
834 {
835 return -1;
836 }
837 }
838 return -1;
839 }
840 case 29:
841 {
842 System.Lex.Lexeme prevMatch = token.match;
843 token.match = lexeme;
844 int tokenId = GetTokenId(0);
845 if (tokenId == CONTINUE_TOKEN)
846 {
847 token.id = CONTINUE_TOKEN;
848 return -1;
849 }
850 else
851 {
852 if (tokenId != INVALID_TOKEN)
853 {
854 token.id = tokenId;
855 }
856 else
857 {
858 token.match = prevMatch;
859 }
860 }
861 switch (i)
862 {
863 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
864 {
865 return 12;
866 }
867 case 2:
868 {
869 return 13;
870 }
871 case 0: case 3: case 6: case 7:
872 {
873 return 16;
874 }
875 case 1:
876 {
877 return 17;
878 }
879 default:
880 {
881 return -1;
882 }
883 }
884 return -1;
885 }
886 case 25:
887 {
888 System.Lex.Lexeme prevMatch = token.match;
889 token.match = lexeme;
890 int tokenId = GetTokenId(0);
891 if (tokenId == CONTINUE_TOKEN)
892 {
893 token.id = CONTINUE_TOKEN;
894 return -1;
895 }
896 else
897 {
898 if (tokenId != INVALID_TOKEN)
899 {
900 token.id = tokenId;
901 }
902 else
903 {
904 token.match = prevMatch;
905 }
906 }
907 switch (i)
908 {
909 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
910 {
911 return 12;
912 }
913 case 2:
914 {
915 return 13;
916 }
917 case 0: case 3: case 6: case 7:
918 {
919 return 16;
920 }
921 case 1:
922 {
923 return 17;
924 }
925 default:
926 {
927 return -1;
928 }
929 }
930 return -1;
931 }
932 case 21:
933 {
934 switch (i)
935 {
936 case 0:
937 {
938 return 20;
939 }
940 case 1: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
941 {
942 return 21;
943 }
944 case 2:
945 {
946 return 22;
947 }
948 case 3:
949 {
950 return 23;
951 }
952 default:
953 {
954 return -1;
955 }
956 }
957 return -1;
958 }
959 case 20:
960 {
961 System.Lex.Lexeme prevMatch = token.match;
962 token.match = lexeme;
963 int tokenId = GetTokenId(0);
964 if (tokenId == CONTINUE_TOKEN)
965 {
966 token.id = CONTINUE_TOKEN;
967 return -1;
968 }
969 else
970 {
971 if (tokenId != INVALID_TOKEN)
972 {
973 token.id = tokenId;
974 }
975 else
976 {
977 token.match = prevMatch;
978 }
979 }
980 switch (i)
981 {
982 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
983 {
984 return 12;
985 }
986 case 2:
987 {
988 return 13;
989 }
990 case 0: case 3: case 6: case 7:
991 {
992 return 16;
993 }
994 case 1:
995 {
996 return 17;
997 }
998 default:
999 {
1000 return -1;
1001 }
1002 }
1003 return -1;
1004 }
1005 case 16:
1006 {
1007 System.Lex.Lexeme prevMatch = token.match;
1008 token.match = lexeme;
1009 int tokenId = GetTokenId(0);
1010 if (tokenId == CONTINUE_TOKEN)
1011 {
1012 token.id = CONTINUE_TOKEN;
1013 return -1;
1014 }
1015 else
1016 {
1017 if (tokenId != INVALID_TOKEN)
1018 {
1019 token.id = tokenId;
1020 }
1021 else
1022 {
1023 token.match = prevMatch;
1024 }
1025 }
1026 switch (i)
1027 {
1028 case 4: case 5: case 8: case 9: case 10: case 11: case 12:
1029 {
1030 return 12;
1031 }
1032 case 2:
1033 {
1034 return 13;
1035 }
1036 case 0: case 3: case 6: case 7:
1037 {
1038 return 16;
1039 }
1040 case 1:
1041 {
1042 return 17;
1043 }
1044 default:
1045 {
1046 return -1;
1047 }
1048 }
1049 return -1;
1050 }
1051 case 14:
1052 {
1053 switch (i)
1054 {
1055 case 0: case 1: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
1056 {
1057 return 12;
1058 }
1059 case 2:
1060 {
1061 return 13;
1062 }
1063 default:
1064 {
1065 return -1;
1066 }
1067 }
1068 return -1;
1069 }
1070 case 12:
1071 {
1072 switch (i)
1073 {
1074 case 0: case 1: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
1075 {
1076 return 12;
1077 }
1078 case 2:
1079 {
1080 return 13;
1081 }
1082 default:
1083 {
1084 return -1;
1085 }
1086 }
1087 return -1;
1088 }
1089 case 10:
1090 {
1091 switch (i)
1092 {
1093 case 0:
1094 {
1095 return 34;
1096 }
1097 case 1: case 2: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
1098 {
1099 return 35;
1100 }
1101 case 3:
1102 {
1103 return 36;
1104 }
1105 default:
1106 {
1107 return -1;
1108 }
1109 }
1110 return -1;
1111 }
1112 case 36:
1113 {
1114 System.Lex.Lexeme prevMatch = token.match;
1115 token.match = lexeme;
1116 int tokenId = GetTokenId(0);
1117 if (tokenId == CONTINUE_TOKEN)
1118 {
1119 token.id = CONTINUE_TOKEN;
1120 return -1;
1121 }
1122 else
1123 {
1124 if (tokenId != INVALID_TOKEN)
1125 {
1126 token.id = tokenId;
1127 }
1128 else
1129 {
1130 token.match = prevMatch;
1131 }
1132 }
1133 switch (i)
1134 {
1135 case 3: case 6: case 7:
1136 {
1137 return 1;
1138 }
1139 case 1:
1140 {
1141 return 2;
1142 }
1143 case 0:
1144 {
1145 return 37;
1146 }
1147 default:
1148 {
1149 return -1;
1150 }
1151 }
1152 return -1;
1153 }
1154 case 37:
1155 {
1156 System.Lex.Lexeme prevMatch = token.match;
1157 token.match = lexeme;
1158 int tokenId = GetTokenId(0);
1159 if (tokenId == CONTINUE_TOKEN)
1160 {
1161 token.id = CONTINUE_TOKEN;
1162 return -1;
1163 }
1164 else
1165 {
1166 if (tokenId != INVALID_TOKEN)
1167 {
1168 token.id = tokenId;
1169 }
1170 else
1171 {
1172 token.match = prevMatch;
1173 }
1174 }
1175 switch (i)
1176 {
1177 case 0: case 3: case 6: case 7:
1178 {
1179 return 1;
1180 }
1181 case 1:
1182 {
1183 return 2;
1184 }
1185 default:
1186 {
1187 return -1;
1188 }
1189 }
1190 return -1;
1191 }
1192 case 35:
1193 {
1194 switch (i)
1195 {
1196 case 0:
1197 {
1198 return 34;
1199 }
1200 case 1: case 2: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
1201 {
1202 return 35;
1203 }
1204 case 3:
1205 {
1206 return 36;
1207 }
1208 default:
1209 {
1210 return -1;
1211 }
1212 }
1213 return -1;
1214 }
1215 case 34:
1216 {
1217 System.Lex.Lexeme prevMatch = token.match;
1218 token.match = lexeme;
1219 int tokenId = GetTokenId(0);
1220 if (tokenId == CONTINUE_TOKEN)
1221 {
1222 token.id = CONTINUE_TOKEN;
1223 return -1;
1224 }
1225 else
1226 {
1227 if (tokenId != INVALID_TOKEN)
1228 {
1229 token.id = tokenId;
1230 }
1231 else
1232 {
1233 token.match = prevMatch;
1234 }
1235 }
1236 switch (i)
1237 {
1238 case 0: case 3: case 6: case 7:
1239 {
1240 return 1;
1241 }
1242 case 1:
1243 {
1244 return 2;
1245 }
1246 default:
1247 {
1248 return -1;
1249 }
1250 }
1251 return -1;
1252 }
1253 case 1:
1254 {
1255 System.Lex.Lexeme prevMatch = token.match;
1256 token.match = lexeme;
1257 int tokenId = GetTokenId(0);
1258 if (tokenId == CONTINUE_TOKEN)
1259 {
1260 token.id = CONTINUE_TOKEN;
1261 return -1;
1262 }
1263 else
1264 {
1265 if (tokenId != INVALID_TOKEN)
1266 {
1267 token.id = tokenId;
1268 }
1269 else
1270 {
1271 token.match = prevMatch;
1272 }
1273 }
1274 switch (i)
1275 {
1276 case 0: case 3: case 6: case 7:
1277 {
1278 return 1;
1279 }
1280 case 1:
1281 {
1282 return 2;
1283 }
1284 default:
1285 {
1286 return -1;
1287 }
1288 }
1289 return -1;
1290 }
1291 }
1292 return -1;
1293 }
1294 private int GetTokenId(int statementIndex)
1295 {
1296 switch (statementIndex)
1297 {
1298 case 0:
1299 {
1300 Retract();
1301 break;
1302 }
1303 case 1:
1304 {
1305 Retract();
1306 int kw = GetKeywordToken(token.match);
1307 if (kw == INVALID_TOKEN) return ID;
1308 else return kw;
1309 break;
1310 }
1311 case 2:
1312 {
1313 Retract();
1314 filePath = soulcm.scmpg.MakeFilePath(FileName(), token);
1315 return FILEPATH;
1316 break;
1317 }
1318 case 3:
1319 {
1320 Retract();
1321 return DOT;
1322 break;
1323 }
1324 case 4:
1325 {
1326 Retract();
1327 return SEMICOLON;
1328 break;
1329 }
1330 }
1331 return CONTINUE_TOKEN;
1332 }
1333 public string filePath;
1334 }