1	/*
2	 * 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 {      // for error handling
80				{
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 {      // for error handling
187				{
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								// consume everything until the next class definition or EOF
324								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;	// block increments, so -1 to make rule at level 0
1143			
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