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