Package org.codehaus.groovy.antlr.parser

Source Code of org.codehaus.groovy.antlr.parser.GroovyRecognizer

// $ANTLR 2.7.6 (2005-12-22): "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.CommonToken;
import org.codehaus.groovy.GroovyBugError;

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();
        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.&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.tracingreturn;
        super.traceIn(rname);
    }
    public void traceOut(String rname) throws TokenStreamException {
        if (!GroovyRecognizer.tracingreturn;
        if (returnAST != nullrname += 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 == nulllt = 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 == nulllt = 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 (!zrequireFailed(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() != IDENTreturn 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 == nullreturn false;
        if (currentClass.getType() != IDENTreturn false// cannot happen?
        String cname = currentClass.getText();

        if (x == null || x.getType() != IDENTreturn 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 INC:
    case DEC:
    case BNOT:
    case LNOT:
    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))) {
      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 INC:
      case DEC:
      case BNOT:
      case LNOT:
      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 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 INC:
        case DEC:
        case BNOT:
        case LNOT:
        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_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);
   
    {
    _loop87:
    do {
      if ((LA(1)==AT)) {
        annotation();
        astFactory.addASTChild(currentAST, returnAST);
        nls();
      }
      else {
        break _loop87;
      }
     
    } 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;
    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 synPredMatched263 = false;
      if (((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2))))) {
        int _m263 = mark();
        synPredMatched263 = 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) {
          synPredMatched263 = false;
        }
        rewind(_m263);
inputState.guessing--;
      }
      if ( synPredMatched263 ) {
        {
        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 INC:
      case DEC:
      case BNOT:
      case LNOT:
      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:
      {
        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();
      {
      _loop267:
      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 _loop267;
        }
       
      } 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 synPredMatched252 = false;
      if (((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2))))) {
        int _m252 = mark();
        synPredMatched252 = true;
        inputState.guessing++;
        try {
          {
          genericMethodStart();
          }
        }
        catch (RecognitionException pe) {
          synPredMatched252 = false;
        }
        rewind(_m252);
inputState.guessing--;
      }
      if ( synPredMatched252 ) {
        genericMethod();
        astFactory.addASTChild(currentAST, returnAST);
        statement_AST = (AST)currentAST.root;
      }
      else {
        boolean synPredMatched254 = false;
        if (((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2))))) {
          int _m254 = mark();
          synPredMatched254 = true;
          inputState.guessing++;
          try {
            {
            declarationStart();
            }
          }
          catch (RecognitionException pe) {
            synPredMatched254 = false;
          }
          rewind(_m254);
inputState.guessing--;
        }
        if ( synPredMatched254 ) {
          declaration();
          astFactory.addASTChild(currentAST, returnAST);
          statement_AST = (AST)currentAST.root;
        }
        else {
          boolean synPredMatched256 = false;
          if (((LA(1)==IDENT) && (LA(2)==COLON))) {
            int _m256 = mark();
            synPredMatched256 = true;
            inputState.guessing++;
            try {
              {
              match(IDENT);
              match(COLON);
              }
            }
            catch (RecognitionException pe) {
              synPredMatched256 = false;
            }
            rewind(_m256);
inputState.guessing--;
          }
          if ( synPredMatched256 ) {
            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 synPredMatched259 = false;
            if (((LA(1)==LCURLY) && (_tokenSet_12.member(LA(2))))) {
              int _m259 = mark();
              synPredMatched259 = true;
              inputState.guessing++;
              try {
                {
                match(LCURLY);
                }
              }
              catch (RecognitionException pe) {
                synPredMatched259 = false;
              }
              rewind(_m259);
inputState.guessing--;
            }
            if ( synPredMatched259 ) {
              openOrClosableBlock();
              astFactory.addASTChild(currentAST, returnAST);
            }
            else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_14.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_14.member(LA(2)))) {
            expressionStatement(prevToken);
            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);
      {
      _loop505:
      do {
        if ((LA(1)==NLS) && (_tokenSet_18.member(LA(2)))) {
          match(NLS);
        }
        else {
          break _loop505;
        }
       
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        sepToken = SEMI;
      }
      break;
    }
    case NLS:
    {
      match(NLS);
      if ( inputState.guessing==0 ) {
        sepToken = NLS;
      }
      {
      _loop509:
      do {
        if ((LA(1)==SEMI) && (_tokenSet_18.member(LA(2)))) {
          match(SEMI);
          {
          _loop508:
          do {
            if ((LA(1)==NLS) && (_tokenSet_18.member(LA(2)))) {
              match(NLS);
            }
            else {
              break _loop508;
            }
           
          } while (true);
          }
          if ( inputState.guessing==0 ) {
            sepToken = SEMI;
          }
        }
        else {
          break _loop509;
        }
       
      } 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 INC:
    case DEC:
    case BNOT:
    case LNOT:
    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());
    }
    }
    }
    {
    _loop246:
    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 INC:
        case DEC:
        case BNOT:
        case LNOT:
        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 _loop246;
      }
     
    } 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);
    {
    _loop70:
    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 _loop70;
      }
     
    } 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;
   
    match(LITERAL_import);
    {
    switch ( LA(1)) {
    case LITERAL_static:
    {
      match(LITERAL_static);
      if ( inputState.guessing==0 ) {
        isStatic=true;
      }
      break;
    }
    case IDENT:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    identifierStar();
    is_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      importStatement_AST = (AST)currentAST.root;
      if (isStatic)
      importStatement_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(STATIC_IMPORT,"static_import",first,LT(1))).add(is_AST));
      else
      importStatement_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(IMPORT,"import",first,LT(1))).add(is_AST));
      currentAST.root = importStatement_AST;
      currentAST.child = importStatement_AST!=null &&importStatement_AST.getFirstChild()!=null ?
        importStatement_AST.getFirstChild() : importStatement_AST;
      currentAST.advanceChildToEnd();
    }
    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;
    Token  i1 = null;
    AST i1_AST = null;
    Token  d1 = null;
    AST d1_AST = null;
    Token  i2 = null;
    AST i2_AST = null;
    Token  d2 = null;
    AST d2_AST = null;
    Token  s = null;
    AST s_AST = null;
    Token  alias = null;
    AST alias_AST = null;
    Token first = LT(1);
   
    i1 = LT(1);
    i1_AST = astFactory.create(i1);
    match(IDENT);
    {
    _loop73:
    do {
      if ((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==NLS)) {
        d1 = LT(1);
        d1_AST = astFactory.create(d1);
        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 _loop73;
      }
     
    } while (true);
    }
    {
    switch ( LA(1)) {
    case DOT:
    {
      d2 = LT(1);
      d2_AST = astFactory.create(d2);
      match(DOT);
      nls();
      s = LT(1);
      s_AST = astFactory.create(s);
      match(STAR);
      if ( inputState.guessing==0 ) {
        i1_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(DOT,".",first,LT(1))).add(i1_AST).add(s_AST));
      }
      break;
    }
    case LITERAL_as:
    {
      match(LITERAL_as);
      nls();
      alias = LT(1);
      alias_AST = astFactory.create(alias);
      match(IDENT);
      if ( inputState.guessing==0 ) {
        i1_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_as,"as",first,LT(1))).add(i1_AST).add(alias_AST));
      }
      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());
    }
    }
    }
    if ( inputState.guessing==0 ) {
      identifierStar_AST = (AST)currentAST.root;
      identifierStar_AST = i1_AST;
      currentAST.root = identifierStar_AST;
      currentAST.child = identifierStar_AST!=null &&identifierStar_AST.getFirstChild()!=null ?
        identifierStar_AST.getFirstChild() : identifierStar_AST;
      currentAST.advanceChildToEnd();
    }
    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 = cloneToken(LT(1));AST prevCurrentClass = currentClass;
    if (modifiers != null) {
    first.setLine(modifiers.getLine());
    first.setColumn(modifiers.getColumn());
    }
   
    match(LITERAL_class);
    AST tmp28_AST = null;
    tmp28_AST = astFactory.create(LT(1));
    match(IDENT);
    nls();
    if ( inputState.guessing==0 ) {
      currentClass = tmp28_AST;
    }
    {
    switch ( LA(1)) {
    case LT:
    {
      typeParameters();
      tp_AST = (AST)returnAST;
      nls();
      break;
    }
    case LITERAL_extends:
    case LCURLY:
    case LITERAL_implements:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    superClassClause();
    sc_AST = (AST)returnAST;
    implementsClause();
    ic_AST = (AST)returnAST;
    classBlock();
    cb_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      classDefinition_AST = (AST)currentAST.root;
      classDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(create(CLASS_DEF,"CLASS_DEF",first,LT(1))).add(modifiers).add(tmp28_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
      currentAST.root = classDefinition_AST;
      currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
        classDefinition_AST.getFirstChild() : classDefinition_AST;
      currentAST.advanceChildToEnd();
    }
    if ( inputState.guessing==0 ) {
      currentClass = prevCurrentClass;
    }
    returnAST = classDefinition_AST;
  }
 
  public final void interfaceDefinition(
    AST modifiers
  ) throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST interfaceDefinition_AST = null;
    AST tp_AST = null;
    AST ie_AST = null;
    AST ib_AST = null;
    Token first = cloneToken(LT(1));
    if (modifiers != null) {
    first.setLine(modifiers.getLine());
    first.setColumn(modifiers.getColumn());
    }
   
    match(LITERAL_interface);
    AST tmp30_AST = null;
    tmp30_AST = astFactory.create(LT(1));
    match(IDENT);
    nls();
    {
    switch ( LA(1)) {
    case LT:
    {
      typeParameters();
      tp_AST = (AST)returnAST;
      break;
    }
    case LITERAL_extends:
    case LCURLY:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    interfaceExtends();
    ie_AST = (AST)returnAST;
    interfaceBlock();
    ib_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      interfaceDefinition_AST = (AST)currentAST.root;
      interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(create(INTERFACE_DEF,"INTERFACE_DEF",first,LT(1))).add(modifiers).add(tmp30_AST).add(tp_AST).add(ie_AST).add(ib_AST));
      currentAST.root = interfaceDefinition_AST;
      currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
        interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
      currentAST.advanceChildToEnd();
    }
    returnAST = interfaceDefinition_AST;
  }
 
  public final void enumDefinition(
    AST modifiers
  ) throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST enumDefinition_AST = null;
    AST ic_AST = null;
    AST eb_AST = null;
    Token first = cloneToken(LT(1)); AST prevCurrentClass = currentClass;
    if (modifiers != null) {
    first.setLine(modifiers.getLine());
    first.setColumn(modifiers.getColumn());
    }
   
    match(LITERAL_enum);
    AST tmp32_AST = null;
    tmp32_AST = astFactory.create(LT(1));
    match(IDENT);
    if ( inputState.guessing==0 ) {
      currentClass = tmp32_AST;
    }
    nls();
    implementsClause();
    ic_AST = (AST)returnAST;
    nls();
    enumBlock();
    eb_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      enumDefinition_AST = (AST)currentAST.root;
      enumDefinition_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(ENUM_DEF,"ENUM_DEF",first,LT(1))).add(modifiers).add(tmp32_AST).add(ic_AST).add(eb_AST));
      currentAST.root = enumDefinition_AST;
      currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
        enumDefinition_AST.getFirstChild() : enumDefinition_AST;
      currentAST.advanceChildToEnd();
    }
    if ( inputState.guessing==0 ) {
      currentClass = prevCurrentClass;
    }
    returnAST = enumDefinition_AST;
  }
 
  public final void annotationDefinition(
    AST modifiers
  ) throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST annotationDefinition_AST = null;
    AST ab_AST = null;
    Token first = cloneToken(LT(1));
    if (modifiers != null) {
    first.setLine(modifiers.getLine());
    first.setColumn(modifiers.getColumn());
    }
   
    AST tmp33_AST = null;
    tmp33_AST = astFactory.create(LT(1));
    match(AT);
    match(LITERAL_interface);
    AST tmp35_AST = null;
    tmp35_AST = astFactory.create(LT(1));
    match(IDENT);
    annotationBlock();
    ab_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      annotationDefinition_AST = (AST)currentAST.root;
      annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(ANNOTATION_DEF,"ANNOTATION_DEF",first,LT(1))).add(modifiers).add(tmp35_AST).add(ab_AST));
      currentAST.root = annotationDefinition_AST;
      currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
        annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
      currentAST.advanceChildToEnd();
    }
    returnAST = annotationDefinition_AST;
  }
 
