/groovy-eclipse/org.codehaus.groovy.eclipse.core/src/org/codehaus/groovy/eclipse/core/compiler/internal/antlr/GroovyRecognizer.java

Large files files are truncated, but you can click here to view the full file

// $ANTLR 2.7.7 (20060930): "groovy.g" -> "GroovyRecognizer.java"$


package org.codehaus.groovy.eclipse.core.compiler.internal.antlr;
import org.codehaus.groovy.antlr.*;
import java.util.*;
import java.io.InputStream;
import java.io.Reader;
import antlr.InputBuffer;
import antlr.LexerSharedInputState;
import antlr.CommonToken;
import org.codehaus.groovy.GroovyBugError;
import antlr.TokenStreamRecognitionException;


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
 *              Alex Popescu            the.mindstorm@gmail.com
 *              Martin Kempf            mkempf@hsr.ch
 *              Reto Kleeb              rkleeb@hsr.ch
 *
 * 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
 * 
 * Version 1.22.4.g.2
 *    o mkempf, rkleeb, Dec 2007
 *    o fixed various rules so that they call the correct Create Method
 *      to make sure that the line information are correct
 *
 * 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.getASTFactory().setASTNodeClass(GroovySourceAST.class);
        parser.warningList = new ArrayList();

        parser.errorList = 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; }

    List errorList;

    public List getErrorList() { return errorList; }


    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.&nbsp;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, AST first) {
        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);
        }
        return t;
    }
    
    private AST attachLast(AST t, Object last) {
    	if ((t instanceof GroovySourceAST) && (last instanceof SourceInfo)) {
            SourceInfo lastInfo = (SourceInfo) last;
            GroovySourceAST node = (GroovySourceAST)t;
            node.setColumnLast(lastInfo.getColumn());
            node.setLineLast(lastInfo.getLine());
            // This is a good point to call node.setSnippet(),
            // but it bulks up the AST too much for production code.
        }
        return t;
    }
     
    public AST create(int type, String txt, Token first, Token last) {
        return attachLast(create(type, txt, astFactory.create(first)), last);
    }
    
    public AST create(int type, String txt, AST first, Token last) {
        return attachLast(create(type, txt, first), last);
    }
    
    public AST create(int type, String txt, AST first, AST last) {
        return attachLast(create(type, txt, first), last);
    }
    
    /** 
    *   Clones the token
    */
    public Token cloneToken(Token t) {
        CommonToken clone = new CommonToken(t.getType(),t.getText());
        clone.setLine(t.getLine());
        clone.setColumn(t.getColumn());
        return clone;
    }


    // 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;
        int lineNum = Token.badToken.getLine(), colNum = Token.badToken.getColumn();
        try { 
            lt = LT(1);
            if(lt != null) {
                lineNum = lt.getLine();
                colNum = lt.getColumn();
            }
        }
        catch (TokenStreamException ee) {
            if(ee instanceof TokenStreamRecognitionException) {
                lineNum = ((TokenStreamRecognitionException) ee).recog.getLine();
                colNum = ((TokenStreamRecognitionException) ee).recog.getColumn();
            }
        }
        throw new SemanticException(problem + ";\n   solution: " + solution,
                                    getFilename(), lineNum, colNum);
    }

    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",     Integer.valueOf(lt.getLine()));
        row.put("column",   Integer.valueOf(lt.getColumn()));
        // System.out.println(row);
        warningList.add(row);
    }

    /**

     * Report a recovered error.

     */

    public void reportError(String message) {

        Token lt = null;

        try { lt = LT(1); }

        catch (TokenStreamException ee) { }

        if (lt == null)  lt = Token.badToken;



        Map row = new HashMap();

        row.put("error" ,message);

        row.put("filename", getFilename());

        row.put("line", new Integer(lt.getLine()));

        row.put("column", new Integer(lt.getColumn()));

        errorList.add(row);

    }

    

    /**

     * Report a recovered exception.

     */

    public void reportError(RecognitionException e) {

        Token lt = null;

        try { lt = LT(1); }

        catch (TokenStreamException ee) { }

        if (lt == null)  lt = Token.badToken;



        Map row = new HashMap();

        row.put("error", e.getMessage());

        row.put("filename", getFilename());

        row.put("line",new Integer(lt.getLine()));

        row.put("column", new Integer(lt.getColumn()));

        errorList.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);
    }

    private boolean matchGenericTypeBrackets(boolean z, String problem, String solution) throws SemanticException {
        if (!z)  matchGenericTypeBracketsFailed(problem, solution);
        return z;
    }

    public void matchGenericTypeBracketsFailed(String problem, String solution) throws SemanticException {
        Token lt = null;
        int lineNum = Token.badToken.getLine(), colNum = Token.badToken.getColumn();
        
        try { 
            lt = LT(1);
            if(lt != null) {
                lineNum = lt.getLine();
                colNum = lt.getColumn();
            }
        }
        catch (TokenStreamException ee) {
            if(ee instanceof TokenStreamRecognitionException) {
                lineNum = ((TokenStreamRecognitionException) ee).recog.getLine();
                colNum = ((TokenStreamRecognitionException) ee).recog.getColumn();
            }
        }
        
        throw new SemanticException(problem + ";\n   solution: " + solution,
                                    getFilename(), lineNum, colNum);
   }

    // 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,2);

}



