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