/** A declaration is the creation of a reference or primitive-type variable,
*  or (if arguments are present) of a method.
*  Generically, this is called a 'variable' definition, even in the case of a class field or method.
*  It may start with the modifiers and/or a declaration keyword "def".
*  It may also start with the modifiers and a capitalized type name.
<p>
*  AST effect: Create a separate Type/Var tree for each var in the var list.
*  Must be guarded, as in (declarationStart) => declaration.
*/
  public final void declaration() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST declaration_AST = null;
    AST m_AST = null;
    AST t_AST = null;
    AST v_AST = null;
    AST t2_AST = null;
    AST v2_AST = null;
   
    switch ( LA(1)) {
    case FINAL:
    case ABSTRACT:
    case STRICTFP:
    case LITERAL_static:
    case LITERAL_def:
    case AT:
    case LITERAL_private:
    case LITERAL_public:
    case LITERAL_protected:
    case LITERAL_transient:
    case LITERAL_native:
    case LITERAL_threadsafe:
    case LITERAL_synchronized:
    case LITERAL_volatile:
    {
      modifiers();
      m_AST = (AST)returnAST;
      {
      if ((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2)))) {
        typeSpec(false);
        t_AST = (AST)returnAST;
      }
      else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (_tokenSet_21.member(LA(2)))) {
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
     
      }
      variableDefinitions(m_AST, t_AST);
      v_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        declaration_AST = (AST)currentAST.root;
        declaration_AST = v_AST;
        currentAST.root = declaration_AST;
        currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
          declaration_AST.getFirstChild() : declaration_AST;
        currentAST.advanceChildToEnd();
      }
      break;
    }
    case IDENT:
    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:
    {
      typeSpec(false);
      t2_AST = (AST)returnAST;
      variableDefinitions(null,t2_AST);
      v2_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        declaration_AST = (AST)currentAST.root;
        declaration_AST = v2_AST;
        currentAST.root = declaration_AST;
        currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
          declaration_AST.getFirstChild() : declaration_AST;
        currentAST.advanceChildToEnd();
      }
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    returnAST = declaration_AST;
  }
 
