Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   // $ANTLR 2.7.7 (20060906): "java.g" -> "JavaRecognizer.java"$
   
   package org.codehaus.groovy.antlr.java;
   import java.util.*;
   import java.io.InputStream;
   import java.io.Reader;
   import  antlr.InputBuffer;
  import  antlr.LexerSharedInputState;
  
  import  antlr.TokenBuffer;
  import  antlr.TokenStreamException;
  import  antlr.TokenStreamIOException;
  import  antlr.ANTLRException;
  import  antlr.LLkParser;
  import  antlr.Token;
  import  antlr.TokenStream;
  import  antlr.RecognitionException;
  import  antlr.NoViableAltException;
  import  antlr.MismatchedTokenException;
  import  antlr.SemanticException;
  import  antlr.ParserSharedInputState;
  import  antlr.collections.impl.BitSet;
  import  antlr.collections.AST;
  import  antlr.ASTFactory;
  import  antlr.ASTPair;
  import  antlr.collections.impl.ASTArray;

Java 1.5 Recognizer Run 'java Main [-showtree] directory-full-of-java-files' [The -showtree option pops up a Swing frame that shows the AST constructed from the parser.] Run 'java Main <directory full of java files>' Contributing authors: Jeremy Rayner groovy@ross-rayner.com John Mitchell johnm@non.net Terence Parr parrt@magelang.com John Lilley jlilley@empathy.com Scott Stanchfield thetick@magelang.com Markus Mohnen mohnen@informatik.rwth-aachen.de Peter Williams pete.williams@sun.com Allan Jacobs Allan.Jacobs@eng.sun.com Steve Messick messick@redhills.com John Pybus john@pybus.org Version 1.00 December 9, 1997 -- initial release Version 1.01 December 10, 1997 fixed bug in octal def (0..7 not 0..8) Version 1.10 August 1998 (parrt) added tree construction fixed definition of WS,comments for mac,pc,unix newlines added unary plus Version 1.11 (Nov 20, 1998) Added "shutup" option to turn off last ambig warning. Fixed inner class def to allow named class defs as statements synchronized requires compound not simple statement add [] after builtInType DOT class in primaryExpression "const" is reserved but not valid..removed from modifiers Version 1.12 (Feb 2, 1999) Changed LITERAL_xxx to xxx in tree grammar. Updated java.g to use tokens {...} now for 2.6.0 (new feature). Version 1.13 (Apr 23, 1999) Didn't have (stat)? for else clause in tree parser. Didn't gen ASTs for interface extends. Updated tree parser too. Updated to 2.6.0. Version 1.14 (Jun 20, 1999) Allowed final/abstract on local classes. Removed local interfaces from methods Put instanceof precedence where it belongs...in relationalExpr It also had expr not type as arg; fixed it. Missing ! on SEMI in classBlock fixed: (expr) + "string" was parsed incorrectly (+ as unary plus). fixed: didn't like Object[].class in parser or tree parser Version 1.15 (Jun 26, 1999) Screwed up rule with instanceof in it. :( Fixed. Tree parser didn't like (expr).something; fixed. Allowed multiple inheritance in tree grammar. oops. Version 1.16 (August 22, 1999) Extending an interface built a wacky tree: had extra EXTENDS. Tree grammar didn't allow multiple superinterfaces. Tree grammar didn't allow empty var initializer: {} Version 1.17 (October 12, 1999) ESC lexer rule allowed 399 max not 377 max. java.tree.g didn't handle the expression of synchronized statements. Version 1.18 (August 12, 2001) Terence updated to Java 2 Version 1.3 by observing/combining work of Allan Jacobs and Steve Messick. Handles 1.3 src. Summary: o primary didn't include boolean.class kind of thing o constructor calls parsed explicitly now: see explicitConstructorInvocation o add strictfp modifier o missing objBlock after new expression in tree grammar o merged local class definition alternatives, moved after declaration o fixed problem with ClassName.super.field o reordered some alternatives to make things more efficient o long and double constants were not differentiated from int/float o whitespace rule was inefficient: matched only one char o add an examples directory with some nasty 1.3 cases o made Main.java use buffered IO and a Reader for Unicode support o supports UNICODE? Using Unicode charVocabulay makes code file big, but only in the bitsets at the end. I need to make ANTLR generate unicode bitsets more efficiently. Version 1.19 (April 25, 2002) Terence added in nice fixes by John Pybus concerning floating constants and problems with super() calls. John did a nice reorg of the primary/postfix expression stuff to read better and makes f.g.super() parse properly (it was METHOD_CALL not a SUPER_CTOR_CALL). Also: o "finally" clause was a root...made it a child of "try" o Added stuff for asserts too for Java 1.4, but *commented out* as it is not backward compatible. Version 1.20 (October 27, 2002) Terence ended up reorging John Pybus' stuff to remove some nondeterminisms and some syntactic predicates. Note that the grammar is stricter now; e.g., this(...) must be the first statement. Trinary ?: operator wasn't working as array name: (isBig ? bigDigits : digits)[i]; Checked parser/tree parser on source for Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4, and the 110k-line jGuru server source. Version 1.21 (October 17, 2003) Fixed lots of problems including: Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g He found a problem/fix with floating point that start with 0 Ray also fixed problem that (int.class) was not recognized. Thorsten van Ellen noticed that \n are allowed incorrectly in strings. TJP fixed CHAR_LITERAL analogously. Version 1.21.2 (March, 2003) Changes by Matt Quail to support generics (as per JDK1.5/JSR14) Notes: o We only allow the "extends" keyword and not the "implements" keyword, since thats what JSR14 seems to imply. o Thanks to Monty Zukowski for his help on the antlr-interest mail list. o Thanks to Alan Eliasen for testing the grammar over his Fink source base Version 1.22 (July, 2004) Changes by Michael Studman to support Java 1.5 language extensions Notes: o Added support for annotations types o Finished off Matt Quail's generics enhancements to support bound type arguments o Added support for new for statement syntax o Added support for static import syntax o Added support for enum types o Tested against JDK 1.5 source base and source base of jdigraph project o Thanks to Matt Quail for doing the hard part by doing most of the generics work Version 1.22.1 (July 28, 2004) Bug/omission fixes for Java 1.5 language support o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for spotting this o Fixed bug where incorrect handling of SR and BSR tokens would cause type parameters to be recognised as type arguments. o Enabled type parameters on constructors, annotations on enum constants and package definitions o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua Version 1.22.2 (July 28, 2004) Slight refactoring of Java 1.5 language support o Refactored for/"foreach" productions so that original literal "for" literal is still used but the for sub-clauses vary by token type o Fixed bug where type parameter was not included in generic constructor's branch of AST Version 1.22.3 (August 26, 2004) Bug fixes as identified by Michael Stahl; clean up of tabs/spaces and other refactorings o Fixed typeParameters omission in identPrimary and newStatement o Replaced GT reconcilliation code with simple semantic predicate o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar o Refactored typeDefinition production and field productions to reduce duplication Version 1.22.4 (October 21, 2004) Small bux fixes o Added typeArguments to explicitConstructorInvocation, e.g. new <String>MyParameterised() o Added typeArguments to postfixExpression productions for anonymous inner class super constructor invocation, e.g. new Outer().<String>super() o Fixed bug in array declarations identified by Geoff Roy Version 1.22.4.j.1 Changes by Jeremy Rayner to support java2groovy tool o I have taken java.g for Java1.5 from Michael Studman (1.22.4) and have made some changes to enable use by java2groovy tool (Jan 2007) This grammar is in the PUBLIC DOMAIN
 
 public class JavaRecognizer extends antlr.LLkParser       implements JavaTokenTypes
  {

    
This factory is the correct way to wire together a Groovy parser and lexer.
 
     public static JavaRecognizer make(JavaLexer lexer) {
         JavaRecognizer parser = new JavaRecognizer(lexer.plumb());
         // TODO: set up a common error-handling control block, to avoid excessive tangle between these guys
         parser.lexer = lexer;
         lexer.parser = parser;
         parser.setASTNodeClass("org.codehaus.groovy.antlr.GroovySourceAST");
         return parser;
     }
     // Create a scanner that reads from the input stream passed to us...
     public static JavaRecognizer make(InputStream in) { return make(new JavaLexer(in)); }
     public static JavaRecognizer make(Reader in) { return make(new JavaLexer(in)); }
     public static JavaRecognizer make(InputBuffer in) { return make(new JavaLexer(in)); }
     public static JavaRecognizer make(LexerSharedInputState in) { return make(new JavaLexer(in)); }
     
     
     JavaLexer lexer;
     public JavaLexer getLexer() { return ; }
     public void setFilename(String f) { super.setFilename(f); .setFilename(f); }
     private SourceBuffer sourceBuffer;
     public void setSourceBuffer(SourceBuffer sourceBuffer) {
         this. = sourceBuffer;
     }

    
Create an AST node with the token type and text passed in, but with the same background information as another supplied Token (e.g. line numbers) to be used in place of antlr tree construction syntax, i.e. #[TOKEN,"text"] becomes create(TOKEN,"text",anotherToken) todo - change antlr.ASTFactory to do this instead...
 
     public AST create(int typeString txt, Token first, Token last) {
         AST t = astFactory.create(type,txt);
         if ( t != null && first != null) {
             // first copy details from first token
             t.initialize(first);
             // then ensure that type and txt are specific to this new node
             t.initialize(type,txt);
         }
 
         if ((t instanceof GroovySourceAST) && last != null) {
             GroovySourceAST node = (GroovySourceAST)t;
             node.setLast(last);
             // This is a good point to call node.setSnippet(),
             // but it bulks up the AST too much for production code.
         }
         return t;
     }

    
    
Counts the number of LT seen in the typeArguments production. It is used in semantic predicates to ensure we have seen enough closing '>' characters; which actually may have been either GT, SR or BSR tokens.
 
 	private int ltCounter = 0;
 
 protected JavaRecognizer(TokenBuffer tokenBufint k) {
   super(tokenBuf,k);
   tokenNames = ;
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 public JavaRecognizer(TokenBuffer tokenBuf) {
   this(tokenBuf,2);
 }
 
 protected JavaRecognizer(TokenStream lexerint k) {
   super(lexer,k);
   tokenNames = ;
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 public JavaRecognizer(TokenStream lexer) {
   this(lexer,2);
 }
 
 public JavaRecognizer(ParserSharedInputState state) {
   super(state,2);
   tokenNames = ;
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 	public final void compilationUnit() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST compilationUnit_AST = null;
 		
 		{
 		boolean synPredMatched4 = false;
 		if (((LA(1)==||LA(1)==) && (LA(2)==))) {
 			int _m4 = mark();
 			synPredMatched4 = true;
 			inputState.guessing++;
 			try {
 				{
 				}
 			}
 			catch (RecognitionException pe) {
 				synPredMatched4 = false;
 			}
 			rewind(_m4);
 inputState.guessing--;
 		}
 		if ( synPredMatched4 ) {
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((.member(LA(1))) && (.member(LA(2)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		{
 		_loop6:
 		do {
 			if ((LA(1)==)) {
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop6;
 			}
 			
 		} while (true);
 		}
 		{
 		_loop8:
 		do {
 			if ((.member(LA(1)))) {
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop8;
 			}
 			
 		} while (true);
 		}
 		match(Token.EOF_TYPE);
 		compilationUnit_AST = (AST)currentAST.root;
 		returnAST = compilationUnit_AST;
 	}
 	
 	public final void annotations() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotations_AST = null;
 		Token first = LT(1);
 		
 		{
 		_loop62:
 		do {
 			if ((LA(1)==)) {
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop62;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			annotations_AST = (AST)currentAST.root;
 			annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(,"ANNOTATIONS")).add(annotations_AST));
 			currentAST.root = annotations_AST;
 			currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ?
 				annotations_AST.getFirstChild() : annotations_AST;
 			currentAST.advanceChildToEnd();
 		}
 		annotations_AST = (AST)currentAST.root;
 		returnAST = annotations_AST;
 	}
 	
 	public final void packageDefinition() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST packageDefinition_AST = null;
 		Token  p = null;
 		AST p_AST = null;
 		
 		try {      // for error handling
 			astFactory.addASTChild(currentAST, returnAST);
 			p = LT(1);
 			p_AST = astFactory.create(p);
 			astFactory.makeASTRoot(currentASTp_AST);
 			if ( inputState.guessing==0 ) {
 				p_AST.setType();
 			}
 			astFactory.addASTChild(currentAST, returnAST);
 			packageDefinition_AST = (AST)currentAST.root;
 		}
 		catch (RecognitionException ex) {
 			if (inputState.guessing==0) {
 				reportError(ex);
 				recover(ex,);
 			} else {
 			  throw ex;
 			}
 		}
 		returnAST = packageDefinition_AST;
 	}
 	
 	public final void importDefinition() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST importDefinition_AST = null;
 		Token  i = null;
 		AST i_AST = null;
 		boolean isStatic = false;
 		
 		try {      // for error handling
 			i = LT(1);
 			i_AST = astFactory.create(i);
 			astFactory.makeASTRoot(currentASTi_AST);
 			if ( inputState.guessing==0 ) {
 				i_AST.setType();
 			}
 			{
 			switch ( LA(1)) {
 			{
 				if ( inputState.guessing==0 ) {
 					i_AST.setType();
 				}
 				break;
 			}
 			case :
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			astFactory.addASTChild(currentAST, returnAST);
 			importDefinition_AST = (AST)currentAST.root;
 		}
 		catch (RecognitionException ex) {
 			if (inputState.guessing==0) {
 				reportError(ex);
 				recover(ex,);
 			} else {
 			  throw ex;
 			}
 		}
 		returnAST = importDefinition_AST;
 	}
 	
 	public final void typeDefinition() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeDefinition_AST = null;
 		AST m_AST = null;
 		
 		try {      // for error handling
 			switch ( LA(1)) {
 			case :
 			case :
 			case :
 			case :
 			case :
 			{
 				m_AST = (AST)returnAST;
 				astFactory.addASTChild(currentAST, returnAST);
 				typeDefinition_AST = (AST)currentAST.root;
 				break;
 			}
 			case :
 			{
 				typeDefinition_AST = (AST)currentAST.root;
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 		}
 		catch (RecognitionException ex) {
 			if (inputState.guessing==0) {
 				reportError(ex);
 				recover(ex,);
 			} else {
 			  throw ex;
 			}
 		}
 		returnAST = typeDefinition_AST;
 	}
 	
 	public final void identifier() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST identifier_AST = null;
 		
 		AST tmp6_AST = null;
 		tmp6_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentASTtmp6_AST);
 		{
 		_loop48:
 		do {
 			if ((LA(1)==)) {
 				AST tmp7_AST = null;
 				tmp7_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentASTtmp7_AST);
 				AST tmp8_AST = null;
 				tmp8_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentASTtmp8_AST);
 			}
 			else {
 				break _loop48;
 			}
 			
 		} while (true);
 		}
 		identifier_AST = (AST)currentAST.root;
 		returnAST = identifier_AST;
 	}
 	
 	public final void identifierStar() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST identifierStar_AST = null;
 		
 		AST tmp9_AST = null;
 		tmp9_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentASTtmp9_AST);
 		{
 		_loop51:
 		do {
 			if ((LA(1)==) && (LA(2)==)) {
 				AST tmp10_AST = null;
 				tmp10_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentASTtmp10_AST);
 				AST tmp11_AST = null;
 				tmp11_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentASTtmp11_AST);
 			}
 			else {
 				break _loop51;
 			}
 			
 		} while (true);
 		}
 		{
 		switch ( LA(1)) {
 		case :
 		{
 			AST tmp12_AST = null;
 			tmp12_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentASTtmp12_AST);
 			AST tmp13_AST = null;
 			tmp13_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentASTtmp13_AST);
 			break;
 		}
 		case :
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		identifierStar_AST = (AST)currentAST.root;
 		returnAST = identifierStar_AST;
 	}
 	
 	public final void modifiers() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST modifiers_AST = null;
 		Token first = LT(1);
 		
 		{
 		_loop55:
 		do {
 			if ((.member(LA(1)))) {
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else if (((LA(1)==) && (LA(2)==))&&(LA(1)== && !LT(2).getText().equals("interface"))) {
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop55;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			modifiers_AST = (AST)currentAST.root;
 			modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(,"MODIFIERS",first,LT(1))).add(modifiers_AST));
 			currentAST.root = modifiers_AST;
 			currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
 				modifiers_AST.getFirstChild() : modifiers_AST;
 			currentAST.advanceChildToEnd();
 		}
 		modifiers_AST = (AST)currentAST.root;
 		returnAST = modifiers_AST;
 	}
 	
 	protected final void typeDefinitionInternal(
 		AST mods
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeDefinitionInternal_AST = null;
 		
 		switch ( LA(1)) {
 		{
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		{
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case :
 		{
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case :
 		{
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = typeDefinitionInternal_AST;
 	}
 	
 	public final void classDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST classDefinition_AST = null;
 		AST tp_AST = null;
 		AST sc_AST = null;
 		AST ic_AST = null;
 		AST cb_AST = null;
 		Token first = LT(1);
 		
 		AST tmp15_AST = null;
 		tmp15_AST = astFactory.create(LT(1));
 		{
 		switch ( LA(1)) {
 		case :
 		{
 			tp_AST = (AST)returnAST;
 			break;
 		}
 		case :
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		sc_AST = (AST)returnAST;
 		ic_AST = (AST)returnAST;
 		cb_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			classDefinition_AST = (AST)currentAST.root;
 			classDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(create(,"CLASS_DEF",first,LT(1))).add(modifiers).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
 			currentAST.root = classDefinition_AST;
 			currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
 				classDefinition_AST.getFirstChild() : classDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = classDefinition_AST;
 	}
 	
 	public final void interfaceDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST interfaceDefinition_AST = null;
 		AST tp_AST = null;
 		AST ie_AST = null;
 		AST ib_AST = null;
 		Token first = LT(1);
 		
 		AST tmp17_AST = null;
 		tmp17_AST = astFactory.create(LT(1));
 		{
 		switch ( LA(1)) {
 		case :
 		{
 			tp_AST = (AST)returnAST;
 			break;
 		}
 		case :
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		ie_AST = (AST)returnAST;
 		ib_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			interfaceDefinition_AST = (AST)currentAST.root;
 			interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(create(,"INTERFACE_DEF",first,LT(1))).add(modifiers).add(tmp17_AST).add(tp_AST).add(ie_AST).add(ib_AST));
 			currentAST.root = interfaceDefinition_AST;
 			currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
 				interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = interfaceDefinition_AST;
 	}
 	
 	public final void enumDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST enumDefinition_AST = null;
 		AST ic_AST = null;
 		AST eb_AST = null;
 		Token first = LT(1);
 		
 		AST tmp19_AST = null;
 		tmp19_AST = astFactory.create(LT(1));
 		ic_AST = (AST)returnAST;
 		eb_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			enumDefinition_AST = (AST)currentAST.root;
 			enumDefinition_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(,"ENUM_DEF",first,LT(1))).add(modifiers).add(tmp19_AST).add(ic_AST).add(eb_AST));
 			currentAST.root = enumDefinition_AST;
 			currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
 				enumDefinition_AST.getFirstChild() : enumDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = enumDefinition_AST;
 	}
 	
 	public final void annotationDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationDefinition_AST = null;
 		AST ab_AST = null;
 		Token first = LT(1);
 		
 		AST tmp20_AST = null;
 		tmp20_AST = astFactory.create(LT(1));
 		AST tmp22_AST = null;
 		tmp22_AST = astFactory.create(LT(1));
 		ab_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			annotationDefinition_AST = (AST)currentAST.root;
 			annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(,"ANNOTATION_DEF",first,LT(1))).add(modifiers).add(tmp22_AST).add(ab_AST));
 			currentAST.root = annotationDefinition_AST;
 			currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
 				annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = annotationDefinition_AST;
 	}
 	
 	public final void declaration() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST declaration_AST = null;
 		AST m_AST = null;
 		AST t_AST = null;
 		AST v_AST = null;
 		
 		m_AST = (AST)returnAST;
 		typeSpec(false);
 		t_AST = (AST)returnAST;
 		variableDefinitions(m_AST,t_AST);
 		v_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			declaration_AST = (AST)currentAST.root;
 			declaration_AST = v_AST;
 			currentAST.root = declaration_AST;
 			currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
 				declaration_AST.getFirstChild() : declaration_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = declaration_AST;
 	}
 	
 	public final void typeSpec(
 		boolean addImagNode
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeSpec_AST = null;
 		
 		switch ( LA(1)) {
 		case :
 		{
 			classTypeSpec(addImagNode);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeSpec_AST = (AST)currentAST.root;
 			break;
 		}
 		case :
 		case :
 		case :
 		case :
 		case :
 		{
 			builtInTypeSpec(addImagNode);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeSpec_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = typeSpec_AST;
 	}
 	
 	public final void variableDefinitions(
 		AST mods, AST t
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST variableDefinitions_AST = null;
 		
 							getASTFactory().dupTree(t));
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop155:
 		do {
 			if ((LA(1)==)) {
 							getASTFactory().dupTree(t));
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop155;
 			}
 			
 		} while (true);
 		}
 		variableDefinitions_AST = (AST)currentAST.root;
 		returnAST = variableDefinitions_AST;
 	}
 	
 	public final void classTypeSpec(
 		boolean addImagNode
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST classTypeSpec_AST = null;
 		Token  lb = null;
 		AST lb_AST = null;
 		Token first = LT(1);
 		
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop18:
 		do {
 			if ((LA(1)==) && (LA(2)==)) {
 				lb = LT(1);
 				lb_AST = astFactory.create(lb);
 				astFactory.makeASTRoot(currentASTlb_AST);
 				if ( inputState.guessing==0 ) {
 					lb_AST.setType();
 				}
 			}
 			else {
 				break _loop18;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
			classTypeSpec_AST = (AST)currentAST.root;
						if ( addImagNode ) {
							classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(,"TYPE",first,LT(1))).add(classTypeSpec_AST));
			currentAST.root = classTypeSpec_AST;
			currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
				classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
			currentAST.advanceChildToEnd();
		classTypeSpec_AST = (AST)currentAST.root;
		returnAST = classTypeSpec_AST;
	public final void builtInTypeSpec(
		boolean addImagNode
throws RecognitionException, TokenStreamException {
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST builtInTypeSpec_AST = null;
		Token  lb = null;
		AST lb_AST = null;
		Token first = LT(1);
		astFactory.addASTChild(currentAST, returnAST);
		_loop43:
		do {
			if ((LA(1)==)) {
				lb = LT(1);
				lb_AST = astFactory.create(lb);
				astFactory.makeASTRoot(currentASTlb_AST);
				if ( inputState.guessing==0 ) {
					lb_AST.setType();
			else {
				break _loop43;
while (true);
		if ( inputState.guessing==0 ) {
			builtInTypeSpec_AST = (AST)currentAST.root;
						if ( addImagNode ) {
							builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(,"TYPE",first,LT(1))).add(builtInTypeSpec_AST));
			currentAST.root = builtInTypeSpec_AST;
			currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
				builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
			currentAST.advanceChildToEnd();
		builtInTypeSpec_AST = (AST)currentAST.root;
		returnAST = builtInTypeSpec_AST;
	public final void classOrInterfaceType(
		boolean addImagNode
throws RecognitionException, TokenStreamException {
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST classOrInterfaceType_AST = null;
		Token first = LT(1);
		AST tmp26_AST = null;
		tmp26_AST = astFactory.create(LT(1));
		astFactory.makeASTRoot(currentASTtmp26_AST);
		switch ( LA(1)) {
		case :
			astFactory.addASTChild(currentAST, returnAST);
			break;
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
		case :
			break;
		default:
			throw new NoViableAltException(LT(1), getFilename());
		_loop23:
		do {
			if ((LA(1)==) && (LA(2)==)) {
				AST tmp27_AST = null;
				tmp27_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentASTtmp27_AST);
				AST tmp28_AST = null;
				tmp28_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentASTtmp28_AST);
				switch ( LA(1)) {
				case :
					astFactory.addASTChild(currentAST, returnAST);
					break;
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
				case :
					break;
				default:
					throw new NoViableAltException(LT(1), getFilename());
			else {
				break _loop23;
while (true);
		if ( inputState.guessing==0 ) {
			classOrInterfaceType_AST = (AST)currentAST.root;
						if ( addImagNode ) {
							classOrInterfaceType_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(,"TYPE",first,LT(1))).add(classOrInterfaceType_AST));
			currentAST.root = classOrInterfaceType_AST;
			currentAST.child = classOrInterfaceType_AST!=null &&classOrInterfaceType_AST.getFirstChild()!=null ?
				classOrInterfaceType_AST.getFirstChild() : classOrInterfaceType_AST;
			currentAST.advanceChildToEnd();
		classOrInterfaceType_AST = (AST)currentAST.root;
		returnAST = classOrInterfaceType_AST;
	public final void typeArguments() throws RecognitionException, TokenStreamException {
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST typeArguments_AST = null;
		int currentLtLevel = 0;  Token first = LT(1);
		if ( inputState.guessing==0 ) {
			currentLtLevel = ;
		if ( inputState.guessing==0 ) {
		astFactory.addASTChild(currentAST, returnAST);
		_loop33:
		do {
			if (((LA(1)==) && (.member(LA(2))))&&(inputState.guessing !=0 ||  == currentLtLevel + 1)) {
				astFactory.addASTChild(currentAST, returnAST);
			else {
				break _loop33;
while (true);
		if (((LA(1) >=  && LA(1) <= )) && (.member(LA(2)))) {
			astFactory.addASTChild(currentAST, returnAST);
		else if ((.member(LA(1))) && (.member(LA(2)))) {
		else {
			throw new NoViableAltException(LT(1), getFilename());
		if (!((currentLtLevel != 0) ||  == currentLtLevel))
		  throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel");
		if ( inputState.guessing==0 ) {
			typeArguments_AST = (AST)currentAST.root;
			typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(,"TYPE_ARGUMENTS",first,LT(1))).add(typeArguments_AST));
			currentAST.root = typeArguments_AST;
			currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ?
				typeArguments_AST.getFirstChild() : typeArguments_AST;
			currentAST.advanceChildToEnd();
		typeArguments_AST = (AST)currentAST.root;
		returnAST = typeArguments_AST;
	public final void typeArgumentSpec() throws RecognitionException, TokenStreamException {
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST typeArgumentSpec_AST = null;
		switch ( LA(1)) {
		case :
			astFactory.addASTChild(currentAST, returnAST);
			typeArgumentSpec_AST = (AST)currentAST.root;
			break;
			astFactory.addASTChild(currentAST, returnAST);
			typeArgumentSpec_AST = (AST)currentAST.root;
			break;
		default:
			throw new NoViableAltException(LT(1), getFilename());
		returnAST = typeArgumentSpec_AST;
	public final void builtInTypeArraySpec(
		boolean addImagNode
throws RecognitionException, TokenStreamException {
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST builtInTypeArraySpec_AST = null;
		Token  lb = null;
		AST lb_AST = null;
		Token first = LT(1);
		astFactory.addASTChild(currentAST, returnAST);
		int _cnt40=0;
		_loop40:
		do {
			if ((LA(1)==) && (LA(2)==)) {
				lb = LT(1);
				lb_AST = astFactory.create(lb);
				astFactory.makeASTRoot(currentASTlb_AST);
				if ( inputState.guessing==0 ) {
					lb_AST.setType();
			else {
				if ( _cnt40>=1 ) { break _loop40; } else {throw new NoViableAltException(LT(1), getFilename());}
			_cnt40++;
while (true);
		if ( inputState.guessing==0 ) {
			builtInTypeArraySpec_AST = (AST)currentAST.root;
						if ( addImagNode ) {
							builtInTypeArraySpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(,"TYPE",first,LT(1))).add(builtInTypeArraySpec_AST));
			currentAST.root = builtInTypeArraySpec_AST;
			currentAST.child = builtInTypeArraySpec_AST!=null &&builtInTypeArraySpec_AST.getFirstChild()!=null ?
				builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST;
			currentAST.advanceChildToEnd();
		builtInTypeArraySpec_AST = (AST)currentAST.root;
		returnAST = builtInTypeArraySpec_AST;
	public final void typeArgument() throws RecognitionException, TokenStreamException {
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST typeArgument_AST = null;
		Token first = LT(1);
		switch ( LA(1)) {
		case :
			astFactory.addASTChild(currentAST, returnAST);
			break;
		case :