protected GroovyRecognizer(TokenStream lexer, int k) {

  super(lexer,k);

  tokenNames = _tokenNames;

  buildTokenTypeASTClassMap();

  astFactory = new ASTFactory(getTokenTypeToASTClassMap());

}



public GroovyRecognizer(TokenStream lexer) {

  this(lexer,2);

}



public GroovyRecognizer(ParserSharedInputState state) {

  super(state,2);

  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:

		case LITERAL_package:

		case LITERAL_import:

		case LITERAL_static:

		case LITERAL_def:

		case LBRACK:

		case IDENT:

		case STRING_LITERAL:

		case LPAREN:

		case LITERAL_class:

		case LITERAL_interface:

		case LITERAL_enum:

		case AT:

		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_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 LITERAL_if:

		case LITERAL_while:

		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 LITERAL_false:

		case LITERAL_new:

		case LITERAL_null:

		case LITERAL_true:

		case INC:

		case DEC:

		case BNOT:

		case LNOT:

		case STRING_CTOR_START:

		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))) {

			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_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {

			{

			switch ( LA(1)) {

			case FINAL:

			case ABSTRACT:

			case STRICTFP:

			case LITERAL_import:

			case LITERAL_static:

			case LITERAL_def:

			case LBRACK:

			case IDENT:

			case STRING_LITERAL:

			case LPAREN:

			case LITERAL_class:

			case LITERAL_interface:

			case LITERAL_enum:

			case AT:

			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_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 LITERAL_if:

			case LITERAL_while:

			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 LITERAL_false:

			case LITERAL_new:

			case LITERAL_null:

			case LITERAL_true:

			case INC:

			case DEC:

			case BNOT:

			case LNOT:

			case STRING_CTOR_START:

			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 LBRACK:

				case IDENT:

				case STRING_LITERAL:

				case LPAREN:

				case LITERAL_class:

				case LITERAL_interface:

				case LITERAL_enum:

				case AT:

				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_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 LITERAL_if:

				case LITERAL_while:

				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 LITERAL_false:

				case LITERAL_new:

				case LITERAL_null:

				case LITERAL_true:

				case INC:

				case DEC:

				case BNOT:

				case LNOT:

				case STRING_CTOR_START:

				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_2.member(LA(2)))) {

			match(NLS);

		}

		else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {

		}

		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);

		

		{

		_loop88:

		do {

			if ((LA(1)==AT)) {

				annotation();

				astFactory.addASTChild(currentAST, returnAST);

				nls();

			}

			else {

				break _loop88;

			}

			

		} 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 es_AST = null;

		AST m_AST = null;

		AST ale_AST = null;

		AST ifCbs_AST = null;

		AST elseCbs_AST = null;

		AST while_sce_AST = null;

		Token  s = null;

		AST s_AST = null;

		AST while_cbs_AST = null;

		AST switchSce_AST = null;

		AST cg_AST = null;

		AST synch_sce_AST = null;

		AST synch_cs_AST = null;

		boolean sce=false; Token first = LT(1); AST casesGroup_AST = null;

		

		switch ( LA(1)) {

		case LITERAL_if:

		{

			match(LITERAL_if);

			match(LPAREN);

			assignmentLessExpression();

			ale_AST = (AST)returnAST;

			match(RPAREN);

			nlsWarn();

			compatibleBodyStatement();

			ifCbs_AST = (AST)returnAST;

			{

			boolean synPredMatched280 = false;

			if (((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2))))) {

				int _m280 = mark();

				synPredMatched280 = 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) {

					synPredMatched280 = false;

				}

				rewind(_m280);

inputState.guessing--;

			}

			if ( synPredMatched280 ) {

				{

				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();

				elseCbs_AST = (AST)returnAST;

			}

			else if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {

			}

			else {

				throw new NoViableAltException(LT(1), getFilename());

			}

			

			}

			if ( inputState.guessing==0 ) {

				statement_AST = (AST)currentAST.root;

				statement_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(LITERAL_if,"if",first,LT(1))).add(ale_AST).add(ifCbs_AST).add(elseCbs_AST));

				currentAST.root = statement_AST;

				currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?

					statement_AST.getFirstChild() : statement_AST;

				currentAST.advanceChildToEnd();

			}

			statement_AST = (AST)currentAST.root;

			break;

		}

		case LITERAL_for:

		{

			forStatement();

			astFactory.addASTChild(currentAST, returnAST);

			statement_AST = (AST)currentAST.root;

			break;

		}

		case LITERAL_while:

		{

			match(LITERAL_while);

			match(LPAREN);

			sce=strictContextExpression(false);

			while_sce_AST = (AST)returnAST;

			match(RPAREN);

			nlsWarn();

			{

			switch ( LA(1)) {

			case SEMI:

			{

				s = LT(1);

				s_AST = astFactory.create(s);

				match(SEMI);

				break;

			}

			case FINAL:

			case ABSTRACT:

			case STRICTFP:

			case LITERAL_import:

			case LITERAL_static:

			case LITERAL_def:

			case LBRACK:

			case IDENT:

			case STRING_LITERAL:

			case LPAREN:

			case LITERAL_class:

			case LITERAL_interface:

			case LITERAL_enum:

			case AT:

			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_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 LITERAL_if:

			case LITERAL_while:

			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 LITERAL_false:

			case LITERAL_new:

			case LITERAL_null:

			case LITERAL_true:

			case INC:

			case DEC:

			case BNOT:

			case LNOT:

			case STRING_CTOR_START:

			case NUM_INT:

			case NUM_FLOAT:

			case NUM_LONG:

			case NUM_DOUBLE:

			case NUM_BIG_INT:

			case NUM_BIG_DECIMAL:

			{

				compatibleBodyStatement();

				while_cbs_AST = (AST)returnAST;

				break;

			}

			default:

			{

				throw new NoViableAltException(LT(1), getFilename());

			}

			}

			}

			if ( inputState.guessing==0 ) {

				statement_AST = (AST)currentAST.root;

				

				if (s_AST != null)

				statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_while,"Literal_while",first,LT(1))).add(while_sce_AST).add(s_AST));

				else

				statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_while,"Literal_while",first,LT(1))).add(while_sce_AST).add(while_cbs_AST));

				

				currentAST.root = statement_AST;

				currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?

					statement_AST.getFirstChild() : statement_AST;

				currentAST.advanceChildToEnd();

			}

			statement_AST = (AST)currentAST.root;

			break;

		}

		case LITERAL_import:

		{

			importStatement();

			astFactory.addASTChild(currentAST, returnAST);

			statement_AST = (AST)currentAST.root;

			break;

		}

		case LITERAL_switch:

		{

			match(LITERAL_switch);

			match(LPAREN);

			sce=strictContextExpression(false);

			switchSce_AST = (AST)returnAST;

			match(RPAREN);

			nlsWarn();

			match(LCURLY);

			nls();

			{

			_loop284:

			do {

				if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case)) {

					casesGroup();

					cg_AST = (AST)returnAST;

					if ( inputState.guessing==0 ) {

						casesGroup_AST = (AST)astFactory.make( (new ASTArray(3)).add(null).add(casesGroup_AST).add(cg_AST));

					}

				}

				else {

					break _loop284;

				}

				

			} while (true);

			}

			match(RCURLY);

			if ( inputState.guessing==0 ) {

				statement_AST = (AST)currentAST.root;

				statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_switch,"switch",first,LT(1))).add(switchSce_AST).add(casesGroup_AST));

				currentAST.root = statement_AST;

				currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?

					statement_AST.getFirstChild() : statement_AST;

				currentAST.advanceChildToEnd();

			}

			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 synPredMatched267 = false;

			if (((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2))))) {

				int _m267 = mark();

				synPredMatched267 = true;

				inputState.guessing++;

				try {

					{

					genericMethodStart();

					}

				}

				catch (RecognitionException pe) {

					synPredMatched267 = false;

				}

				rewind(_m267);

inputState.guessing--;

			}

			if ( synPredMatched267 ) {

				genericMethod();

				astFactory.addASTChild(currentAST, returnAST);

				statement_AST = (AST)currentAST.root;

			}

			else {

				boolean synPredMatched269 = false;

				if (((_tokenSet_8.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {

					int _m269 = mark();

					synPredMatched269 = true;

					inputState.guessing++;

					try {

						{

						multipleAssignmentDeclarationStart();

						}

					}

					catch (RecognitionException pe) {

						synPredMatched269 = false;

					}

					rewind(_m269);

inputState.guessing--;

				}

				if ( synPredMatched269 ) {

					multipleAssignmentDeclaration();

					astFactory.addASTChild(currentAST, returnAST);

					statement_AST = (AST)currentAST.root;

				}

				else {

					boolean synPredMatched271 = false;

					if (((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2))))) {

						int _m271 = mark();

						synPredMatched271 = true;

						inputState.guessing++;

						try {

							{

							declarationStart();

							}

						}

						catch (RecognitionException pe) {

							synPredMatched271 = false;

						}

						rewind(_m271);

inputState.guessing--;

					}

					if ( synPredMatched271 ) {

						declaration();

						astFactory.addASTChild(currentAST, returnAST);

						statement_AST = (AST)currentAST.root;

					}

					else {

						boolean synPredMatched273 = false;

						if (((LA(1)==IDENT) && (LA(2)==COLON))) {

							int _m273 = mark();

							synPredMatched273 = true;

							inputState.guessing++;

							try {

								{

								match(IDENT);

								match(COLON);

								}

							}

							catch (RecognitionException pe) {

								synPredMatched273 = false;

							}

							rewind(_m273);

inputState.guessing--;

						}

						if ( synPredMatched273 ) {

							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 synPredMatched276 = false;

							if (((LA(1)==LCURLY) && (_tokenSet_13.member(LA(2))))) {

								int _m276 = mark();

								synPredMatched276 = true;

								inputState.guessing++;

								try {

									{

									match(LCURLY);

									}

								}

								catch (RecognitionException pe) {

									synPredMatched276 = false;

								}

								rewind(_m276);

inputState.guessing--;

							}

							if ( synPredMatched276 ) {

								openOrClosableBlock();

								astFactory.addASTChild(currentAST, returnAST);

							}

							else if ((_tokenSet_14.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {

								statement(COLON);

								astFactory.addASTChild(currentAST, returnAST);

							}

							else {

								throw new NoViableAltException(LT(1), getFilename());

							}

							

							}

							statement_AST = (AST)currentAST.root;

						}

						else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {

							expressionStatement(prevToken);

							es_AST = (AST)returnAST;

							astFactory.addASTChild(currentAST, returnAST);

							statement_AST = (AST)currentAST.root;

						}

						else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {

							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)) {

							match(LITERAL_synchronized);

							match(LPAREN);

							sce=strictContextExpression(false);

							synch_sce_AST = (AST)returnAST;

							match(RPAREN);

							nlsWarn();

							compoundStatement();

							synch_cs_AST = (AST)returnAST;

							if ( inputState.guessing==0 ) {

								statement_AST = (AST)currentAST.root;

								statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_synchronized,"synchronized",first,LT(1))).add(synch_sce_AST).add(synch_cs_AST));

								currentAST.root = statement_AST;

								currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?

									statement_AST.getFirstChild() : statement_AST;

								currentAST.advanceChildToEnd();

							}

							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);

			{

			_loop530:

			do {

				if ((LA(1)==NLS) && (_tokenSet_18.member(LA(2)))) {

					match(NLS);

				}

				else {

					break _loop530;

				}

				

			} while (true);

			}

			if ( inputState.guessing==0 ) {

				sepToken = SEMI;

			}

			break;

		}

		case NLS:

		{

			match(NLS);

			if ( inputState.guessing==0 ) {

				sepToken = NLS;

			}

			{

			_loop534:

			do {

				if ((LA(1)==SEMI) && (_tokenSet_18.member(LA(2)))) {

					match(SEMI);

					{

					_loop533:

					do {

						if ((LA(1)==NLS) && (_tokenSet_18.member(LA(2)))) {

							match(NLS);

						}

						else {

							break _loop533;

						}

						

					} while (true);

					}

					if ( inputState.guessing==0 ) {

						sepToken = SEMI;

					}

				}

				else {

					break _loop534;

				}

				

			} 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 LBRACK:

		case IDENT:

		case STRING_LITERAL:

		case LPAREN:

		case LITERAL_class:

		case LITERAL_interface:

		case LITERAL_enum:

		case AT:

		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_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 LITERAL_if:

		case LITERAL_while:

		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 LITERAL_false:

		case LITERAL_new:

		case LITERAL_null:

		case LITERAL_true:

		case INC:

		case DEC:

		case BNOT:

		case LNOT:

		case STRING_CTOR_START:

		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());

		}

		}

		}

		{

		_loop261:

		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 LBRACK:

				case IDENT:

				case STRING_LITERAL:

				case LPAREN:

				case LITERAL_class:

				case LITERAL_interface:

				case LITERAL_enum:

				case AT:

				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_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 LITERAL_if:

				case LITERAL_while:

				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 LITERAL_false:

				case LITERAL_new:

				case LITERAL_null:

				case LITERAL_true:

				case INC:

				case DEC:

				case BNOT:

				case LNOT:

				case STRING_CTOR_START:

				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 _loop261;

			}

			

		} 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;

		Token  i1 = null;

		AST i1_AST = null;

		Token  d = null;

		AST d_AST = null;

		Token  i2 = null;

		AST i2_AST = null;

		Token first = LT(1);

		

		i1 = LT(1);

		i1_AST = astFactory.create(i1);

		match(IDENT);

		{

		_loop71:

		do {

			if ((LA(1)==DOT)) {

				d = LT(1);

				d_AST = astFactory.create(d);

				match(DOT);

				nls();

				i2 = LT(1);

				i2_AST = astFactory.create(i2);

				match(IDENT);

				if ( inputState.guessing==0 ) {

					i1_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(DOT,".",first,LT(1))).add(i1_AST).add(i2_AST));

				}

			}

			else {

				break _loop71;

			}

			

		} while (true);

		}

		if ( inputState.guessing==0 ) {

			identifier_AST = (AST)currentAST.root;

			identifier_AST = i1_AST;

			currentAST.root = identifier_AST;

			currentAST.child = identifier_AST!=null &&identifier_AST.getFirstChild()!=null ?

				identifier_AST.getFirstChild() : identifier_AST;

			currentAST.advanceChildToEnd();

		}

		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;

		AST is_AST = null;

		Token first = LT(1); boolean isStatic = false;

		

…