/** A list of one or more modifier, annotation, or "def". */
  public final void modifiers() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST modifiers_AST = null;
    Token first = LT(1);
   
    modifiersInternal();
    astFactory.addASTChild(currentAST, returnAST);
    if ( inputState.guessing==0 ) {
      modifiers_AST = (AST)currentAST.root;
      modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(modifiers_AST));
      currentAST.root = modifiers_AST;
      currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
        modifiers_AST.getFirstChild() : modifiers_AST;
      currentAST.advanceChildToEnd();
    }
    modifiers_AST = (AST)currentAST.root;
    returnAST = modifiers_AST;
  }
 
  public final void typeSpec(
    boolean addImagNode
  ) throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeSpec_AST = null;
   
    switch ( LA(1)) {
    case IDENT:
    {
      classTypeSpec(addImagNode);
      astFactory.addASTChild(currentAST, returnAST);
      typeSpec_AST = (AST)currentAST.root;
      break;
    }
    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:
    {
      builtInTypeSpec(addImagNode);
      astFactory.addASTChild(currentAST, returnAST);
      typeSpec_AST = (AST)currentAST.root;
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    returnAST = typeSpec_AST;
  }
 
/** The tail of a declaration.
  * Either v1, v2, ... (with possible initializers) or else m(args){body}.
  * The two arguments are the modifier list (if any) and the declaration head (if any).
  * The declaration head is the variable type, or (for a method) the return type.
  * If it is missing, then the variable type is taken from its initializer (if there is one).
  * Otherwise, the variable type defaults to 'any'.
  * DECIDE:  Method return types default to the type of the method body, as an expression.
  */
  public final void variableDefinitions(
    AST mods, AST t
  ) throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST variableDefinitions_AST = null;
    Token  id = null;
    AST id_AST = null;
    Token  qid = null;
    AST qid_AST = null;
    AST param_AST = null;
    AST tc_AST = null;
    AST mb_AST = null;
    Token first = cloneToken(LT(1));
                   if (mods != null) {
                       first.setLine(mods.getLine());
                     first.setColumn(mods.getColumn());
                   } else if (t != null) {
                       first.setLine(t.getLine());
                       first.setColumn(t.getColumn());
                   }
   
    if ((LA(1)==IDENT) && (_tokenSet_22.member(LA(2)))) {
      variableDeclarator(getASTFactory().dupTree(mods),
                           getASTFactory().dupTree(t),first);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop200:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          nls();
          if ( inputState.guessing==0 ) {
            first = LT(1);
          }
          variableDeclarator(getASTFactory().dupTree(mods),
                               getASTFactory().dupTree(t),first);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop200;
        }
       
      } while (true);
      }
      variableDefinitions_AST = (AST)currentAST.root;
    }
    else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (LA(2)==LPAREN)) {
      {
      switch ( LA(1)) {
      case IDENT:
      {
        id = LT(1);
        id_AST = astFactory.create(id);
        astFactory.addASTChild(currentAST, id_AST);
        match(IDENT);
        break;
      }
      case STRING_LITERAL:
      {
        qid = LT(1);
        qid_AST = astFactory.create(qid);
        astFactory.addASTChild(currentAST, qid_AST);
        match(STRING_LITERAL);
        if ( inputState.guessing==0 ) {
          qid_AST.setType(IDENT);
        }
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      match(LPAREN);
      parameterDeclarationList();
      param_AST = (AST)returnAST;
      match(RPAREN);
      {
      boolean synPredMatched204 = false;
      if (((LA(1)==NLS||LA(1)==LITERAL_throws) && (_tokenSet_23.member(LA(2))))) {
        int _m204 = mark();
        synPredMatched204 = true;
        inputState.guessing++;
        try {
          {
          nls();
          match(LITERAL_throws);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched204 = false;
        }
        rewind(_m204);
inputState.guessing--;
      }
      if ( synPredMatched204 ) {
        throwsClause();
        tc_AST = (AST)returnAST;
      }
      else if ((_tokenSet_24.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
     
      }
      {
      boolean synPredMatched207 = false;
      if (((LA(1)==LCURLY||LA(1)==NLS) && (_tokenSet_25.member(LA(2))))) {
        int _m207 = mark();
        synPredMatched207 = true;
        inputState.guessing++;
        try {
          {
          nls();
          match(LCURLY);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched207 = false;
        }
        rewind(_m207);
inputState.guessing--;
      }
      if ( synPredMatched207 ) {
        {
        nlsWarn();
        openBlock();
        mb_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 ) {
        variableDefinitions_AST = (AST)currentAST.root;
        if (qid_AST != nullid_AST = qid_AST;
        variableDefinitions_AST =
        (AST)astFactory.make( (new ASTArray(7)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t))).add(id_AST).add(param_AST).add(tc_AST).add(mb_AST));
       
        currentAST.root = variableDefinitions_AST;
        currentAST.child = variableDefinitions_AST!=null &&variableDefinitions_AST.getFirstChild()!=null ?
          variableDefinitions_AST.getFirstChild() : variableDefinitions_AST;
        currentAST.advanceChildToEnd();
      }
      variableDefinitions_AST = (AST)currentAST.root;
    }
    else {
      throw new NoViableAltException(LT(1), getFilename());
    }
   
    returnAST = variableDefinitions_AST;
  }
 
  public final void genericMethod() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST genericMethod_AST = null;
    AST m_AST = null;
    AST p_AST = null;
    AST t_AST = null;
    AST v_AST = null;
   
    modifiers();
    m_AST = (AST)returnAST;
    typeParameters();
    p_AST = (AST)returnAST;
    typeSpec(false);
    t_AST = (AST)returnAST;
    variableDefinitions(m_AST, t_AST);
    v_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      genericMethod_AST = (AST)currentAST.root;
     
      genericMethod_AST = v_AST;
      AST old = v_AST.getFirstChild();
      genericMethod_AST.setFirstChild(p_AST);
      p_AST.setNextSibling(old);
     
      currentAST.root = genericMethod_AST;
      currentAST.child = genericMethod_AST!=null &&genericMethod_AST.getFirstChild()!=null ?
        genericMethod_AST.getFirstChild() : genericMethod_AST;
      currentAST.advanceChildToEnd();
    }
    returnAST = genericMethod_AST;
  }
 
  public final void typeParameters() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeParameters_AST = null;
    Token first = LT(1);int currentLtLevel = 0;
   
    if ( inputState.guessing==0 ) {
      currentLtLevel = ltCounter;
    }
    match(LT);
    if ( inputState.guessing==0 ) {
      ltCounter++;
    }
    nls();
    typeParameter();
    astFactory.addASTChild(currentAST, returnAST);
    {
    _loop105:
    do {
      if ((LA(1)==COMMA)) {
        match(COMMA);
        nls();
        typeParameter();
        astFactory.addASTChild(currentAST, returnAST);
      }
      else {
        break _loop105;
      }
     
    } while (true);
    }
    nls();
    {
    switch ( LA(1)) {
    case GT:
    case SR:
    case BSR:
    {
      typeArgumentsOrParametersEnd();
      astFactory.addASTChild(currentAST, returnAST);
      break;
    }
    case IDENT:
    case LITERAL_extends:
    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 LCURLY:
    case NLS:
    case LITERAL_implements:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
      throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel");
    if ( inputState.guessing==0 ) {
      typeParameters_AST = (AST)currentAST.root;
      typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETERS,"TYPE_PARAMETERS",first,LT(1))).add(typeParameters_AST));
      currentAST.root = typeParameters_AST;
      currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ?
        typeParameters_AST.getFirstChild() : typeParameters_AST;
      currentAST.advanceChildToEnd();
    }
    typeParameters_AST = (AST)currentAST.root;
    returnAST = typeParameters_AST;
  }
 
/** A declaration with one declarator and no initialization, like a parameterDeclaration.
*  Used to parse loops like <code>for (int x in y)</code> (up to the <code>in</code> keyword).
*/
  public final void singleDeclarationNoInit() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST singleDeclarationNoInit_AST = null;
    AST m_AST = null;
    AST t_AST = null;
    AST v_AST = null;
    AST t2_AST = null;
    AST v2_AST = null;
   
    switch ( LA(1)) {
    case FINAL:
    case ABSTRACT:
    case STRICTFP:
    case LITERAL_static:
    case LITERAL_def:
    case AT:
    case LITERAL_private:
    case LITERAL_public:
    case LITERAL_protected:
    case LITERAL_transient:
    case LITERAL_native:
    case LITERAL_threadsafe:
    case LITERAL_synchronized:
    case LITERAL_volatile:
    {
      modifiers();
      m_AST = (AST)returnAST;
      {
      if ((_tokenSet_19.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
        typeSpec(false);
        t_AST = (AST)returnAST;
      }
      else if ((LA(1)==IDENT) && (_tokenSet_27.member(LA(2)))) {
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
     
      }
      singleVariable(m_AST, t_AST);
      v_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        singleDeclarationNoInit_AST = (AST)currentAST.root;
        singleDeclarationNoInit_AST = v_AST;
        currentAST.root = singleDeclarationNoInit_AST;
        currentAST.child = singleDeclarationNoInit_AST!=null &&singleDeclarationNoInit_AST.getFirstChild()!=null ?
          singleDeclarationNoInit_AST.getFirstChild() : singleDeclarationNoInit_AST;
        currentAST.advanceChildToEnd();
      }
      break;
    }
    case IDENT:
    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:
    {
      typeSpec(false);
      t2_AST = (AST)returnAST;
      singleVariable(null,t2_AST);
      v2_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        singleDeclarationNoInit_AST = (AST)currentAST.root;
        singleDeclarationNoInit_AST = v2_AST;
        currentAST.root = singleDeclarationNoInit_AST;
        currentAST.child = singleDeclarationNoInit_AST!=null &&singleDeclarationNoInit_AST.getFirstChild()!=null ?
          singleDeclarationNoInit_AST.getFirstChild() : singleDeclarationNoInit_AST;
        currentAST.advanceChildToEnd();
      }
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    returnAST = singleDeclarationNoInit_AST;
  }
 
/** Used in cases where a declaration cannot have commas, or ends with the "in" operator instead of '='. */
  public final void singleVariable(
    AST mods, AST t
  ) throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST singleVariable_AST = null;
    AST id_AST = null;
    Token first = LT(1);
   
    variableName();
    id_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      singleVariable_AST = (AST)currentAST.root;
      singleVariable_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(VARIABLE_DEF,"VARIABLE_DEF",first,LT(1))).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t))).add(id_AST));
      currentAST.root = singleVariable_AST;
      currentAST.child = singleVariable_AST!=null &&singleVariable_AST.getFirstChild()!=null ?
        singleVariable_AST.getFirstChild() : singleVariable_AST;
      currentAST.advanceChildToEnd();
    }
    returnAST = singleVariable_AST;
  }
 
