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