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