/** A declaration with one declarator and optional initialization, like a parameterDeclaration.
*  Used to parse declarations used for both binding and effect, in places like argument
*  lists and <code>while</code> statements.
*/
  public final void singleDeclaration() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST singleDeclaration_AST = null;
    AST sd_AST = null;
   
    singleDeclarationNoInit();
    sd_AST = (AST)returnAST;
    if ( inputState.guessing==0 ) {
      singleDeclaration_AST = (AST)currentAST.root;
      singleDeclaration_AST = sd_AST;
      currentAST.root = singleDeclaration_AST;
      currentAST.child = singleDeclaration_AST!=null &&singleDeclaration_AST.getFirstChild()!=null ?
        singleDeclaration_AST.getFirstChild() : singleDeclaration_AST;
      currentAST.advanceChildToEnd();
    }
    {
    switch ( LA(1)) {
    case ASSIGN:
    {
      varInitializer();
      astFactory.addASTChild(currentAST, returnAST);
      break;
    }
    case EOF:
    case RBRACK:
    case COMMA:
    case RPAREN:
    case SEMI:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    singleDeclaration_AST = (AST)currentAST.root;
    returnAST = singleDeclaration_AST;
  }
 
/** An assignment operator '=' followed by an expression.  (Never empty.) */
  public final void varInitializer() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST varInitializer_AST = null;
   
    AST tmp41_AST = null;
    tmp41_AST = astFactory.create(LT(1));
    astFactory.makeASTRoot(currentAST, tmp41_AST);
    match(ASSIGN);
    nls();
    expression(LC_INIT);
    astFactory.addASTChild(currentAST, returnAST);
    varInitializer_AST = (AST)currentAST.root;
    returnAST = varInitializer_AST;
  }
 
