// $ANTLR 2.7.2: "groovy.g" -> "GroovyRecognizer.java"$
   
   package org.codehaus.groovy.antlr.parser;
   import org.codehaus.groovy.antlr.*;
   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 java.util.Hashtable;
  import antlr.ASTFactory;
  import antlr.ASTPair;
  import antlr.collections.impl.ASTArray;
  
  /*** JSR-241 Groovy Recognizer
   *
   * Run 'java Main [-showtree] directory-full-of-groovy-files'
   *
   * [The -showtree option pops up a Swing frame that shows
   *  the AST constructed from the parser.]
   *
   * Contributing authors:
   *              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
   *              James Strachan          jstrachan@protique.com
   *              John Pybus              john@pybus.org
   *              John Rose               rose00@mac.com
   *              Jeremy Rayner           groovy@ross-rayner.com
   *
   * 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.g.1
  *    o I have taken java.g for Java1.5 from Michael Studman (1.22.4)
  *      and have applied the groovy.diff from java.g (1.22) by John Rose
  *      back onto the new root (1.22.4) - Jeremy Rayner (Jan 2005)
  *    o for a map of the task see... 
  *      http://groovy.javanicus.com/java-g.png
  *
  * This grammar is in the PUBLIC DOMAIN
  */
 public class GroovyRecognizer extends antlr.LLkParser       implements GroovyTokenTypes
  {
 
         /*** This factory is the correct way to wire together a Groovy parser and lexer. */
     public static GroovyRecognizer make(GroovyLexer lexer) {
         GroovyRecognizer parser = new GroovyRecognizer(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");
         parser.warningList = new ArrayList();
         return parser;
     }
     // Create a scanner that reads from the input stream passed to us...
     public static GroovyRecognizer make(InputStream in) { return make(new GroovyLexer(in)); }
     public static GroovyRecognizer make(Reader in) { return make(new GroovyLexer(in)); }
     public static GroovyRecognizer make(InputBuffer in) { return make(new GroovyLexer(in)); }
     public static GroovyRecognizer make(LexerSharedInputState in) { return make(new GroovyLexer(in)); }
     
     private static GroovySourceAST dummyVariableToforceClassLoaderToFindASTClass = new GroovySourceAST();
 
     List warningList;
     public List getWarningList() { return warningList; }
     
     GroovyLexer lexer;
     public GroovyLexer getLexer() { return lexer; }
     public void setFilename(String f) { super.setFilename(f); lexer.setFilename(f); }
     private SourceBuffer sourceBuffer;
     public void setSourceBuffer(SourceBuffer sourceBuffer) {
         this.sourceBuffer = 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 type, String 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;
     }
 
 
     // stuff to adjust ANTLR's tracing machinery
     public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceParser
     public void traceIn(String rname) throws TokenStreamException {
         if (!GroovyRecognizer.tracing)  return;
         super.traceIn(rname);
     }
     public void traceOut(String rname) throws TokenStreamException {
         if (!GroovyRecognizer.tracing)  return;
         if (returnAST != null)  rname += returnAST.toStringList();
         super.traceOut(rname);
     }
         
     // Error handling.  This is a funnel through which parser errors go, when the parser can suggest a solution.
     public void requireFailed(String problem, String solution) throws SemanticException {
         // TODO: Needs more work.
         Token lt = null;
         try { lt = LT(1); }
         catch (TokenStreamException ee) { }
         if (lt == null)  lt = Token.badToken;
         throw new SemanticException(problem + ";\n   solution: " + solution,
                                     getFilename(), lt.getLine(), lt.getColumn());
     }
 
     public void addWarning(String warning, String solution) {
         Token lt = null;
         try { lt = LT(1); }
         catch (TokenStreamException ee) { }
         if (lt == null)  lt = Token.badToken;
 
         Map row = new HashMap();
         row.put("warning" ,warning);
         row.put("solution",solution);
         row.put("filename",getFilename());
         row.put("line"    ,new Integer(lt.getLine()));
         row.put("column"  ,new Integer(lt.getColumn()));
         // System.out.println(row);
         warningList.add(row);
     }
 
     // Convenience method for checking of expected error syndromes.
     private void require(boolean z, String problem, String solution) throws SemanticException {
         if (!z)  requireFailed(problem, solution);
     }
 
 
     // Query a name token to see if it begins with a capital letter.
     // This is used to tell the difference (w/o symbol table access) between {String x} and {println x}.
     private boolean isUpperCase(Token x) {
         if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
         String xtext = x.getText();
         return (xtext.length() > 0 && Character.isUpperCase(xtext.charAt(0)));
     }
 
     private AST currentClass = null;  // current enclosing class (for constructor recognition)
     // Query a name token to see if it is identical with the current class name.
     // This is used to distinguish constructors from other methods.
     private boolean isConstructorIdent(Token x) {
         if (currentClass == null)  return false;
         if (currentClass.getType() != IDENT)  return false;  // cannot happen?
         String cname = currentClass.getText();
 
         if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
         return cname.equals(x.getText());
     }
 
     // Scratch variable for last 'sep' token.
     // Written by the 'sep' rule, read only by immediate callers of 'sep'.
     // (Not entirely clean, but better than a million xx=sep occurrences.)
     private int sepToken = EOF;
 
     // Scratch variable for last argument list; tells whether there was a label.
     // Written by 'argList' rule, read only by immediate callers of 'argList'.
     private boolean argListHasLabels = false;
 
     // Scratch variable, holds most recently completed pathExpression.
     // Read only by immediate callers of 'pathExpression' and 'expression'.
     private AST lastPathExpression = null;
 
     // Inherited attribute pushed into most expression rules.
     // If not zero, it means that the left context of the expression
     // being parsed is a statement boundary or an initializer sign '='.
     // Only such expressions are allowed to reach across newlines
     // to pull in an LCURLY and appended block.
     private final int LC_STMT = 1, LC_INIT = 2;
 
     /***
      * 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;
     
     /* This symbol is used to work around a known ANTLR limitation.
      * In a loop with syntactic predicate, ANTLR needs help knowing
      * that the loop exit is a second alternative.
      * Example usage:  ( (LCURLY)=> block | {ANTLR_LOOP_EXIT}? )*
      * Probably should be an ANTLR RFE.
      */
     ////// Original comment in Java grammar:
     // Unfortunately a syntactic predicate can only select one of
     // multiple alternatives on the same level, not break out of
     // an enclosing loop, which is why this ugly hack (a fake
     // empty alternative with always-false semantic predicate)
     // is necessary.
     private static final boolean ANTLR_LOOP_EXIT = false;
 
 protected GroovyRecognizer(TokenBuffer tokenBuf, int k) {
   super(tokenBuf,k);
   tokenNames = _tokenNames;
   buildTokenTypeASTClassMap();
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 public GroovyRecognizer(TokenBuffer tokenBuf) {
   this(tokenBuf,3);
 }
 
 protected GroovyRecognizer(TokenStream lexer, int k) {
   super(lexer,k);
   tokenNames = _tokenNames;
   buildTokenTypeASTClassMap();
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 public GroovyRecognizer(TokenStream lexer) {
   this(lexer,3);
 }
 
 public GroovyRecognizer(ParserSharedInputState state) {
   super(state,3);
   tokenNames = _tokenNames;
   buildTokenTypeASTClassMap();
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 	public final void compilationUnit() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST compilationUnit_AST = null;
 		
 		{
 		switch ( LA(1)) {
 		case SH_COMMENT:
 		{
 			match(SH_COMMENT);
 			break;
 		}
 		case EOF:
 		case FINAL:
 		case ABSTRACT:
 		case STRICTFP:
 		caseg> LITERAL_package:
 		case LITERAL_import:
 		case LITERAL_static:
 		case LITERAL_def:
 		case AT:
 		case IDENT:
 		case LBRACK:
 		case LPAREN:
 		case LITERAL_class:
 		case LITERAL_interface:
 		case LITERAL_enum:
 		case LITERAL_super:
 		case LITERAL_void:
 		case LITERAL_boolean:
 		case LITERAL_byte:
 		case LITERAL_char:
 		case LITERAL_short:
 		case LITERAL_int:
 		case LITERAL_float:
 		case LITERAL_long:
 		case LITERAL_double:
 		case LITERAL_any:
 		case STAR:
 		case LITERAL_private:
 		case LITERAL_public:
 		case LITERAL_protected:
 		case LITERAL_transient:
 		case LITERAL_native:
 		case LITERAL_threadsafe:
 		case LITERAL_synchronized:
 		case LITERAL_volatile:
 		case LCURLY:
 		case SEMI:
 		case NLS:
 		case LITERAL_this:
 		case STRING_LITERAL:
 		case LITERAL_if:
 		case LITERAL_while:
 		case LITERAL_with:
 		case LITERAL_switch:
 		case LITERAL_for:
 		case LITERAL_return:
 		case LITERAL_break:
 		case LITERAL_continue:
 		case LITERAL_throw:
 		case LITERAL_assert:
 		case PLUS:
 		case MINUS:
 		case LITERAL_try:
 		case INC:
 		case DEC:
 		case BNOT:
 		case LNOT:
 		case DOLLAR:
 		case STRING_CTOR_START:
 		case LITERAL_new:
 		case LITERAL_true:
 		case LITERAL_false:
 		case LITERAL_null:
 		case NUM_INT:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		case NUM_BIG_INT:
 		case NUM_BIG_DECIMAL:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		nls();
 		{
 		boolean synPredMatched5 = false;
 		if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT) && (_tokenSet_0.member(LA(3))))) {
 			int _m5 = mark();
 			synPredMatched5 = true;
 			inputState.guessing++;
 			try {
 				{
 				annotationsOpt();
 				match(LITERAL_package);
 				}
 			}
 			catch (RecognitionException pe) {
 				synPredMatched5 = false;
 			}
 			rewind(_m5);
 			inputState.guessing--;
 		}
 		if ( synPredMatched5 ) {
 			packageDefinition();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
 			{
 			switch ( LA(1)) {
 			case FINAL:
 			case ABSTRACT:
 			case STRICTFP:
 			case LITERAL_import:
 			case LITERAL_static:
 			case LITERAL_def:
 			case AT:
 			case IDENT:
 			case LBRACK:
 			case LPAREN:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			case LITERAL_super:
 			case LITERAL_void:
 			case LITERAL_boolean:
 			case LITERAL_byte:
 			case LITERAL_char:
 			case LITERAL_short:
 			case LITERAL_int:
 			case LITERAL_float:
 			case LITERAL_long:
 			case LITERAL_double:
 			case LITERAL_any:
 			case STAR:
 			case LITERAL_private:
 			case LITERAL_public:
 			case LITERAL_protected:
 			case LITERAL_transient:
 			case LITERAL_native:
 			case LITERAL_threadsafe:
 			case LITERAL_synchronized:
 			case LITERAL_volatile:
 			case LCURLY:
 			case LITERAL_this:
 			case STRING_LITERAL:
 			case LITERAL_if:
 			case LITERAL_while:
 			case LITERAL_with:
 			case LITERAL_switch:
 			case LITERAL_for:
 			case LITERAL_return:
 			case LITERAL_break:
 			case LITERAL_continue:
 			case LITERAL_throw:
 			case LITERAL_assert:
 			case PLUS:
 			case MINUS:
 			case LITERAL_try:
 			case INC:
 			case DEC:
 			case BNOT:
 			case LNOT:
 			case DOLLAR:
 			case STRING_CTOR_START:
 			case LITERAL_new:
 			case LITERAL_true:
 			case LITERAL_false:
 			case LITERAL_null:
 			case NUM_INT:
 			case NUM_FLOAT:
 			case NUM_LONG:
 			case NUM_DOUBLE:
 			case NUM_BIG_INT:
 			case NUM_BIG_DECIMAL:
 			{
 				statement(EOF);
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case EOF:
 			case SEMI:
 			case NLS:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		{
 		_loop9:
 		do {
 			if ((LA(1)==SEMI||LA(1)==NLS)) {
 				sep();
 				{
 				switch ( LA(1)) {
 				case FINAL:
 				case ABSTRACT:
 				case STRICTFP:
 				case LITERAL_import:
 				case LITERAL_static:
 				case LITERAL_def:
 				case AT:
 				case IDENT:
 				case LBRACK:
 				case LPAREN:
 				case LITERAL_class:
 				case LITERAL_interface:
 				case LITERAL_enum:
 				case LITERAL_super:
 				case LITERAL_void:
 				case LITERAL_boolean:
 				case LITERAL_byte:
 				case LITERAL_char:
 				case LITERAL_short:
 				case LITERAL_int:
 				case LITERAL_float:
 				case LITERAL_long:
 				case LITERAL_double:
 				case LITERAL_any:
 				case STAR:
 				case LITERAL_private:
 				case LITERAL_public:
 				case LITERAL_protected:
 				case LITERAL_transient:
 				case LITERAL_native:
 				case LITERAL_threadsafe:
 				case LITERAL_synchronized:
 				case LITERAL_volatile:
 				case LCURLY:
 				case LITERAL_this:
 				case STRING_LITERAL:
 				case LITERAL_if:
 				case LITERAL_while:
 				case LITERAL_with:
 				case LITERAL_switch:
 				case LITERAL_for:
 				case LITERAL_return:
 				case LITERAL_break:
 				case LITERAL_continue:
 				case LITERAL_throw:
 				case LITERAL_assert:
 				case PLUS:
 				case MINUS:
 				case LITERAL_try:
 				case INC:
 				case DEC:
 				case BNOT:
 				case LNOT:
 				case DOLLAR:
 				case STRING_CTOR_START:
 				case LITERAL_new:
 				case LITERAL_true:
 				case LITERAL_false:
 				case LITERAL_null:
 				case NUM_INT:
 				case NUM_FLOAT:
 				case NUM_LONG:
 				case NUM_DOUBLE:
 				case NUM_BIG_INT:
 				case NUM_BIG_DECIMAL:
 				{
 					statement(sepToken);
 					astFactory.addASTChild(currentAST, returnAST);
 					break;
 				}
 				case EOF:
 				case SEMI:
 				case NLS:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 			}
 			else {
 				break _loop9;
 			}
 			
 		} while (true);
 		}
 		match(Token.EOF_TYPE);
 		compilationUnit_AST = (AST)currentAST.root;
 		returnAST = compilationUnit_AST;
 	}
 	
 /*** Zero or more insignificant newlines, all gobbled up and thrown away. */
 	public final void nls() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST nls_AST = null;
 		
 		{
 		if ((LA(1)==NLS) && (_tokenSet_4.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
 			match(NLS);
 		}
 		else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		returnAST = nls_AST;
 	}
 	
 	public final void annotationsOpt() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationsOpt_AST = null;
 		Token first = LT(1);
 		
 		{
 		_loop79:
 		do {
 			if ((LA(1)==AT)) {
 				annotation();
 				astFactory.addASTChild(currentAST, returnAST);
 				nls();
 			}
 			else {
 				break _loop79;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			annotationsOpt_AST = (AST)currentAST.root;
 			annotationsOpt_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ANNOTATIONS,"ANNOTATIONS",first,LT(1))).add(annotationsOpt_AST));
 			currentAST.root = annotationsOpt_AST;
 			currentAST.child = annotationsOpt_AST!=null &&annotationsOpt_AST.getFirstChild()!=null ?
 				annotationsOpt_AST.getFirstChild() : annotationsOpt_AST;
 			currentAST.advanceChildToEnd();
 		}
 		annotationsOpt_AST = (AST)currentAST.root;
 		returnAST = annotationsOpt_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;
 		
 		annotationsOpt();
 		astFactory.addASTChild(currentAST, returnAST);
 		p = LT(1);
 		p_AST = astFactory.create(p);
 		astFactory.makeASTRoot(currentAST, p_AST);
 		match(LITERAL_package);
 		if ( inputState.guessing==0 ) {
 			p_AST.setType(PACKAGE_DEF);
 		}
 		identifier();
 		astFactory.addASTChild(currentAST, returnAST);
 		packageDefinition_AST = (AST)currentAST.root;
 		returnAST = packageDefinition_AST;
 	}
 	
 /*** A statement is an element of a block.
  *  Typical statements are declarations (which are scoped to the block)
  *  and expressions.
  */
 	public final void statement(
 		int prevToken
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST statement_AST = null;
 		AST pfx_AST = null;
 		AST m_AST = null;
 		Token  sp = null;
 		AST sp_AST = null;
 		
 		switch ( LA(1)) {
 		case LITERAL_if:
 		{
 			AST tmp4_AST = null;
 			tmp4_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp4_AST);
 			match(LITERAL_if);
 			match(LPAREN);
 			assignmentLessExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			nlsWarn();
 			compatibleBodyStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			boolean synPredMatched251 = false;
 			if (((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2))) && (_tokenSet_8.member(LA(3))))) {
 				int _m251 = mark();
 				synPredMatched251 = true;
 				inputState.guessing++;
 				try {
 					{
 					{
 					switch ( LA(1)) {
 					case SEMI:
 					case NLS:
 					{
 						sep();
 						break;
 					}
 					case LITERAL_else:
 					{
 						break;
 					}
 					default:
 					{
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					}
 					}
 					match(LITERAL_else);
 					}
 				}
 				catch (RecognitionException pe) {
 					synPredMatched251 = false;
 				}
 				rewind(_m251);
 				inputState.guessing--;
 			}
 			if ( synPredMatched251 ) {
 				{
 				switch ( LA(1)) {
 				case SEMI:
 				case NLS:
 				{
 					sep();
 					break;
 				}
 				case LITERAL_else:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				match(LITERAL_else);
 				nlsWarn();
 				compatibleBodyStatement();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
 			}
 			else {
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			
 			}
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_for:
 		{
 			forStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_while:
 		{
 			AST tmp8_AST = null;
 			tmp8_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp8_AST);
 			match(LITERAL_while);
 			match(LPAREN);
 			strictContextExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			nlsWarn();
 			compatibleBodyStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_with:
 		{
 			AST tmp11_AST = null;
 			tmp11_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp11_AST);
 			match(LITERAL_with);
 			match(LPAREN);
 			strictContextExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			nlsWarn();
 			compoundStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case STAR:
 		{
 			sp = LT(1);
 			sp_AST = astFactory.create(sp);
 			astFactory.makeASTRoot(currentAST, sp_AST);
 			match(STAR);
 			nls();
 			if ( inputState.guessing==0 ) {
 				sp_AST.setType(SPREAD_ARG);
 			}
 			expressionStatement(EOF);
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_import:
 		{
 			importStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_switch:
 		{
 			AST tmp14_AST = null;
 			tmp14_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp14_AST);
 			match(LITERAL_switch);
 			match(LPAREN);
 			strictContextExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			nlsWarn();
 			match(LCURLY);
 			nls();
 			{
 			_loop254:
 			do {
 				if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case)) {
 					casesGroup();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop254;
 				}
 				
 			} while (true);
 			}
 			match(RCURLY);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_try:
 		{
 			tryBlock();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_return:
 		case LITERAL_break:
 		case LITERAL_continue:
 		case LITERAL_throw:
 		case LITERAL_assert:
 		{
 			branchStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 			boolean synPredMatched242 = false;
 			if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))) && (_tokenSet_14.member(LA(3))))) {
 				int _m242 = mark();
 				synPredMatched242 = true;
 				inputState.guessing++;
 				try {
 					{
 					declarationStart();
 					}
 				}
 				catch (RecognitionException pe) {
 					synPredMatched242 = false;
 				}
 				rewind(_m242);
 				inputState.guessing--;
 			}
 			if ( synPredMatched242 ) {
 				declaration();
 				astFactory.addASTChild(currentAST, returnAST);
 				statement_AST = (AST)currentAST.root;
 			}
 			else {
 				boolean synPredMatched244 = false;
 				if (((LA(1)==IDENT) && (LA(2)==COLON) && (_tokenSet_15.member(LA(3))))) {
 					int _m244 = mark();
 					synPredMatched244 = true;
 					inputState.guessing++;
 					try {
 						{
 						match(IDENT);
 						match(COLON);
 						}
 					}
 					catch (RecognitionException pe) {
 						synPredMatched244 = false;
 					}
 					rewind(_m244);
 					inputState.guessing--;
 				}
 				if ( synPredMatched244 ) {
 					statementLabelPrefix();
 					pfx_AST = (AST)returnAST;
 					if ( inputState.guessing==0 ) {
 						statement_AST = (AST)currentAST.root;
 						statement_AST = pfx_AST;
 						currentAST.root = statement_AST;
 						currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
 							statement_AST.getFirstChild() : statement_AST;
 						currentAST.advanceChildToEnd();
 					}
 					{
 					boolean synPredMatched247 = false;
 					if (((LA(1)==LCURLY) && (_tokenSet_16.member(LA(2))) && (_tokenSet_8.member(LA(3))))) {
 						int _m247 = mark();
 						synPredMatched247 = true;
 						inputState.guessing++;
 						try {
 							{
 							match(LCURLY);
 							}
 						}
 						catch (RecognitionException pe) {
 							synPredMatched247 = false;
 						}
 						rewind(_m247);
 						inputState.guessing--;
 					}
 					if ( synPredMatched247 ) {
 						openOrClosableBlock();
 						astFactory.addASTChild(currentAST, returnAST);
 					}
 					else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_18.member(LA(3)))) {
 						statement(COLON);
 						astFactory.addASTChild(currentAST, returnAST);
 					}
 					else {
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					
 					}
 					statement_AST = (AST)currentAST.root;
 				}
 				else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
 					expressionStatement(prevToken);
 					astFactory.addASTChild(currentAST, returnAST);
 					statement_AST = (AST)currentAST.root;
 				}
 				else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))) && (_tokenSet_23.member(LA(3)))) {
 					modifiersOpt();
 					m_AST = (AST)returnAST;
 					typeDefinitionInternal(m_AST);
 					astFactory.addASTChild(currentAST, returnAST);
 					statement_AST = (AST)currentAST.root;
 				}
 				else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
 					AST tmp19_AST = null;
 					tmp19_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp19_AST);
 					match(LITERAL_synchronized);
 					match(LPAREN);
 					strictContextExpression();
 					astFactory.addASTChild(currentAST, returnAST);
 					match(RPAREN);
 					nlsWarn();
 					compoundStatement();
 					astFactory.addASTChild(currentAST, returnAST);
 					statement_AST = (AST)currentAST.root;
 				}
 			else {
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}}
 			returnAST = statement_AST;
 		}
 		
 /*** A statement separator is either a semicolon or a significant newline. 
  *  Any number of additional (insignificant) newlines may accompany it.
  */
 	public final void sep() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST sep_AST = null;
 		
 		switch ( LA(1)) {
 		case SEMI:
 		{
 			match(SEMI);
 			{
 			_loop475:
 			do {
 				if ((LA(1)==NLS) && (_tokenSet_24.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
 					match(NLS);
 				}
 				else {
 					break _loop475;
 				}
 				
 			} while (true);
 			}
 			if ( inputState.guessing==0 ) {
 				sepToken = SEMI;
 			}
 			break;
 		}
 		case NLS:
 		{
 			match(NLS);
 			if ( inputState.guessing==0 ) {
 				sepToken = NLS;
 			}
 			{
 			_loop479:
 			do {
 				if ((LA(1)==SEMI) && (_tokenSet_24.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
 					match(SEMI);
 					{
 					_loop478:
 					do {
 						if ((LA(1)==NLS) && (_tokenSet_24.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
 							match(NLS);
 						}
 						else {
 							break _loop478;
 						}
 						
 					} while (true);
 					}
 					if ( inputState.guessing==0 ) {
 						sepToken = SEMI;
 					}
 				}
 				else {
 					break _loop479;
 				}
 				
 			} while (true);
 			}
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = sep_AST;
 	}
 	
 /*** A Groovy script or simple expression.  Can be anything legal inside {...}. */
 	public final void snippetUnit() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST snippetUnit_AST = null;
 		
 		nls();
 		blockBody(EOF);
 		astFactory.addASTChild(currentAST, returnAST);
 		snippetUnit_AST = (AST)currentAST.root;
 		returnAST = snippetUnit_AST;
 	}
 	
 /*** A block body is a parade of zero or more statements or expressions. */
 	public final void blockBody(
 		int prevToken
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST blockBody_AST = null;
 		
 		{
 		switch ( LA(1)) {
 		case FINAL:
 		case ABSTRACT:
 		case STRICTFP:
 		case LITERAL_import:
 		case LITERAL_static:
 		case LITERAL_def:
 		case AT:
 		case IDENT:
 		case LBRACK:
 		case LPAREN:
 		case LITERAL_class:
 		case LITERAL_interface:
 		case LITERAL_enum:
 		case LITERAL_super:
 		case LITERAL_void:
 		case LITERAL_boolean:
 		case LITERAL_byte:
 		case LITERAL_char:
 		case LITERAL_short:
 		case LITERAL_int:
 		case LITERAL_float:
 		case LITERAL_long:
 		case LITERAL_double:
 		case LITERAL_any:
 		case STAR:
 		case LITERAL_private:
 		case LITERAL_public:
 		case LITERAL_protected:
 		case LITERAL_transient:
 		case LITERAL_native:
 		case LITERAL_threadsafe:
 		case LITERAL_synchronized:
 		case LITERAL_volatile:
 		case LCURLY:
 		case LITERAL_this:
 		case STRING_LITERAL:
 		case LITERAL_if:
 		case LITERAL_while:
 		case LITERAL_with:
 		case LITERAL_switch:
 		case LITERAL_for:
 		case LITERAL_return:
 		case LITERAL_break:
 		case LITERAL_continue:
 		case LITERAL_throw:
 		case LITERAL_assert:
 		case PLUS:
 		case MINUS:
 		case LITERAL_try:
 		case INC:
 		case DEC:
 		case BNOT:
 		case LNOT:
 		case DOLLAR:
 		case STRING_CTOR_START:
 		case LITERAL_new:
 		case LITERAL_true:
 		case LITERAL_false:
 		case LITERAL_null:
 		case NUM_INT:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		case NUM_BIG_INT:
 		case NUM_BIG_DECIMAL:
 		{
 			statement(prevToken);
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case EOF:
 		case RCURLY:
 		case SEMI:
 		case NLS:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		{
 		_loop236:
 		do {
 			if ((LA(1)==SEMI||LA(1)==NLS)) {
 				sep();
 				{
 				switch ( LA(1)) {
 				case FINAL:
 				case ABSTRACT:
 				case STRICTFP:
 				case LITERAL_import:
 				case LITERAL_static:
 				case LITERAL_def:
 				case AT:
 				case IDENT:
 				case LBRACK:
 				case LPAREN:
 				case LITERAL_class:
 				case LITERAL_interface:
 				case LITERAL_enum:
 				case LITERAL_super:
 				case LITERAL_void:
 				case LITERAL_boolean:
 				case LITERAL_byte:
 				case LITERAL_char:
 				case LITERAL_short:
 				case LITERAL_int:
 				case LITERAL_float:
 				case LITERAL_long:
 				case LITERAL_double:
 				case LITERAL_any:
 				case STAR:
 				case LITERAL_private:
 				case LITERAL_public:
 				case LITERAL_protected:
 				case LITERAL_transient:
 				case LITERAL_native:
 				case LITERAL_threadsafe:
 				case LITERAL_synchronized:
 				case LITERAL_volatile:
 				case LCURLY:
 				case LITERAL_this:
 				case STRING_LITERAL:
 				case LITERAL_if:
 				case LITERAL_while:
 				case LITERAL_with:
 				case LITERAL_switch:
 				case LITERAL_for:
 				case LITERAL_return:
 				case LITERAL_break:
 				case LITERAL_continue:
 				case LITERAL_throw:
 				case LITERAL_assert:
 				case PLUS:
 				case MINUS:
 				case LITERAL_try:
 				case INC:
 				case DEC:
 				case BNOT:
 				case LNOT:
 				case DOLLAR:
 				case STRING_CTOR_START:
 				case LITERAL_new:
 				case LITERAL_true:
 				case LITERAL_false:
 				case LITERAL_null:
 				case NUM_INT:
 				case NUM_FLOAT:
 				case NUM_LONG:
 				case NUM_DOUBLE:
 				case NUM_BIG_INT:
 				case NUM_BIG_DECIMAL:
 				{
 					statement(sepToken);
 					astFactory.addASTChild(currentAST, returnAST);
 					break;
 				}
 				case EOF:
 				case RCURLY:
 				case SEMI:
 				case NLS:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 			}
 			else {
 				break _loop236;
 			}
 			
 		} while (true);
 		}
 		blockBody_AST = (AST)currentAST.root;
 		returnAST = blockBody_AST;
 	}
 	
 	public final void identifier() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST identifier_AST = null;
 		
 		AST tmp27_AST = null;
 		tmp27_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentAST, tmp27_AST);
 		match(IDENT);
 		{
 		_loop62:
 		do {
 			if ((LA(1)==DOT)) {
 				AST tmp28_AST = null;
 				tmp28_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp28_AST);
 				match(DOT);
 				nls();
 				AST tmp29_AST = null;
 				tmp29_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp29_AST);
 				match(IDENT);
 			}
 			else {
 				break _loop62;
 			}
 			
 		} while (true);
 		}
 		identifier_AST = (AST)currentAST.root;
 		returnAST = identifier_AST;
 	}
 	
 	public final void importStatement() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST importStatement_AST = null;
 		Token  i = null;
 		AST i_AST = null;
 		boolean isStatic = false;
 		
 		i = LT(1);
 		i_AST = astFactory.create(i);
 		astFactory.makeASTRoot(currentAST, i_AST);
 		match(LITERAL_import);
 		if ( inputState.guessing==0 ) {
 			i_AST.setType(IMPORT);
 		}
 		{
 		switch ( LA(1)) {
 		case LITERAL_static:
 		{
 			match(LITERAL_static);
 			if ( inputState.guessing==0 ) {
 				i_AST.setType(STATIC_IMPORT);
 			}
 			break;
 		}
 		case IDENT:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		identifierStar();
 		astFactory.addASTChild(currentAST, returnAST);
 		importStatement_AST = (AST)currentAST.root;
 		returnAST = importStatement_AST;
 	}
 	
 	public final void identifierStar() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST identifierStar_AST = null;
 		
 		AST tmp31_AST = null;
 		tmp31_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentAST, tmp31_AST);
 		match(IDENT);
 		{
 		_loop65:
 		do {
 			if ((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==NLS) && (_tokenSet_25.member(LA(3)))) {
 				AST tmp32_AST = null;
 				tmp32_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp32_AST);
 				match(DOT);
 				nls();
 				AST tmp33_AST = null;
 				tmp33_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp33_AST);
 				match(IDENT);
 			}
 			else {
 				break _loop65;
 			}
 			
 		} while (true);
 		}
 		{
 		switch ( LA(1)) {
 		case DOT:
 		{
 			AST tmp34_AST = null;
 			tmp34_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp34_AST);
 			match(DOT);
 			nls();
 			AST tmp35_AST = null;
 			tmp35_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp35_AST);
 			match(STAR);
 			break;
 		}
 		case LITERAL_as:
 		{
 			AST tmp36_AST = null;
 			tmp36_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp36_AST);
 			match(LITERAL_as);
 			nls();
 			AST tmp37_AST = null;
 			tmp37_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp37_AST);
 			match(IDENT);
 			break;
 		}
 		case EOF:
 		case RCURLY:
 		case SEMI:
 		case NLS:
 		case LITERAL_default:
 		case LITERAL_else:
 		case LITERAL_case:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		identifierStar_AST = (AST)currentAST.root;
 		returnAST = identifierStar_AST;
 	}
 	
 	protected final void typeDefinitionInternal(
 		AST mods
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeDefinitionInternal_AST = null;
 		AST cd_AST = null;
 		AST id_AST = null;
 		AST ed_AST = null;
 		AST ad_AST = null;
 		
 		switch ( LA(1)) {
 		case LITERAL_class:
 		{
 			classDefinition(mods);
 			cd_AST = (AST)returnAST;
 			astFactory.addASTChild(currentAST, returnAST);
 			if ( inputState.guessing==0 ) {
 				typeDefinitionInternal_AST = (AST)currentAST.root;
 				typeDefinitionInternal_AST = cd_AST;
 				currentAST.root = typeDefinitionInternal_AST;
 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
 				currentAST.advanceChildToEnd();
 			}
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_interface:
 		{
 			interfaceDefinition(mods);
 			id_AST = (AST)returnAST;
 			astFactory.addASTChild(currentAST, returnAST);
 			if ( inputState.guessing==0 ) {
 				typeDefinitionInternal_AST = (AST)currentAST.root;
 				typeDefinitionInternal_AST = id_AST;
 				currentAST.root = typeDefinitionInternal_AST;
 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
 				currentAST.advanceChildToEnd();
 			}
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_enum:
 		{
 			enumDefinition(mods);
 			ed_AST = (AST)returnAST;
 			astFactory.addASTChild(currentAST, returnAST);
 			if ( inputState.guessing==0 ) {
 				typeDefinitionInternal_AST = (AST)currentAST.root;
 				typeDefinitionInternal_AST = ed_AST;
 				currentAST.root = typeDefinitionInternal_AST;
 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
 				currentAST.advanceChildToEnd();
 			}
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case AT:
 		{
 			annotationDefinition(mods);
 			ad_AST = (AST)returnAST;
 			astFactory.addASTChild(currentAST, returnAST);
 			if ( inputState.guessing==0 ) {
 				typeDefinitionInternal_AST = (AST)currentAST.root;
 				typeDefinitionInternal_AST = ad_AST;
 				currentAST.root = typeDefinitionInternal_AST;
 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
 				currentAST.advanceChildToEnd();
 			}
 			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 prevCurrentClass = currentClass;
 		
 		match(LITERAL_class);
 		AST tmp39_AST = null;
 		tmp39_AST = astFactory.create(LT(1));
 		match(IDENT);
 		nls();
 		if ( inputState.guessing==0 ) {
 			currentClass = tmp39_AST;
 		}
 		{
 		switch ( LA(1)) {
 		case LT:
 		{
 			typeParameters();
 			tp_AST = (AST)returnAST;
 			break;
 		}
 		case LITERAL_extends:
 		case LCURLY:
 		case LITERAL_implements:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}