/** Used only as a lookahead predicate, before diving in and parsing a declaration.
*  A declaration can be unambiguously introduced with "def", an annotation or a modifier token like "final".
*  It may also be introduced by a simple identifier whose first character is an uppercase letter,
*  as in {String x}.  A declaration can also be introduced with a built in type like 'int' or 'void'.
*  Brackets (array and generic) are allowed, as in {List[] x} or {int[][] y}.
*  Anything else is parsed as a statement of some sort (expression or command).
<p>
*  (In the absence of explicit method-call parens, we assume a capitalized name is a type name.
*  Yes, this is a little hacky.  Alternatives are to complicate the declaration or command
*  syntaxes, or to have the parser query the symbol table.  Parse-time queries are evil.
*  And we want both {String x} and {println x}.  So we need a syntactic razor-edge to slip
*  between 'println' and 'String'.)
*
*   *TODO* The declarationStart production needs to be strengthened to recognize
*  things like {List<String> foo}.
*  Right now it only knows how to skip square brackets after the type, not
*  angle brackets.
*  This probably turns out to be tricky because of >> vs. > >. If so,
*  just put a TODO comment in.
*/
  public final void declarationStart() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST declarationStart_AST = null;
   
    {
    int _cnt28=0;
    _loop28:
    do {
      switch ( LA(1)) {
      case LITERAL_def:
      {
        match(LITERAL_def);
        nls();
        break;
      }
      case FINAL:
      case ABSTRACT:
      case STRICTFP:
      case LITERAL_static:
      case LITERAL_private:
      case LITERAL_public:
      case LITERAL_protected:
      case LITERAL_transient:
      case LITERAL_native:
      case LITERAL_threadsafe:
      case LITERAL_synchronized:
      case LITERAL_volatile:
      {
        modifier();
        nls();
        break;
      }
      case AT:
      {
        annotation();
        nls();
        break;
      }
      default:
        if ((_tokenSet_19.member(LA(1))) && (_tokenSet_28.member(LA(2)))) {
          {
          if ((LA(1)==IDENT) && (_tokenSet_29.member(LA(2)))) {
            upperCaseIdent();
          }
          else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_double))) {
            builtInType();
          }
          else if ((LA(1)==IDENT) && (LA(2)==DOT)) {
            qualifiedTypeName();
          }
          else {
            throw new NoViableAltException(LT(1), getFilename());
          }
         
          }
          {
          switch ( LA(1)) {
          case LT:
          {
            typeArguments();
            break;
          }
          case FINAL:
          case ABSTRACT:
          case STRICTFP:
          case LITERAL_static:
          case LITERAL_def:
          case LBRACK:
          case IDENT:
          case STRING_LITERAL:
          case AT:
          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:
          {
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          {
          _loop27:
          do {
            if ((LA(1)==LBRACK)) {
              AST tmp43_AST = null;
              tmp43_AST = astFactory.create(LT(1));
              match(LBRACK);
              balancedTokens();
              AST tmp44_AST = null;
              tmp44_AST = astFactory.create(LT(1));
              match(RBRACK);
            }
            else {
              break _loop27;
            }
           
          } while (true);
          }
        }
      else {
        if ( _cnt28>=1 ) { break _loop28; } else {throw new NoViableAltException(LT(1), getFilename());}
      }
      }
      _cnt28++;
    } while (true);
    }
    {
    switch ( LA(1)) {
    case IDENT:
    {
      AST tmp45_AST = null;
      tmp45_AST = astFactory.create(LT(1));
      match(IDENT);
      break;
    }
    case STRING_LITERAL:
    {
      AST tmp46_AST = null;
      tmp46_AST = astFactory.create(LT(1));
      match(STRING_LITERAL);
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    returnAST = declarationStart_AST;
  }
 
  public final void modifier() throws RecognitionException, TokenStreamException {
   
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST modifier_AST = null;
   
    switch ( LA(1)) {
    case LITERAL_private:
    {
      AST tmp47_AST = null;
      tmp47_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp47_AST);
      match(LITERAL_private);
      modifier_AST = (AST)currentAST.root;
      break;
    }
    case LITERAL_public:
    {
      AST tmp48_AST = null;
      tmp48_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp48_AST);
      match(LITERAL_public);
      modifier_AST = (AST)currentAST.root;
      break;
    }
    case LITERAL_protected:
    {
      AST tmp49_AST = null;
      tmp49_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp49_AST);
      match(LITERAL_protected);
      modifier_AST = (AST)currentAST.root;
      break;
    }
    case LITERAL_static:
    {
      AST tmp50_AST = null;
      tmp50_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp50_AST);
      match(LITERAL_static);
      modifier_AST = (AST)currentAST.root;
      break;
    }
    case LITERAL_transient:
    {
      AST tmp51_AST = null;
      tmp51_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp51_AST);
      match(LITERAL_transient);
      modifier_AST = (AST)currentAST.root;
      break;
    }
    case FINAL:
    {
      AST tmp52_AST = null;
      tmp52_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp52_AST);
      match(FINAL