001    // $ANTLR 2.7.7 (2006-11-01): "groovy.g" -> "GroovyRecognizer.java"$
002    
003    package org.codehaus.groovy.antlr.parser;
004    import org.codehaus.groovy.antlr.*;
005    import java.util.*;
006    import java.io.InputStream;
007    import java.io.Reader;
008    import antlr.InputBuffer;
009    import antlr.LexerSharedInputState;
010    
011    import antlr.TokenBuffer;
012    import antlr.TokenStreamException;
013    import antlr.TokenStreamIOException;
014    import antlr.ANTLRException;
015    import antlr.LLkParser;
016    import antlr.Token;
017    import antlr.TokenStream;
018    import antlr.RecognitionException;
019    import antlr.NoViableAltException;
020    import antlr.MismatchedTokenException;
021    import antlr.SemanticException;
022    import antlr.ParserSharedInputState;
023    import antlr.collections.impl.BitSet;
024    import antlr.collections.AST;
025    import java.util.Hashtable;
026    import antlr.ASTFactory;
027    import antlr.ASTPair;
028    import antlr.collections.impl.ASTArray;
029    
030    /** JSR-241 Groovy Recognizer
031     *
032     * Run 'java Main [-showtree] directory-full-of-groovy-files'
033     *
034     * [The -showtree option pops up a Swing frame that shows
035     *  the AST constructed from the parser.]
036     *
037     * Contributing authors:
038     *              John Mitchell           johnm@non.net
039     *              Terence Parr            parrt@magelang.com
040     *              John Lilley             jlilley@empathy.com
041     *              Scott Stanchfield       thetick@magelang.com
042     *              Markus Mohnen           mohnen@informatik.rwth-aachen.de
043     *              Peter Williams          pete.williams@sun.com
044     *              Allan Jacobs            Allan.Jacobs@eng.sun.com
045     *              Steve Messick           messick@redhills.com
046     *              James Strachan          jstrachan@protique.com
047     *              John Pybus              john@pybus.org
048     *              John Rose               rose00@mac.com
049     *              Jeremy Rayner           groovy@ross-rayner.com
050     *
051     * Version 1.00 December 9, 1997 -- initial release
052     * Version 1.01 December 10, 1997
053     *              fixed bug in octal def (0..7 not 0..8)
054     * Version 1.10 August 1998 (parrt)
055     *              added tree construction
056     *              fixed definition of WS,comments for mac,pc,unix newlines
057     *              added unary plus
058     * Version 1.11 (Nov 20, 1998)
059     *              Added "shutup" option to turn off last ambig warning.
060     *              Fixed inner class def to allow named class defs as statements
061     *              synchronized requires compound not simple statement
062     *              add [] after builtInType DOT class in primaryExpression
063     *              "const" is reserved but not valid..removed from modifiers
064     * Version 1.12 (Feb 2, 1999)
065     *              Changed LITERAL_xxx to xxx in tree grammar.
066     *              Updated java.g to use tokens {...} now for 2.6.0 (new feature).
067     *
068     * Version 1.13 (Apr 23, 1999)
069     *              Didn't have (stat)? for else clause in tree parser.
070     *              Didn't gen ASTs for interface extends.  Updated tree parser too.
071     *              Updated to 2.6.0.
072     * Version 1.14 (Jun 20, 1999)
073     *              Allowed final/abstract on local classes.
074     *              Removed local interfaces from methods
075     *              Put instanceof precedence where it belongs...in relationalExpr
076     *                      It also had expr not type as arg; fixed it.
077     *              Missing ! on SEMI in classBlock
078     *              fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
079     *              fixed: didn't like Object[].class in parser or tree parser
080     * Version 1.15 (Jun 26, 1999)
081     *              Screwed up rule with instanceof in it. :(  Fixed.
082     *              Tree parser didn't like (expr).something; fixed.
083     *              Allowed multiple inheritance in tree grammar. oops.
084     * Version 1.16 (August 22, 1999)
085     *              Extending an interface built a wacky tree: had extra EXTENDS.
086     *              Tree grammar didn't allow multiple superinterfaces.
087     *              Tree grammar didn't allow empty var initializer: {}
088     * Version 1.17 (October 12, 1999)
089     *              ESC lexer rule allowed 399 max not 377 max.
090     *              java.tree.g didn't handle the expression of synchronized
091     *              statements.
092     * Version 1.18 (August 12, 2001)
093     *              Terence updated to Java 2 Version 1.3 by
094     *              observing/combining work of Allan Jacobs and Steve
095     *              Messick.  Handles 1.3 src.  Summary:
096     *              o  primary didn't include boolean.class kind of thing
097     *              o  constructor calls parsed explicitly now:
098     *                 see explicitConstructorInvocation
099     *              o  add strictfp modifier
100     *              o  missing objBlock after new expression in tree grammar
101     *              o  merged local class definition alternatives, moved after declaration
102     *              o  fixed problem with ClassName.super.field
103     *              o  reordered some alternatives to make things more efficient
104     *              o  long and double constants were not differentiated from int/float
105     *              o  whitespace rule was inefficient: matched only one char
106     *              o  add an examples directory with some nasty 1.3 cases
107     *              o  made Main.java use buffered IO and a Reader for Unicode support
108     *              o  supports UNICODE?
109     *                 Using Unicode charVocabulay makes code file big, but only
110     *                 in the bitsets at the end. I need to make ANTLR generate
111     *                 unicode bitsets more efficiently.
112     * Version 1.19 (April 25, 2002)
113     *              Terence added in nice fixes by John Pybus concerning floating
114     *              constants and problems with super() calls.  John did a nice
115     *              reorg of the primary/postfix expression stuff to read better
116     *              and makes f.g.super() parse properly (it was METHOD_CALL not
117     *              a SUPER_CTOR_CALL).  Also:
118     *
119     *              o  "finally" clause was a root...made it a child of "try"
120     *              o  Added stuff for asserts too for Java 1.4, but *commented out*
121     *                 as it is not backward compatible.
122     *
123     * Version 1.20 (October 27, 2002)
124     *
125     *        Terence ended up reorging John Pybus' stuff to
126     *        remove some nondeterminisms and some syntactic predicates.
127     *        Note that the grammar is stricter now; e.g., this(...) must
128     *      be the first statement.
129     *
130     *        Trinary ?: operator wasn't working as array name:
131     *                (isBig ? bigDigits : digits)[i];
132     *
133     *        Checked parser/tree parser on source for
134     *                Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
135     *              and the 110k-line jGuru server source.
136     *
137     * Version 1.21 (October 17, 2003)
138     *  Fixed lots of problems including:
139     *  Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g
140     *  He found a problem/fix with floating point that start with 0
141     *  Ray also fixed problem that (int.class) was not recognized.
142     *  Thorsten van Ellen noticed that \n are allowed incorrectly in strings.
143     *  TJP fixed CHAR_LITERAL analogously.
144     *
145     * Version 1.21.2 (March, 2003)
146     *        Changes by Matt Quail to support generics (as per JDK1.5/JSR14)
147     *        Notes:
148     *        o We only allow the "extends" keyword and not the "implements"
149     *              keyword, since thats what JSR14 seems to imply.
150     *        o Thanks to Monty Zukowski for his help on the antlr-interest
151     *              mail list.
152     *        o Thanks to Alan Eliasen for testing the grammar over his
153     *              Fink source base
154     *
155     * Version 1.22 (July, 2004)
156     *        Changes by Michael Studman to support Java 1.5 language extensions
157     *        Notes:
158     *        o Added support for annotations types
159     *        o Finished off Matt Quail's generics enhancements to support bound type arguments
160     *        o Added support for new for statement syntax
161     *        o Added support for static import syntax
162     *        o Added support for enum types
163     *        o Tested against JDK 1.5 source base and source base of jdigraph project
164     *        o Thanks to Matt Quail for doing the hard part by doing most of the generics work
165     *
166     * Version 1.22.1 (July 28, 2004)
167     *        Bug/omission fixes for Java 1.5 language support
168     *        o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for
169     *              spotting this
170     *        o Fixed bug where incorrect handling of SR and BSR tokens would cause type
171     *              parameters to be recognised as type arguments.
172     *        o Enabled type parameters on constructors, annotations on enum constants
173     *              and package definitions
174     *        o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua
175     *
176     * Version 1.22.2 (July 28, 2004)
177     *        Slight refactoring of Java 1.5 language support
178     *        o Refactored for/"foreach" productions so that original literal "for" literal
179     *          is still used but the for sub-clauses vary by token type
180     *        o Fixed bug where type parameter was not included in generic constructor's branch of AST
181     *
182     * Version 1.22.3 (August 26, 2004)
183     *        Bug fixes as identified by Michael Stahl; clean up of tabs/spaces
184     *        and other refactorings
185     *        o Fixed typeParameters omission in identPrimary and newStatement
186     *        o Replaced GT reconcilliation code with simple semantic predicate
187     *        o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar
188     *        o Refactored typeDefinition production and field productions to reduce duplication
189     *
190     * Version 1.22.4 (October 21, 2004)
191     *    Small bux fixes
192     *    o Added typeArguments to explicitConstructorInvocation, e.g. new <String>MyParameterised()
193     *    o Added typeArguments to postfixExpression productions for anonymous inner class super
194     *      constructor invocation, e.g. new Outer().<String>super()
195     *    o Fixed bug in array declarations identified by Geoff Roy
196     *
197     * Version 1.22.4.g.1
198     *    o I have taken java.g for Java1.5 from Michael Studman (1.22.4)
199     *      and have applied the groovy.diff from java.g (1.22) by John Rose
200     *      back onto the new root (1.22.4) - Jeremy Rayner (Jan 2005)
201     *    o for a map of the task see... 
202     *      http://groovy.javanicus.com/java-g.png
203     *
204     * This grammar is in the PUBLIC DOMAIN
205     */
206    public class GroovyRecognizer extends antlr.LLkParser       implements GroovyTokenTypes
207     {
208    
209            /** This factory is the correct way to wire together a Groovy parser and lexer. */
210        public static GroovyRecognizer make(GroovyLexer lexer) {
211            GroovyRecognizer parser = new GroovyRecognizer(lexer.plumb());
212            // TODO: set up a common error-handling control block, to avoid excessive tangle between these guys
213            parser.lexer = lexer;
214            lexer.parser = parser;
215            parser.setASTNodeClass("org.codehaus.groovy.antlr.GroovySourceAST");
216            parser.warningList = new ArrayList();
217            return parser;
218        }
219        // Create a scanner that reads from the input stream passed to us...
220        public static GroovyRecognizer make(InputStream in) { return make(new GroovyLexer(in)); }
221        public static GroovyRecognizer make(Reader in) { return make(new GroovyLexer(in)); }
222        public static GroovyRecognizer make(InputBuffer in) { return make(new GroovyLexer(in)); }
223        public static GroovyRecognizer make(LexerSharedInputState in) { return make(new GroovyLexer(in)); }
224        
225        private static GroovySourceAST dummyVariableToforceClassLoaderToFindASTClass = new GroovySourceAST();
226    
227        List warningList;
228        public List getWarningList() { return warningList; }
229        
230        GroovyLexer lexer;
231        public GroovyLexer getLexer() { return lexer; }
232        public void setFilename(String f) { super.setFilename(f); lexer.setFilename(f); }
233        private SourceBuffer sourceBuffer;
234        public void setSourceBuffer(SourceBuffer sourceBuffer) {
235            this.sourceBuffer = sourceBuffer;
236        }
237    
238        /** Create an AST node with the token type and text passed in, but
239         *  with the same background information as another supplied Token (e.g. line numbers)
240         * to be used in place of antlr tree construction syntax,
241         * i.e. #[TOKEN,"text"]  becomes  create(TOKEN,"text",anotherToken)
242         *
243         * todo - change antlr.ASTFactory to do this instead...
244         */
245        public AST create(int type, String txt, Token first, Token last) {
246            AST t = astFactory.create(type,txt);
247            if ( t != null && first != null) {
248                // first copy details from first token
249                t.initialize(first);
250                // then ensure that type and txt are specific to this new node
251                t.initialize(type,txt);
252            }
253    
254            if ((t instanceof GroovySourceAST) && last != null) {
255                GroovySourceAST node = (GroovySourceAST)t;
256                node.setLast(last);
257                // This is a good point to call node.setSnippet(),
258                // but it bulks up the AST too much for production code.
259            }
260            return t;
261        }
262    
263    
264        // stuff to adjust ANTLR's tracing machinery
265        public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceParser
266        public void traceIn(String rname) throws TokenStreamException {
267            if (!GroovyRecognizer.tracing)  return;
268            super.traceIn(rname);
269        }
270        public void traceOut(String rname) throws TokenStreamException {
271            if (!GroovyRecognizer.tracing)  return;
272            if (returnAST != null)  rname += returnAST.toStringList();
273            super.traceOut(rname);
274        }
275            
276        // Error handling.  This is a funnel through which parser errors go, when the parser can suggest a solution.
277        public void requireFailed(String problem, String solution) throws SemanticException {
278            // TODO: Needs more work.
279            Token lt = null;
280            try { lt = LT(1); }
281            catch (TokenStreamException ee) { }
282            if (lt == null)  lt = Token.badToken;
283            throw new SemanticException(problem + ";\n   solution: " + solution,
284                                        getFilename(), lt.getLine(), lt.getColumn());
285        }
286    
287        public void addWarning(String warning, String solution) {
288            Token lt = null;
289            try { lt = LT(1); }
290            catch (TokenStreamException ee) { }
291            if (lt == null)  lt = Token.badToken;
292    
293            Map row = new HashMap();
294            row.put("warning" ,warning);
295            row.put("solution",solution);
296            row.put("filename",getFilename());
297            row.put("line"    ,new Integer(lt.getLine()));
298            row.put("column"  ,new Integer(lt.getColumn()));
299            // System.out.println(row);
300            warningList.add(row);
301        }
302    
303        // Convenience method for checking of expected error syndromes.
304        private void require(boolean z, String problem, String solution) throws SemanticException {
305            if (!z)  requireFailed(problem, solution);
306        }
307    
308    
309        // Query a name token to see if it begins with a capital letter.
310        // This is used to tell the difference (w/o symbol table access) between {String x} and {println x}.
311        private boolean isUpperCase(Token x) {
312            if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
313            String xtext = x.getText();
314            return (xtext.length() > 0 && Character.isUpperCase(xtext.charAt(0)));
315        }
316    
317        private AST currentClass = null;  // current enclosing class (for constructor recognition)
318        // Query a name token to see if it is identical with the current class name.
319        // This is used to distinguish constructors from other methods.
320        private boolean isConstructorIdent(Token x) {
321            if (currentClass == null)  return false;
322            if (currentClass.getType() != IDENT)  return false;  // cannot happen?
323            String cname = currentClass.getText();
324    
325            if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
326            return cname.equals(x.getText());
327        }
328    
329        // Scratch variable for last 'sep' token.
330        // Written by the 'sep' rule, read only by immediate callers of 'sep'.
331        // (Not entirely clean, but better than a million xx=sep occurrences.)
332        private int sepToken = EOF;
333    
334        // Scratch variable for last argument list; tells whether there was a label.
335        // Written by 'argList' rule, read only by immediate callers of 'argList'.
336        private boolean argListHasLabels = false;
337    
338        // Scratch variable, holds most recently completed pathExpression.
339        // Read only by immediate callers of 'pathExpression' and 'expression'.
340        private AST lastPathExpression = null;
341    
342        // Inherited attribute pushed into most expression rules.
343        // If not zero, it means that the left context of the expression
344        // being parsed is a statement boundary or an initializer sign '='.
345        // Only such expressions are allowed to reach across newlines
346        // to pull in an LCURLY and appended block.
347        private final int LC_STMT = 1, LC_INIT = 2;
348    
349        /**
350         * Counts the number of LT seen in the typeArguments production.
351         * It is used in semantic predicates to ensure we have seen
352         * enough closing '>' characters; which actually may have been
353         * either GT, SR or BSR tokens.
354         */
355        private int ltCounter = 0;
356        
357        /* This symbol is used to work around a known ANTLR limitation.
358         * In a loop with syntactic predicate, ANTLR needs help knowing
359         * that the loop exit is a second alternative.
360         * Example usage:  ( (LCURLY)=> block | {ANTLR_LOOP_EXIT}? )*
361         * Probably should be an ANTLR RFE.
362         */
363        ////// Original comment in Java grammar:
364        // Unfortunately a syntactic predicate can only select one of
365        // multiple alternatives on the same level, not break out of
366        // an enclosing loop, which is why this ugly hack (a fake
367        // empty alternative with always-false semantic predicate)
368        // is necessary.
369        private static final boolean ANTLR_LOOP_EXIT = false;
370    
371    protected GroovyRecognizer(TokenBuffer tokenBuf, int k) {
372      super(tokenBuf,k);
373      tokenNames = _tokenNames;
374      buildTokenTypeASTClassMap();
375      astFactory = new ASTFactory(getTokenTypeToASTClassMap());
376    }
377    
378    public GroovyRecognizer(TokenBuffer tokenBuf) {
379      this(tokenBuf,3);
380    }
381    
382    protected GroovyRecognizer(TokenStream lexer, int k) {
383      super(lexer,k);
384      tokenNames = _tokenNames;
385      buildTokenTypeASTClassMap();
386      astFactory = new ASTFactory(getTokenTypeToASTClassMap());
387    }
388    
389    public GroovyRecognizer(TokenStream lexer) {
390      this(lexer,3);
391    }
392    
393    public GroovyRecognizer(ParserSharedInputState state) {
394      super(state,3);
395      tokenNames = _tokenNames;
396      buildTokenTypeASTClassMap();
397      astFactory = new ASTFactory(getTokenTypeToASTClassMap());
398    }
399    
400            public final void compilationUnit() throws RecognitionException, TokenStreamException {
401                    
402                    returnAST = null;
403                    ASTPair currentAST = new ASTPair();
404                    AST compilationUnit_AST = null;
405                    
406                    {
407                    switch ( LA(1)) {
408                    case SH_COMMENT:
409                    {
410                            match(SH_COMMENT);
411                            break;
412                    }
413                    case EOF:
414                    case FINAL:
415                    case ABSTRACT:
416                    case STRICTFP:
417                    case LITERAL_package:
418                    case LITERAL_import:
419                    case LITERAL_static:
420                    case LITERAL_def:
421                    case AT:
422                    case IDENT:
423                    case LBRACK:
424                    case LPAREN:
425                    case LITERAL_class:
426                    case LITERAL_interface:
427                    case LITERAL_enum:
428                    case LITERAL_super:
429                    case LITERAL_void:
430                    case LITERAL_boolean:
431                    case LITERAL_byte:
432                    case LITERAL_char:
433                    case LITERAL_short:
434                    case LITERAL_int:
435                    case LITERAL_float:
436                    case LITERAL_long:
437                    case LITERAL_double:
438                    case LITERAL_any:
439                    case STAR:
440                    case LITERAL_private:
441                    case LITERAL_public:
442                    case LITERAL_protected:
443                    case LITERAL_transient:
444                    case LITERAL_native:
445                    case LITERAL_threadsafe:
446                    case LITERAL_synchronized:
447                    case LITERAL_volatile:
448                    case LCURLY:
449                    case SEMI:
450                    case NLS:
451                    case LITERAL_this:
452                    case STRING_LITERAL:
453                    case LITERAL_if:
454                    case LITERAL_while:
455                    case LITERAL_with:
456                    case LITERAL_switch:
457                    case LITERAL_for:
458                    case LITERAL_return:
459                    case LITERAL_break:
460                    case LITERAL_continue:
461                    case LITERAL_throw:
462                    case LITERAL_assert:
463                    case PLUS:
464                    case MINUS:
465                    case LITERAL_try:
466                    case INC:
467                    case DEC:
468                    case BNOT:
469                    case LNOT:
470                    case DOLLAR:
471                    case STRING_CTOR_START:
472                    case LITERAL_new:
473                    case LITERAL_true:
474                    case LITERAL_false:
475                    case LITERAL_null:
476                    case NUM_INT:
477                    case NUM_FLOAT:
478                    case NUM_LONG:
479                    case NUM_DOUBLE:
480                    case NUM_BIG_INT:
481                    case NUM_BIG_DECIMAL:
482                    {
483                            break;
484                    }
485                    default:
486                    {
487                            throw new NoViableAltException(LT(1), getFilename());
488                    }
489                    }
490                    }
491                    nls();
492                    {
493                    boolean synPredMatched5 = false;
494                    if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT) && (_tokenSet_0.member(LA(3))))) {
495                            int _m5 = mark();
496                            synPredMatched5 = true;
497                            inputState.guessing++;
498                            try {
499                                    {
500                                    annotationsOpt();
501                                    match(LITERAL_package);
502                                    }
503                            }
504                            catch (RecognitionException pe) {
505                                    synPredMatched5 = false;
506                            }
507                            rewind(_m5);
508    inputState.guessing--;
509                    }
510                    if ( synPredMatched5 ) {
511                            packageDefinition();
512                            astFactory.addASTChild(currentAST, returnAST);
513                    }
514                    else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
515                            {
516                            switch ( LA(1)) {
517                            case FINAL:
518                            case ABSTRACT:
519                            case STRICTFP:
520                            case LITERAL_import:
521                            case LITERAL_static:
522                            case LITERAL_def:
523                            case AT:
524                            case IDENT:
525                            case LBRACK:
526                            case LPAREN:
527                            case LITERAL_class:
528                            case LITERAL_interface:
529                            case LITERAL_enum:
530                            case LITERAL_super:
531                            case LITERAL_void:
532                            case LITERAL_boolean:
533                            case LITERAL_byte:
534                            case LITERAL_char:
535                            case LITERAL_short:
536                            case LITERAL_int:
537                            case LITERAL_float:
538                            case LITERAL_long:
539                            case LITERAL_double:
540                            case LITERAL_any:
541                            case STAR:
542                            case LITERAL_private:
543                            case LITERAL_public:
544                            case LITERAL_protected:
545                            case LITERAL_transient:
546                            case LITERAL_native:
547                            case LITERAL_threadsafe:
548                            case LITERAL_synchronized:
549                            case LITERAL_volatile:
550                            case LCURLY:
551                            case LITERAL_this:
552                            case STRING_LITERAL:
553                            case LITERAL_if:
554                            case LITERAL_while:
555                            case LITERAL_with:
556                            case LITERAL_switch:
557                            case LITERAL_for:
558                            case LITERAL_return:
559                            case LITERAL_break:
560                            case LITERAL_continue:
561                            case LITERAL_throw:
562                            case LITERAL_assert:
563                            case PLUS:
564                            case MINUS:
565                            case LITERAL_try:
566                            case INC:
567                            case DEC:
568                            case BNOT:
569                            case LNOT:
570                            case DOLLAR:
571                            case STRING_CTOR_START:
572                            case LITERAL_new:
573                            case LITERAL_true:
574                            case LITERAL_false:
575                            case LITERAL_null:
576                            case NUM_INT:
577                            case NUM_FLOAT:
578                            case NUM_LONG:
579                            case NUM_DOUBLE:
580                            case NUM_BIG_INT:
581                            case NUM_BIG_DECIMAL:
582                            {
583                                    statement(EOF);
584                                    astFactory.addASTChild(currentAST, returnAST);
585                                    break;
586                            }
587                            case EOF:
588                            case SEMI:
589                            case NLS:
590                            {
591                                    break;
592                            }
593                            default:
594                            {
595                                    throw new NoViableAltException(LT(1), getFilename());
596                            }
597                            }
598                            }
599                    }
600                    else {
601                            throw new NoViableAltException(LT(1), getFilename());
602                    }
603                    
604                    }
605                    {
606                    _loop9:
607                    do {
608                            if ((LA(1)==SEMI||LA(1)==NLS)) {
609                                    sep();
610                                    {
611                                    switch ( LA(1)) {
612                                    case FINAL:
613                                    case ABSTRACT:
614                                    case STRICTFP:
615                                    case LITERAL_import:
616                                    case LITERAL_static:
617                                    case LITERAL_def:
618                                    case AT:
619                                    case IDENT:
620                                    case LBRACK:
621                                    case LPAREN:
622                                    case LITERAL_class:
623                                    case LITERAL_interface:
624                                    case LITERAL_enum:
625                                    case LITERAL_super:
626                                    case LITERAL_void:
627                                    case LITERAL_boolean:
628                                    case LITERAL_byte:
629                                    case LITERAL_char:
630                                    case LITERAL_short:
631                                    case LITERAL_int:
632                                    case LITERAL_float:
633                                    case LITERAL_long:
634                                    case LITERAL_double:
635                                    case LITERAL_any:
636                                    case STAR:
637                                    case LITERAL_private:
638                                    case LITERAL_public:
639                                    case LITERAL_protected:
640                                    case LITERAL_transient:
641                                    case LITERAL_native:
642                                    case LITERAL_threadsafe:
643                                    case LITERAL_synchronized:
644                                    case LITERAL_volatile:
645                                    case LCURLY:
646                                    case LITERAL_this:
647                                    case STRING_LITERAL:
648                                    case LITERAL_if:
649                                    case LITERAL_while:
650                                    case LITERAL_with:
651                                    case LITERAL_switch:
652                                    case LITERAL_for:
653                                    case LITERAL_return:
654                                    case LITERAL_break:
655                                    case LITERAL_continue:
656                                    case LITERAL_throw:
657                                    case LITERAL_assert:
658                                    case PLUS:
659                                    case MINUS:
660                                    case LITERAL_try:
661                                    case INC:
662                                    case DEC:
663                                    case BNOT:
664                                    case LNOT:
665                                    case DOLLAR:
666                                    case STRING_CTOR_START:
667                                    case LITERAL_new:
668                                    case LITERAL_true:
669                                    case LITERAL_false:
670                                    case LITERAL_null:
671                                    case NUM_INT:
672                                    case NUM_FLOAT:
673                                    case NUM_LONG:
674                                    case NUM_DOUBLE:
675                                    case NUM_BIG_INT:
676                                    case NUM_BIG_DECIMAL:
677                                    {
678                                            statement(sepToken);
679                                            astFactory.addASTChild(currentAST, returnAST);
680                                            break;
681                                    }
682                                    case EOF:
683                                    case SEMI:
684                                    case NLS:
685                                    {
686                                            break;
687                                    }
688                                    default:
689                                    {
690                                            throw new NoViableAltException(LT(1), getFilename());
691                                    }
692                                    }
693                                    }
694                            }
695                            else {
696                                    break _loop9;
697                            }
698                            
699                    } while (true);
700                    }
701                    match(Token.EOF_TYPE);
702                    compilationUnit_AST = (AST)currentAST.root;
703                    returnAST = compilationUnit_AST;
704            }
705            
706    /** Zero or more insignificant newlines, all gobbled up and thrown away. */
707            public final void nls() throws RecognitionException, TokenStreamException {
708                    
709                    returnAST = null;
710                    ASTPair currentAST = new ASTPair();
711                    AST nls_AST = null;
712                    
713                    {
714                    if ((LA(1)==NLS) && (_tokenSet_4.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
715                            match(NLS);
716                    }
717                    else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
718                    }
719                    else {
720                            throw new NoViableAltException(LT(1), getFilename());
721                    }
722                    
723                    }
724                    returnAST = nls_AST;
725            }
726            
727            public final void annotationsOpt() throws RecognitionException, TokenStreamException {
728                    
729                    returnAST = null;
730                    ASTPair currentAST = new ASTPair();
731                    AST annotationsOpt_AST = null;
732                    Token first = LT(1);
733                    
734                    {
735                    _loop79:
736                    do {
737                            if ((LA(1)==AT)) {
738                                    annotation();
739                                    astFactory.addASTChild(currentAST, returnAST);
740                                    nls();
741                            }
742                            else {
743                                    break _loop79;
744                            }
745                            
746                    } while (true);
747                    }
748                    if ( inputState.guessing==0 ) {
749                            annotationsOpt_AST = (AST)currentAST.root;
750                            annotationsOpt_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ANNOTATIONS,"ANNOTATIONS",first,LT(1))).add(annotationsOpt_AST));
751                            currentAST.root = annotationsOpt_AST;
752                            currentAST.child = annotationsOpt_AST!=null &&annotationsOpt_AST.getFirstChild()!=null ?
753                                    annotationsOpt_AST.getFirstChild() : annotationsOpt_AST;
754                            currentAST.advanceChildToEnd();
755                    }
756                    annotationsOpt_AST = (AST)currentAST.root;
757                    returnAST = annotationsOpt_AST;
758            }
759            
760            public final void packageDefinition() throws RecognitionException, TokenStreamException {
761                    
762                    returnAST = null;
763                    ASTPair currentAST = new ASTPair();
764                    AST packageDefinition_AST = null;
765                    Token  p = null;
766                    AST p_AST = null;
767                    
768                    annotationsOpt();
769                    astFactory.addASTChild(currentAST, returnAST);
770                    p = LT(1);
771                    p_AST = astFactory.create(p);
772                    astFactory.makeASTRoot(currentAST, p_AST);
773                    match(LITERAL_package);
774                    if ( inputState.guessing==0 ) {
775                            p_AST.setType(PACKAGE_DEF);
776                    }
777                    identifier();
778                    astFactory.addASTChild(currentAST, returnAST);
779                    packageDefinition_AST = (AST)currentAST.root;
780                    returnAST = packageDefinition_AST;
781            }
782            
783    /** A statement is an element of a block.
784     *  Typical statements are declarations (which are scoped to the block)
785     *  and expressions.
786     */
787            public final void statement(
788                    int prevToken
789            ) throws RecognitionException, TokenStreamException {
790                    
791                    returnAST = null;
792                    ASTPair currentAST = new ASTPair();
793                    AST statement_AST = null;
794                    AST pfx_AST = null;
795                    AST m_AST = null;
796                    Token  sp = null;
797                    AST sp_AST = null;
798                    
799                    switch ( LA(1)) {
800                    case LITERAL_if:
801                    {
802                            AST tmp4_AST = null;
803                            tmp4_AST = astFactory.create(LT(1));
804                            astFactory.makeASTRoot(currentAST, tmp4_AST);
805                            match(LITERAL_if);
806                            match(LPAREN);
807                            assignmentLessExpression();
808                            astFactory.addASTChild(currentAST, returnAST);
809                            match(RPAREN);
810                            nlsWarn();
811                            compatibleBodyStatement();
812                            astFactory.addASTChild(currentAST, returnAST);
813                            {
814                            boolean synPredMatched251 = false;
815                            if (((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2))) && (_tokenSet_8.member(LA(3))))) {
816                                    int _m251 = mark();
817                                    synPredMatched251 = true;
818                                    inputState.guessing++;
819                                    try {
820                                            {
821                                            {
822                                            switch ( LA(1)) {
823                                            case SEMI:
824                                            case NLS:
825                                            {
826                                                    sep();
827                                                    break;
828                                            }
829                                            case LITERAL_else:
830                                            {
831                                                    break;
832                                            }
833                                            default:
834                                            {
835                                                    throw new NoViableAltException(LT(1), getFilename());
836                                            }
837                                            }
838                                            }
839                                            match(LITERAL_else);
840                                            }
841                                    }
842                                    catch (RecognitionException pe) {
843                                            synPredMatched251 = false;
844                                    }
845                                    rewind(_m251);
846    inputState.guessing--;
847                            }
848                            if ( synPredMatched251 ) {
849                                    {
850                                    switch ( LA(1)) {
851                                    case SEMI:
852                                    case NLS:
853                                    {
854                                            sep();
855                                            break;
856                                    }
857                                    case LITERAL_else:
858                                    {
859                                            break;
860                                    }
861                                    default:
862                                    {
863                                            throw new NoViableAltException(LT(1), getFilename());
864                                    }
865                                    }
866                                    }
867                                    match(LITERAL_else);
868                                    nlsWarn();
869                                    compatibleBodyStatement();
870                                    astFactory.addASTChild(currentAST, returnAST);
871                            }
872                            else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
873                            }
874                            else {
875                                    throw new NoViableAltException(LT(1), getFilename());
876                            }
877                            
878                            }
879                            statement_AST = (AST)currentAST.root;
880                            break;
881                    }
882                    case LITERAL_for:
883                    {
884                            forStatement();
885                            astFactory.addASTChild(currentAST, returnAST);
886                            statement_AST = (AST)currentAST.root;
887                            break;
888                    }
889                    case LITERAL_while:
890                    {
891                            AST tmp8_AST = null;
892                            tmp8_AST = astFactory.create(LT(1));
893                            astFactory.makeASTRoot(currentAST, tmp8_AST);
894                            match(LITERAL_while);
895                            match(LPAREN);
896                            strictContextExpression();
897                            astFactory.addASTChild(currentAST, returnAST);
898                            match(RPAREN);
899                            nlsWarn();
900                            compatibleBodyStatement();
901                            astFactory.addASTChild(currentAST, returnAST);
902                            statement_AST = (AST)currentAST.root;
903                            break;
904                    }
905                    case LITERAL_with:
906                    {
907                            AST tmp11_AST = null;
908                            tmp11_AST = astFactory.create(LT(1));
909                            astFactory.makeASTRoot(currentAST, tmp11_AST);
910                            match(LITERAL_with);
911                            match(LPAREN);
912                            strictContextExpression();
913                            astFactory.addASTChild(currentAST, returnAST);
914                            match(RPAREN);
915                            nlsWarn();
916                            compoundStatement();
917                            astFactory.addASTChild(currentAST, returnAST);
918                            statement_AST = (AST)currentAST.root;
919                            break;
920                    }
921                    case STAR:
922                    {
923                            sp = LT(1);
924                            sp_AST = astFactory.create(sp);
925                            astFactory.makeASTRoot(currentAST, sp_AST);
926                            match(STAR);
927                            nls();
928                            if ( inputState.guessing==0 ) {
929                                    sp_AST.setType(SPREAD_ARG);
930                            }
931                            expressionStatement(EOF);
932                            astFactory.addASTChild(currentAST, returnAST);
933                            statement_AST = (AST)currentAST.root;
934                            break;
935                    }
936                    case LITERAL_import:
937                    {
938                            importStatement();
939                            astFactory.addASTChild(currentAST, returnAST);
940                            statement_AST = (AST)currentAST.root;
941                            break;
942                    }
943                    case LITERAL_switch:
944                    {
945                            AST tmp14_AST = null;
946                            tmp14_AST = astFactory.create(LT(1));
947                            astFactory.makeASTRoot(currentAST, tmp14_AST);
948                            match(LITERAL_switch);
949                            match(LPAREN);
950                            strictContextExpression();
951                            astFactory.addASTChild(currentAST, returnAST);
952                            match(RPAREN);
953                            nlsWarn();
954                            match(LCURLY);
955                            nls();
956                            {
957                            _loop254:
958                            do {
959                                    if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case)) {
960                                            casesGroup();
961                                            astFactory.addASTChild(currentAST, returnAST);
962                                    }
963                                    else {
964                                            break _loop254;
965                                    }
966                                    
967                            } while (true);
968                            }
969                            match(RCURLY);
970                            statement_AST = (AST)currentAST.root;
971                            break;
972                    }
973                    case LITERAL_try:
974                    {
975                            tryBlock();
976                            astFactory.addASTChild(currentAST, returnAST);
977                            statement_AST = (AST)currentAST.root;
978                            break;
979                    }
980                    case LITERAL_return:
981                    case LITERAL_break:
982                    case LITERAL_continue:
983                    case LITERAL_throw:
984                    case LITERAL_assert:
985                    {
986                            branchStatement();
987                            astFactory.addASTChild(currentAST, returnAST);
988                            statement_AST = (AST)currentAST.root;
989                            break;
990                    }
991                    default:
992                            boolean synPredMatched242 = false;
993                            if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))) && (_tokenSet_14.member(LA(3))))) {
994                                    int _m242 = mark();
995                                    synPredMatched242 = true;
996                                    inputState.guessing++;
997                                    try {
998                                            {
999                                            declarationStart();
1000                                            }
1001                                    }
1002                                    catch (RecognitionException pe) {
1003                                            synPredMatched242 = false;
1004                                    }
1005                                    rewind(_m242);
1006    inputState.guessing--;
1007                            }
1008                            if ( synPredMatched242 ) {
1009                                    declaration();
1010                                    astFactory.addASTChild(currentAST, returnAST);
1011                                    statement_AST = (AST)currentAST.root;
1012                            }
1013                            else {
1014                                    boolean synPredMatched244 = false;
1015                                    if (((LA(1)==IDENT) && (LA(2)==COLON) && (_tokenSet_15.member(LA(3))))) {
1016                                            int _m244 = mark();
1017                                            synPredMatched244 = true;
1018                                            inputState.guessing++;
1019                                            try {
1020                                                    {
1021                                                    match(IDENT);
1022                                                    match(COLON);
1023                                                    }
1024                                            }
1025                                            catch (RecognitionException pe) {
1026                                                    synPredMatched244 = false;
1027                                            }
1028                                            rewind(_m244);
1029    inputState.guessing--;
1030                                    }
1031                                    if ( synPredMatched244 ) {
1032                                            statementLabelPrefix();
1033                                            pfx_AST = (AST)returnAST;
1034                                            if ( inputState.guessing==0 ) {
1035                                                    statement_AST = (AST)currentAST.root;
1036                                                    statement_AST = pfx_AST;
1037                                                    currentAST.root = statement_AST;
1038                                                    currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
1039                                                            statement_AST.getFirstChild() : statement_AST;
1040                                                    currentAST.advanceChildToEnd();
1041                                            }
1042                                            {
1043                                            boolean synPredMatched247 = false;
1044                                            if (((LA(1)==LCURLY) && (_tokenSet_16.member(LA(2))) && (_tokenSet_8.member(LA(3))))) {
1045                                                    int _m247 = mark();
1046                                                    synPredMatched247 = true;
1047                                                    inputState.guessing++;
1048                                                    try {
1049                                                            {
1050                                                            match(LCURLY);
1051                                                            }
1052                                                    }
1053                                                    catch (RecognitionException pe) {
1054                                                            synPredMatched247 = false;
1055                                                    }
1056                                                    rewind(_m247);
1057    inputState.guessing--;
1058                                            }
1059                                            if ( synPredMatched247 ) {
1060                                                    openOrClosableBlock();
1061                                                    astFactory.addASTChild(currentAST, returnAST);
1062                                            }
1063                                            else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_18.member(LA(3)))) {
1064                                                    statement(COLON);
1065                                                    astFactory.addASTChild(currentAST, returnAST);
1066                                            }
1067                                            else {
1068                                                    throw new NoViableAltException(LT(1), getFilename());
1069                                            }
1070                                            
1071                                            }
1072                                            statement_AST = (AST)currentAST.root;
1073                                    }
1074                                    else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
1075                                            expressionStatement(prevToken);
1076                                            astFactory.addASTChild(currentAST, returnAST);
1077                                            statement_AST = (AST)currentAST.root;
1078                                    }
1079                                    else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))) && (_tokenSet_23.member(LA(3)))) {
1080                                            modifiersOpt();
1081                                            m_AST = (AST)returnAST;
1082                                            typeDefinitionInternal(m_AST);
1083                                            astFactory.addASTChild(currentAST, returnAST);
1084                                            statement_AST = (AST)currentAST.root;
1085                                    }
1086                                    else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
1087                                            AST tmp19_AST = null;
1088                                            tmp19_AST = astFactory.create(LT(1));
1089                                            astFactory.makeASTRoot(currentAST, tmp19_AST);
1090                                            match(LITERAL_synchronized);
1091                                            match(LPAREN);
1092                                            strictContextExpression();
1093                                            astFactory.addASTChild(currentAST, returnAST);
1094                                            match(RPAREN);
1095                                            nlsWarn();
1096                                            compoundStatement();
1097                                            astFactory.addASTChild(currentAST, returnAST);
1098                                            statement_AST = (AST)currentAST.root;
1099                                    }
1100                            else {
1101                                    throw new NoViableAltException(LT(1), getFilename());
1102                            }
1103                            }}
1104                            returnAST = statement_AST;
1105                    }
1106                    
1107    /** A statement separator is either a semicolon or a significant newline. 
1108     *  Any number of additional (insignificant) newlines may accompany it.
1109     */
1110            public final void sep() throws RecognitionException, TokenStreamException {
1111                    
1112                    returnAST = null;
1113                    ASTPair currentAST = new ASTPair();
1114                    AST sep_AST = null;
1115                    
1116                    switch ( LA(1)) {
1117                    case SEMI:
1118                    {
1119                            match(SEMI);
1120                            {
1121                            _loop475:
1122                            do {
1123                                    if ((LA(1)==NLS) && (_tokenSet_24.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
1124                                            match(NLS);
1125                                    }
1126                                    else {
1127                                            break _loop475;
1128                                    }
1129                                    
1130                            } while (true);
1131                            }
1132                            if ( inputState.guessing==0 ) {
1133                                    sepToken = SEMI;
1134                            }
1135                            break;
1136                    }
1137                    case NLS:
1138                    {
1139                            match(NLS);
1140                            if ( inputState.guessing==0 ) {
1141                                    sepToken = NLS;
1142                            }
1143                            {
1144                            _loop479:
1145                            do {
1146                                    if ((LA(1)==SEMI) && (_tokenSet_24.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
1147                                            match(SEMI);
1148                                            {
1149                                            _loop478:
1150                                            do {
1151                                                    if ((LA(1)==NLS) && (_tokenSet_24.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
1152                                                            match(NLS);
1153                                                    }
1154                                                    else {
1155                                                            break _loop478;
1156                                                    }
1157                                                    
1158                                            } while (true);
1159                                            }
1160                                            if ( inputState.guessing==0 ) {
1161                                                    sepToken = SEMI;
1162                                            }
1163                                    }
1164                                    else {
1165                                            break _loop479;
1166                                    }
1167                                    
1168                            } while (true);
1169                            }
1170                            break;
1171                    }
1172                    default:
1173                    {
1174                            throw new NoViableAltException(LT(1), getFilename());
1175                    }
1176                    }
1177                    returnAST = sep_AST;
1178            }
1179            
1180    /** A Groovy script or simple expression.  Can be anything legal inside {...}. */
1181            public final void snippetUnit() throws RecognitionException, TokenStreamException {
1182                    
1183                    returnAST = null;
1184                    ASTPair currentAST = new ASTPair();
1185                    AST snippetUnit_AST = null;
1186                    
1187                    nls();
1188                    blockBody(EOF);
1189                    astFactory.addASTChild(currentAST, returnAST);
1190                    snippetUnit_AST = (AST)currentAST.root;
1191                    returnAST = snippetUnit_AST;
1192            }
1193            
1194    /** A block body is a parade of zero or more statements or expressions. */
1195            public final void blockBody(
1196                    int prevToken
1197            ) throws RecognitionException, TokenStreamException {
1198                    
1199                    returnAST = null;
1200                    ASTPair currentAST = new ASTPair();
1201                    AST blockBody_AST = null;
1202                    
1203                    {
1204                    switch ( LA(1)) {
1205                    case FINAL:
1206                    case ABSTRACT:
1207                    case STRICTFP:
1208                    case LITERAL_import:
1209                    case LITERAL_static:
1210                    case LITERAL_def:
1211                    case AT:
1212                    case IDENT:
1213                    case LBRACK:
1214                    case LPAREN:
1215                    case LITERAL_class:
1216                    case LITERAL_interface:
1217                    case LITERAL_enum:
1218                    case LITERAL_super:
1219                    case LITERAL_void:
1220                    case LITERAL_boolean:
1221                    case LITERAL_byte:
1222                    case LITERAL_char:
1223                    case LITERAL_short:
1224                    case LITERAL_int:
1225                    case LITERAL_float:
1226                    case LITERAL_long:
1227                    case LITERAL_double:
1228                    case LITERAL_any:
1229                    case STAR:
1230                    case LITERAL_private:
1231                    case LITERAL_public:
1232                    case LITERAL_protected:
1233                    case LITERAL_transient:
1234                    case LITERAL_native:
1235                    case LITERAL_threadsafe:
1236                    case LITERAL_synchronized:
1237                    case LITERAL_volatile:
1238                    case LCURLY:
1239                    case LITERAL_this:
1240                    case STRING_LITERAL:
1241                    case LITERAL_if:
1242                    case LITERAL_while:
1243                    case LITERAL_with:
1244                    case LITERAL_switch:
1245                    case LITERAL_for:
1246                    case LITERAL_return:
1247                    case LITERAL_break:
1248                    case LITERAL_continue:
1249                    case LITERAL_throw:
1250                    case LITERAL_assert:
1251                    case PLUS:
1252                    case MINUS:
1253                    case LITERAL_try:
1254                    case INC:
1255                    case DEC:
1256                    case BNOT:
1257                    case LNOT:
1258                    case DOLLAR:
1259                    case STRING_CTOR_START:
1260                    case LITERAL_new:
1261                    case LITERAL_true:
1262                    case LITERAL_false:
1263                    case LITERAL_null:
1264                    case NUM_INT:
1265                    case NUM_FLOAT:
1266                    case NUM_LONG:
1267                    case NUM_DOUBLE:
1268                    case NUM_BIG_INT:
1269                    case NUM_BIG_DECIMAL:
1270                    {
1271                            statement(prevToken);
1272                            astFactory.addASTChild(currentAST, returnAST);
1273                            break;
1274                    }
1275                    case EOF:
1276                    case RCURLY:
1277                    case SEMI:
1278                    case NLS:
1279                    {
1280                            break;
1281                    }
1282                    default:
1283                    {
1284                            throw new NoViableAltException(LT(1), getFilename());
1285                    }
1286                    }
1287                    }
1288                    {
1289                    _loop236:
1290                    do {
1291                            if ((LA(1)==SEMI||LA(1)==NLS)) {
1292                                    sep();
1293                                    {
1294                                    switch ( LA(1)) {
1295                                    case FINAL:
1296                                    case ABSTRACT:
1297                                    case STRICTFP:
1298                                    case LITERAL_import:
1299                                    case LITERAL_static:
1300                                    case LITERAL_def:
1301                                    case AT:
1302                                    case IDENT:
1303                                    case LBRACK:
1304                                    case LPAREN:
1305                                    case LITERAL_class:
1306                                    case LITERAL_interface:
1307                                    case LITERAL_enum:
1308                                    case LITERAL_super:
1309                                    case LITERAL_void:
1310                                    case LITERAL_boolean:
1311                                    case LITERAL_byte:
1312                                    case LITERAL_char:
1313                                    case LITERAL_short:
1314                                    case LITERAL_int:
1315                                    case LITERAL_float:
1316                                    case LITERAL_long:
1317                                    case LITERAL_double:
1318                                    case LITERAL_any:
1319                                    case STAR:
1320                                    case LITERAL_private:
1321                                    case LITERAL_public:
1322                                    case LITERAL_protected:
1323                                    case LITERAL_transient:
1324                                    case LITERAL_native:
1325                                    case LITERAL_threadsafe:
1326                                    case LITERAL_synchronized:
1327                                    case LITERAL_volatile:
1328                                    case LCURLY:
1329                                    case LITERAL_this:
1330                                    case STRING_LITERAL:
1331                                    case LITERAL_if:
1332                                    case LITERAL_while:
1333                                    case LITERAL_with:
1334                                    case LITERAL_switch:
1335                                    case LITERAL_for:
1336                                    case LITERAL_return:
1337                                    case LITERAL_break:
1338                                    case LITERAL_continue:
1339                                    case LITERAL_throw:
1340                                    case LITERAL_assert:
1341                                    case PLUS:
1342                                    case MINUS:
1343                                    case LITERAL_try:
1344                                    case INC:
1345                                    case DEC:
1346                                    case BNOT:
1347                                    case LNOT:
1348                                    case DOLLAR:
1349                                    case STRING_CTOR_START:
1350                                    case LITERAL_new:
1351                                    case LITERAL_true:
1352                                    case LITERAL_false:
1353                                    case LITERAL_null:
1354                                    case NUM_INT:
1355                                    case NUM_FLOAT:
1356                                    case NUM_LONG:
1357                                    case NUM_DOUBLE:
1358                                    case NUM_BIG_INT:
1359                                    case NUM_BIG_DECIMAL:
1360                                    {
1361                                            statement(sepToken);
1362                                            astFactory.addASTChild(currentAST, returnAST);
1363                                            break;
1364                                    }
1365                                    case EOF:
1366                                    case RCURLY:
1367                                    case SEMI:
1368                                    case NLS:
1369                                    {
1370                                            break;
1371                                    }
1372                                    default:
1373                                    {
1374                                            throw new NoViableAltException(LT(1), getFilename());
1375                                    }
1376                                    }
1377                                    }
1378                            }
1379                            else {
1380                                    break _loop236;
1381                            }
1382                            
1383                    } while (true);
1384                    }
1385                    blockBody_AST = (AST)currentAST.root;
1386                    returnAST = blockBody_AST;
1387            }
1388            
1389            public final void identifier() throws RecognitionException, TokenStreamException {
1390                    
1391                    returnAST = null;
1392                    ASTPair currentAST = new ASTPair();
1393                    AST identifier_AST = null;
1394                    
1395                    AST tmp27_AST = null;
1396                    tmp27_AST = astFactory.create(LT(1));
1397                    astFactory.addASTChild(currentAST, tmp27_AST);
1398                    match(IDENT);
1399                    {
1400                    _loop62:
1401                    do {
1402                            if ((LA(1)==DOT)) {
1403                                    AST tmp28_AST = null;
1404                                    tmp28_AST = astFactory.create(LT(1));
1405                                    astFactory.makeASTRoot(currentAST, tmp28_AST);
1406                                    match(DOT);
1407                                    nls();
1408                                    AST tmp29_AST = null;
1409                                    tmp29_AST = astFactory.create(LT(1));
1410                                    astFactory.addASTChild(currentAST, tmp29_AST);
1411                                    match(IDENT);
1412                            }
1413                            else {
1414                                    break _loop62;
1415                            }
1416                            
1417                    } while (true);
1418                    }
1419                    identifier_AST = (AST)currentAST.root;
1420                    returnAST = identifier_AST;
1421            }
1422            
1423            public final void importStatement() throws RecognitionException, TokenStreamException {
1424                    
1425                    returnAST = null;
1426                    ASTPair currentAST = new ASTPair();
1427                    AST importStatement_AST = null;
1428                    Token  i = null;
1429                    AST i_AST = null;
1430                    boolean isStatic = false;
1431                    
1432                    i = LT(1);
1433                    i_AST = astFactory.create(i);
1434                    astFactory.makeASTRoot(currentAST, i_AST);
1435                    match(LITERAL_import);
1436                    if ( inputState.guessing==0 ) {
1437                            i_AST.setType(IMPORT);
1438                    }
1439                    {
1440                    switch ( LA(1)) {
1441                    case LITERAL_static:
1442                    {
1443                            match(LITERAL_static);
1444                            if ( inputState.guessing==0 ) {
1445                                    i_AST.setType(STATIC_IMPORT);
1446                            }
1447                            break;
1448                    }
1449                    case IDENT:
1450                    {
1451                            break;
1452                    }
1453                    default:
1454                    {
1455                            throw new NoViableAltException(LT(1), getFilename());
1456                    }
1457                    }
1458                    }
1459                    identifierStar();
1460                    astFactory.addASTChild(currentAST, returnAST);
1461                    importStatement_AST = (AST)currentAST.root;
1462                    returnAST = importStatement_AST;
1463            }
1464            
1465            public final void identifierStar() throws RecognitionException, TokenStreamException {
1466                    
1467                    returnAST = null;
1468                    ASTPair currentAST = new ASTPair();
1469                    AST identifierStar_AST = null;
1470                    
1471                    AST tmp31_AST = null;
1472                    tmp31_AST = astFactory.create(LT(1));
1473                    astFactory.addASTChild(currentAST, tmp31_AST);
1474                    match(IDENT);
1475                    {
1476                    _loop65:
1477                    do {
1478                            if ((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==NLS) && (_tokenSet_25.member(LA(3)))) {
1479                                    AST tmp32_AST = null;
1480                                    tmp32_AST = astFactory.create(LT(1));
1481                                    astFactory.makeASTRoot(currentAST, tmp32_AST);
1482                                    match(DOT);
1483                                    nls();
1484                                    AST tmp33_AST = null;
1485                                    tmp33_AST = astFactory.create(LT(1));
1486                                    astFactory.addASTChild(currentAST, tmp33_AST);
1487                                    match(IDENT);
1488                            }
1489                            else {
1490                                    break _loop65;
1491                            }
1492                            
1493                    } while (true);
1494                    }
1495                    {
1496                    switch ( LA(1)) {
1497                    case DOT:
1498                    {
1499                            AST tmp34_AST = null;
1500                            tmp34_AST = astFactory.create(LT(1));
1501                            astFactory.makeASTRoot(currentAST, tmp34_AST);
1502                            match(DOT);
1503                            nls();
1504                            AST tmp35_AST = null;
1505                            tmp35_AST = astFactory.create(LT(1));
1506                            astFactory.addASTChild(currentAST, tmp35_AST);
1507                            match(STAR);
1508                            break;
1509                    }
1510                    case LITERAL_as:
1511                    {
1512                            AST tmp36_AST = null;
1513                            tmp36_AST = astFactory.create(LT(1));
1514                            astFactory.makeASTRoot(currentAST, tmp36_AST);
1515                            match(LITERAL_as);
1516                            nls();
1517                            AST tmp37_AST = null;
1518                            tmp37_AST = astFactory.create(LT(1));
1519                            astFactory.addASTChild(currentAST, tmp37_AST);
1520                            match(IDENT);
1521                            break;
1522                    }
1523                    case EOF:
1524                    case RCURLY:
1525                    case SEMI:
1526                    case NLS:
1527                    case LITERAL_default:
1528                    case LITERAL_else:
1529                    case LITERAL_case:
1530                    {
1531                            break;
1532                    }
1533                    default:
1534                    {
1535                            throw new NoViableAltException(LT(1), getFilename());
1536                    }
1537                    }
1538                    }
1539                    identifierStar_AST = (AST)currentAST.root;
1540                    returnAST = identifierStar_AST;
1541            }
1542            
1543            protected final void typeDefinitionInternal(
1544                    AST mods
1545            ) throws RecognitionException, TokenStreamException {
1546                    
1547                    returnAST = null;
1548                    ASTPair currentAST = new ASTPair();
1549                    AST typeDefinitionInternal_AST = null;
1550                    AST cd_AST = null;
1551                    AST id_AST = null;
1552                    AST ed_AST = null;
1553                    AST ad_AST = null;
1554                    
1555                    switch ( LA(1)) {
1556                    case LITERAL_class:
1557                    {
1558                            classDefinition(mods);
1559                            cd_AST = (AST)returnAST;
1560                            astFactory.addASTChild(currentAST, returnAST);
1561                            if ( inputState.guessing==0 ) {
1562                                    typeDefinitionInternal_AST = (AST)currentAST.root;
1563                                    typeDefinitionInternal_AST = cd_AST;
1564                                    currentAST.root = typeDefinitionInternal_AST;
1565                                    currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1566                                            typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1567                                    currentAST.advanceChildToEnd();
1568                            }
1569                            typeDefinitionInternal_AST = (AST)currentAST.root;
1570                            break;
1571                    }
1572                    case LITERAL_interface:
1573                    {
1574                            interfaceDefinition(mods);
1575                            id_AST = (AST)returnAST;
1576                            astFactory.addASTChild(currentAST, returnAST);
1577                            if ( inputState.guessing==0 ) {
1578                                    typeDefinitionInternal_AST = (AST)currentAST.root;
1579                                    typeDefinitionInternal_AST = id_AST;
1580                                    currentAST.root = typeDefinitionInternal_AST;
1581                                    currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1582                                            typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1583                                    currentAST.advanceChildToEnd();
1584                            }
1585                            typeDefinitionInternal_AST = (AST)currentAST.root;
1586                            break;
1587                    }
1588                    case LITERAL_enum:
1589                    {
1590                            enumDefinition(mods);
1591                            ed_AST = (AST)returnAST;
1592                            astFactory.addASTChild(currentAST, returnAST);
1593                            if ( inputState.guessing==0 ) {
1594                                    typeDefinitionInternal_AST = (AST)currentAST.root;
1595                                    typeDefinitionInternal_AST = ed_AST;
1596                                    currentAST.root = typeDefinitionInternal_AST;
1597                                    currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1598                                            typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1599                                    currentAST.advanceChildToEnd();
1600                            }
1601                            typeDefinitionInternal_AST = (AST)currentAST.root;
1602                            break;
1603                    }
1604                    case AT:
1605                    {
1606                            annotationDefinition(mods);
1607                            ad_AST = (AST)returnAST;
1608                            astFactory.addASTChild(currentAST, returnAST);
1609                            if ( inputState.guessing==0 ) {
1610                                    typeDefinitionInternal_AST = (AST)currentAST.root;
1611                                    typeDefinitionInternal_AST = ad_AST;
1612                                    currentAST.root = typeDefinitionInternal_AST;
1613                                    currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1614                                            typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1615                                    currentAST.advanceChildToEnd();
1616                            }
1617                            typeDefinitionInternal_AST = (AST)currentAST.root;
1618                            break;
1619                    }
1620                    default:
1621                    {
1622                            throw new NoViableAltException(LT(1), getFilename());
1623                    }
1624                    }
1625                    returnAST = typeDefinitionInternal_AST;
1626            }
1627            
1628            public final void classDefinition(
1629                    AST modifiers
1630            ) throws RecognitionException, TokenStreamException {
1631                    
1632                    returnAST = null;
1633                    ASTPair currentAST = new ASTPair();
1634                    AST classDefinition_AST = null;
1635                    AST tp_AST = null;
1636                    AST sc_AST = null;
1637                    AST ic_AST = null;
1638                    AST cb_AST = null;
1639                    Token first = LT(1);AST prevCurrentClass = currentClass;
1640                    
1641                    match(LITERAL_class);
1642                    AST tmp39_AST = null;
1643                    tmp39_AST = astFactory.create(LT(1));
1644                    match(IDENT);
1645                    nls();
1646                    if ( inputState.guessing==0 ) {
1647                            currentClass = tmp39_AST;
1648                    }
1649                    {
1650                    switch ( LA(1)) {
1651                    case LT:
1652                    {
1653                            typeParameters();
1654                            tp_AST = (AST)returnAST;
1655                            break;
1656                    }
1657                    case LITERAL_extends:
1658                    case LCURLY:
1659                    case LITERAL_implements:
1660                    {
1661                            break;
1662                    }
1663                    default:
1664                    {
1665                            throw new NoViableAltException(LT(1), getFilename());
1666                    }
1667                    }
1668                    }
1669                    superClassClause();
1670                    sc_AST = (AST)returnAST;
1671                    implementsClause();
1672                    ic_AST = (AST)returnAST;
1673                    classBlock();
1674                    cb_AST = (AST)returnAST;
1675                    if ( inputState.guessing==0 ) {
1676                            classDefinition_AST = (AST)currentAST.root;
1677                            classDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(create(CLASS_DEF,"CLASS_DEF",first,LT(1))).add(modifiers).add(tmp39_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
1678                            currentAST.root = classDefinition_AST;
1679                            currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
1680                                    classDefinition_AST.getFirstChild() : classDefinition_AST;
1681                            currentAST.advanceChildToEnd();
1682                    }
1683                    if ( inputState.guessing==0 ) {
1684                            currentClass = prevCurrentClass;
1685                    }
1686                    returnAST = classDefinition_AST;
1687            }
1688            
1689            public final void interfaceDefinition(
1690                    AST modifiers
1691            ) throws RecognitionException, TokenStreamException {
1692                    
1693                    returnAST = null;
1694                    ASTPair currentAST = new ASTPair();
1695                    AST interfaceDefinition_AST = null;
1696                    AST tp_AST = null;
1697                    AST ie_AST = null;
1698                    AST ib_AST = null;
1699                    Token first = LT(1);
1700                    
1701                    match(LITERAL_interface);
1702                    AST tmp41_AST = null;
1703                    tmp41_AST = astFactory.create(LT(1));
1704                    match(IDENT);
1705                    nls();
1706                    {
1707                    switch ( LA(1)) {
1708                    case LT:
1709                    {
1710                            typeParameters();
1711                            tp_AST = (AST)returnAST;
1712                            break;
1713                    }
1714                    case LITERAL_extends:
1715                    case LCURLY:
1716                    {
1717                            break;
1718                    }
1719                    default:
1720                    {
1721                            throw new NoViableAltException(LT(1), getFilename());
1722                    }
1723                    }
1724                    }
1725                    interfaceExtends();
1726                    ie_AST = (AST)returnAST;
1727                    interfaceBlock();
1728                    ib_AST = (AST)returnAST;
1729                    if ( inputState.guessing==0 ) {
1730                            interfaceDefinition_AST = (AST)currentAST.root;
1731                            interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(create(INTERFACE_DEF,"INTERFACE_DEF",first,LT(1))).add(modifiers).add(tmp41_AST).add(tp_AST).add(ie_AST).add(ib_AST));
1732                            currentAST.root = interfaceDefinition_AST;
1733                            currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
1734                                    interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
1735                            currentAST.advanceChildToEnd();
1736                    }
1737                    returnAST = interfaceDefinition_AST;
1738            }
1739            
1740            public final void enumDefinition(
1741                    AST modifiers
1742            ) throws RecognitionException, TokenStreamException {
1743                    
1744                    returnAST = null;
1745                    ASTPair currentAST = new ASTPair();
1746                    AST enumDefinition_AST = null;
1747                    AST ic_AST = null;
1748                    AST eb_AST = null;
1749                    Token first = LT(1);
1750                    
1751                    match(LITERAL_enum);
1752                    AST tmp43_AST = null;
1753                    tmp43_AST = astFactory.create(LT(1));
1754                    match(IDENT);
1755                    implementsClause();
1756                    ic_AST = (AST)returnAST;
1757                    enumBlock();
1758                    eb_AST = (AST)returnAST;
1759                    if ( inputState.guessing==0 ) {
1760                            enumDefinition_AST = (AST)currentAST.root;
1761                            enumDefinition_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(ENUM_DEF,"ENUM_DEF",first,LT(1))).add(modifiers).add(tmp43_AST).add(ic_AST).add(eb_AST));
1762                            currentAST.root = enumDefinition_AST;
1763                            currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
1764                                    enumDefinition_AST.getFirstChild() : enumDefinition_AST;
1765                            currentAST.advanceChildToEnd();
1766                    }
1767                    returnAST = enumDefinition_AST;
1768            }
1769            
1770            public final void annotationDefinition(
1771                    AST modifiers
1772            ) throws RecognitionException, TokenStreamException {
1773                    
1774                    returnAST = null;
1775                    ASTPair currentAST = new ASTPair();
1776                    AST annotationDefinition_AST = null;
1777                    AST ab_AST = null;
1778                    Token first = LT(1);
1779                    
1780                    AST tmp44_AST = null;
1781                    tmp44_AST = astFactory.create(LT(1));
1782                    match(AT);
1783                    match(LITERAL_interface);
1784                    AST tmp46_AST = null;
1785                    tmp46_AST = astFactory.create(LT(1));
1786                    match(IDENT);
1787                    annotationBlock();
1788                    ab_AST = (AST)returnAST;
1789                    if ( inputState.guessing==0 ) {
1790                            annotationDefinition_AST = (AST)currentAST.root;
1791                            annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(ANNOTATION_DEF,"ANNOTATION_DEF",first,LT(1))).add(modifiers).add(tmp46_AST).add(ab_AST));
1792                            currentAST.root = annotationDefinition_AST;
1793                            currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
1794                                    annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
1795                            currentAST.advanceChildToEnd();
1796                    }
1797                    returnAST = annotationDefinition_AST;
1798            }
1799            
1800    /** A declaration is the creation of a reference or primitive-type variable,
1801     *  or (if arguments are present) of a method.
1802     *  Generically, this is called a 'variable' definition, even in the case of a class field or method.
1803     *  It may start with the modifiers and/or a declaration keyword "def".
1804     *  It may also start with the modifiers and a capitalized type name.
1805     *  <p>
1806     *  AST effect: Create a separate Type/Var tree for each var in the var list.
1807     *  Must be guarded, as in (declarationStart) => declaration.
1808     */
1809            public final void declaration() throws RecognitionException, TokenStreamException {
1810                    
1811                    returnAST = null;
1812                    ASTPair currentAST = new ASTPair();
1813                    AST declaration_AST = null;
1814                    AST m_AST = null;
1815                    AST t_AST = null;
1816                    AST v_AST = null;
1817                    AST t2_AST = null;
1818                    AST v2_AST = null;
1819                    
1820                    switch ( LA(1)) {
1821                    case FINAL:
1822                    case ABSTRACT:
1823                    case STRICTFP:
1824                    case LITERAL_static:
1825                    case LITERAL_def:
1826                    case AT:
1827                    case LITERAL_private:
1828                    case LITERAL_public:
1829                    case LITERAL_protected:
1830                    case LITERAL_transient:
1831                    case LITERAL_native:
1832                    case LITERAL_threadsafe:
1833                    case LITERAL_synchronized:
1834                    case LITERAL_volatile:
1835                    {
1836                            modifiers();
1837                            m_AST = (AST)returnAST;
1838                            {
1839                            if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) {
1840                                    typeSpec(false);
1841                                    t_AST = (AST)returnAST;
1842                            }
1843                            else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (_tokenSet_28.member(LA(2)))) {
1844                            }
1845                            else {
1846                                    throw new NoViableAltException(LT(1), getFilename());
1847                            }
1848                            
1849                            }
1850                            variableDefinitions(m_AST, t_AST);
1851                            v_AST = (AST)returnAST;
1852                            if ( inputState.guessing==0 ) {
1853                                    declaration_AST = (AST)currentAST.root;
1854                                    declaration_AST = v_AST;
1855                                    currentAST.root = declaration_AST;
1856                                    currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
1857                                            declaration_AST.getFirstChild() : declaration_AST;
1858                                    currentAST.advanceChildToEnd();
1859                            }
1860                            break;
1861                    }
1862                    case IDENT:
1863                    case LITERAL_void:
1864                    case LITERAL_boolean:
1865                    case LITERAL_byte:
1866                    case LITERAL_char:
1867                    case LITERAL_short:
1868                    case LITERAL_int:
1869                    case LITERAL_float:
1870                    case LITERAL_long:
1871                    case LITERAL_double:
1872                    case LITERAL_any:
1873                    {
1874                            typeSpec(false);
1875                            t2_AST = (AST)returnAST;
1876                            variableDefinitions(null,t2_AST);
1877                            v2_AST = (AST)returnAST;
1878                            if ( inputState.guessing==0 ) {
1879                                    declaration_AST = (AST)currentAST.root;
1880                                    declaration_AST = v2_AST;
1881                                    currentAST.root = declaration_AST;
1882                                    currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
1883                                            declaration_AST.getFirstChild() : declaration_AST;
1884                                    currentAST.advanceChildToEnd();
1885                            }
1886                            break;
1887                    }
1888                    default:
1889                    {
1890                            throw new NoViableAltException(LT(1), getFilename());
1891                    }
1892                    }
1893                    returnAST = declaration_AST;
1894            }
1895            
1896    /** A list of one or more modifier, annotation, or "def". */
1897            public final void modifiers() throws RecognitionException, TokenStreamException {
1898                    
1899                    returnAST = null;
1900                    ASTPair currentAST = new ASTPair();
1901                    AST modifiers_AST = null;
1902                    Token first = LT(1);
1903                    
1904                    modifiersInternal();
1905                    astFactory.addASTChild(currentAST, returnAST);
1906                    if ( inputState.guessing==0 ) {
1907                            modifiers_AST = (AST)currentAST.root;
1908                            modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(modifiers_AST));
1909                            currentAST.root = modifiers_AST;
1910                            currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
1911                                    modifiers_AST.getFirstChild() : modifiers_AST;
1912                            currentAST.advanceChildToEnd();
1913                    }
1914                    modifiers_AST = (AST)currentAST.root;
1915                    returnAST = modifiers_AST;
1916            }
1917            
1918            public final void typeSpec(
1919                    boolean addImagNode
1920            ) throws RecognitionException, TokenStreamException {
1921                    
1922                    returnAST = null;
1923                    ASTPair currentAST = new ASTPair();
1924                    AST typeSpec_AST = null;
1925                    
1926                    switch ( LA(1)) {
1927                    case IDENT:
1928                    {
1929                            classTypeSpec(addImagNode);
1930                            astFactory.addASTChild(currentAST, returnAST);
1931                            typeSpec_AST = (AST)currentAST.root;
1932                            break;
1933                    }
1934                    case LITERAL_void:
1935                    case LITERAL_boolean:
1936                    case LITERAL_byte:
1937                    case LITERAL_char:
1938                    case LITERAL_short:
1939                    case LITERAL_int:
1940                    case LITERAL_float:
1941                    case LITERAL_long:
1942                    case LITERAL_double:
1943                    case LITERAL_any:
1944                    {
1945                            builtInTypeSpec(addImagNode);
1946                            astFactory.addASTChild(currentAST, returnAST);
1947                            typeSpec_AST = (AST)currentAST.root;
1948                            break;
1949                    }
1950                    default:
1951                    {
1952                            throw new NoViableAltException(LT(1), getFilename());
1953                    }
1954                    }
1955                    returnAST = typeSpec_AST;
1956            }
1957            
1958    /** The tail of a declaration.
1959      * Either v1, v2, ... (with possible initializers) or else m(args){body}.
1960      * The two arguments are the modifier list (if any) and the declaration head (if any).
1961      * The declaration head is the variable type, or (for a method) the return type.
1962      * If it is missing, then the variable type is taken from its initializer (if there is one).
1963      * Otherwise, the variable type defaults to 'any'.
1964      * DECIDE:  Method return types default to the type of the method body, as an expression.
1965      */
1966            public final void variableDefinitions(
1967                    AST mods, AST t
1968            ) throws RecognitionException, TokenStreamException {
1969                    
1970                    returnAST = null;
1971                    ASTPair currentAST = new ASTPair();
1972                    AST variableDefinitions_AST = null;
1973                    Token  id = null;
1974                    AST id_AST = null;
1975                    Token  qid = null;
1976                    AST qid_AST = null;
1977                    AST param_AST = null;
1978                    AST tc_AST = null;
1979                    AST mb_AST = null;
1980                    Token first = LT(1);
1981                    
1982                    if ((LA(1)==IDENT) && (_tokenSet_29.member(LA(2)))) {
1983                            variableDeclarator(getASTFactory().dupTree(mods),
1984                               getASTFactory().dupTree(t));
1985                            astFactory.addASTChild(currentAST, returnAST);
1986                            {
1987                            _loop190:
1988                            do {
1989                                    if ((LA(1)==COMMA)) {
1990                                            match(COMMA);
1991                                            nls();
1992                                            variableDeclarator(getASTFactory().dupTree(mods),
1993                                   getASTFactory().dupTree(t));
1994                                            astFactory.addASTChild(currentAST, returnAST);
1995                                    }
1996                                    else {
1997                                            break _loop190;
1998                                    }
1999                                    
2000                            } while (true);
2001                            }
2002                            variableDefinitions_AST = (AST)currentAST.root;
2003                    }
2004                    else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (LA(2)==LPAREN)) {
2005                            {
2006                            switch ( LA(1)) {
2007                            case IDENT:
2008                            {
2009                                    id = LT(1);
2010                                    id_AST = astFactory.create(id);
2011                                    astFactory.addASTChild(currentAST, id_AST);
2012                                    match(IDENT);
2013                                    break;
2014                            }
2015                            case STRING_LITERAL:
2016                            {
2017                                    qid = LT(1);
2018                                    qid_AST = astFactory.create(qid);
2019                                    astFactory.addASTChild(currentAST, qid_AST);
2020                                    match(STRING_LITERAL);
2021                                    if ( inputState.guessing==0 ) {
2022                                            qid_AST.setType(IDENT);
2023                                    }
2024                                    break;
2025                            }
2026                            default:
2027                            {
2028                                    throw new NoViableAltException(LT(1), getFilename());
2029                            }
2030                            }
2031                            }
2032                            match(LPAREN);
2033                            parameterDeclarationList();
2034                            param_AST = (AST)returnAST;
2035                            match(RPAREN);
2036                            {
2037                            boolean synPredMatched194 = false;
2038                            if (((LA(1)==NLS||LA(1)==LITERAL_throws) && (_tokenSet_30.member(LA(2))) && (_tokenSet_31.member(LA(3))))) {
2039                                    int _m194 = mark();
2040                                    synPredMatched194 = true;
2041                                    inputState.guessing++;
2042                                    try {
2043                                            {
2044                                            nls();
2045                                            match(LITERAL_throws);
2046                                            }
2047                                    }
2048                                    catch (RecognitionException pe) {
2049                                            synPredMatched194 = false;
2050                                    }
2051                                    rewind(_m194);
2052    inputState.guessing--;
2053                            }
2054                            if ( synPredMatched194 ) {
2055                                    throwsClause();
2056                                    tc_AST = (AST)returnAST;
2057                            }
2058                            else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_10.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
2059                            }
2060                            else {
2061                                    throw new NoViableAltException(LT(1), getFilename());
2062                            }
2063                            
2064                            }
2065                            {
2066                            boolean synPredMatched197 = false;
2067                            if (((LA(1)==LCURLY||LA(1)==NLS) && (_tokenSet_33.member(LA(2))) && (_tokenSet_8.member(LA(3))))) {
2068                                    int _m197 = mark();
2069                                    synPredMatched197 = true;
2070                                    inputState.guessing++;
2071                                    try {
2072                                            {
2073                                            nls();
2074                                            match(LCURLY);
2075                                            }
2076                                    }
2077                                    catch (RecognitionException pe) {
2078                                            synPredMatched197 = false;
2079                                    }
2080                                    rewind(_m197);
2081    inputState.guessing--;
2082                            }
2083                            if ( synPredMatched197 ) {
2084                                    {
2085                                    nlsWarn();
2086                                    openBlock();
2087                                    mb_AST = (AST)returnAST;
2088                                    }
2089                            }
2090                            else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
2091                            }
2092                            else {
2093                                    throw new NoViableAltException(LT(1), getFilename());
2094                            }
2095                            
2096                            }
2097                            if ( inputState.guessing==0 ) {
2098                                    variableDefinitions_AST = (AST)currentAST.root;
2099                                    if (qid_AST != null)  id_AST = qid_AST;
2100                                    variableDefinitions_AST =
2101                                    (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));
2102                                    
2103                                    currentAST.root = variableDefinitions_AST;
2104                                    currentAST.child = variableDefinitions_AST!=null &&variableDefinitions_AST.getFirstChild()!=null ?
2105                                            variableDefinitions_AST.getFirstChild() : variableDefinitions_AST;
2106                                    currentAST.advanceChildToEnd();
2107                            }
2108                            variableDefinitions_AST = (AST)currentAST.root;
2109                    }
2110                    else {
2111                            throw new NoViableAltException(LT(1), getFilename());
2112                    }
2113                    
2114                    returnAST = variableDefinitions_AST;
2115            }
2116            
2117    /** A declaration with one declarator and no initialization, like a parameterDeclaration.
2118     *  Used to parse loops like <code>for (int x in y)</code> (up to the <code>in</code> keyword).
2119     */
2120            public final void singleDeclarationNoInit() throws RecognitionException, TokenStreamException {
2121                    
2122                    returnAST = null;
2123                    ASTPair currentAST = new ASTPair();
2124                    AST singleDeclarationNoInit_AST = null;
2125                    AST m_AST = null;
2126                    AST t_AST = null;
2127                    AST v_AST = null;
2128                    AST t2_AST = null;
2129                    AST v2_AST = null;
2130                    
2131                    switch ( LA(1)) {
2132                    case FINAL:
2133                    case ABSTRACT:
2134                    case STRICTFP:
2135                    case LITERAL_static:
2136                    case LITERAL_def:
2137                    case AT:
2138                    case LITERAL_private:
2139                    case LITERAL_public:
2140                    case LITERAL_protected:
2141                    case LITERAL_transient:
2142                    case LITERAL_native:
2143                    case LITERAL_threadsafe:
2144                    case LITERAL_synchronized:
2145                    case LITERAL_volatile:
2146                    {
2147                            modifiers();
2148                            m_AST = (AST)returnAST;
2149                            {
2150                            if ((_tokenSet_26.member(LA(1))) && (_tokenSet_34.member(LA(2)))) {
2151                                    typeSpec(false);
2152                                    t_AST = (AST)returnAST;
2153                            }
2154                            else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
2155                            }
2156                            else {
2157                                    throw new NoViableAltException(LT(1), getFilename());
2158                            }
2159                            
2160                            }
2161                            singleVariable(m_AST, t_AST);
2162                            v_AST = (AST)returnAST;
2163                            if ( inputState.guessing==0 ) {
2164                                    singleDeclarationNoInit_AST = (AST)currentAST.root;
2165                                    singleDeclarationNoInit_AST = v_AST;
2166                                    currentAST.root = singleDeclarationNoInit_AST;
2167                                    currentAST.child = singleDeclarationNoInit_AST!=null &&singleDeclarationNoInit_AST.getFirstChild()!=null ?
2168                                            singleDeclarationNoInit_AST.getFirstChild() : singleDeclarationNoInit_AST;
2169                                    currentAST.advanceChildToEnd();
2170                            }
2171                            break;
2172                    }
2173                    case IDENT:
2174                    case LITERAL_void:
2175                    case LITERAL_boolean:
2176                    case LITERAL_byte:
2177                    case LITERAL_char:
2178                    case LITERAL_short:
2179                    case LITERAL_int:
2180                    case LITERAL_float:
2181                    case LITERAL_long:
2182                    case LITERAL_double:
2183                    case LITERAL_any:
2184                    {
2185                            typeSpec(false);
2186                            t2_AST = (AST)returnAST;
2187                            singleVariable(null,t2_AST);
2188                            v2_AST = (AST)returnAST;
2189                            if ( inputState.guessing==0 ) {
2190                                    singleDeclarationNoInit_AST = (AST)currentAST.root;
2191                                    singleDeclarationNoInit_AST = v2_AST;
2192                                    currentAST.root = singleDeclarationNoInit_AST;
2193                                    currentAST.child = singleDeclarationNoInit_AST!=null &&singleDeclarationNoInit_AST.getFirstChild()!=null ?
2194                                            singleDeclarationNoInit_AST.getFirstChild() : singleDeclarationNoInit_AST;
2195                                    currentAST.advanceChildToEnd();
2196                            }
2197                            break;
2198                    }
2199                    default:
2200                    {
2201                            throw new NoViableAltException(LT(1), getFilename());
2202                    }
2203                    }
2204                    returnAST = singleDeclarationNoInit_AST;
2205            }
2206            
2207    /** Used in cases where a declaration cannot have commas, or ends with the "in" operator instead of '='. */
2208            public final void singleVariable(
2209                    AST mods, AST t
2210            ) throws RecognitionException, TokenStreamException {
2211                    
2212                    returnAST = null;
2213                    ASTPair currentAST = new ASTPair();
2214                    AST singleVariable_AST = null;
2215                    AST id_AST = null;
2216                    Token first = LT(1);
2217                    
2218                    variableName();
2219                    id_AST = (AST)returnAST;
2220                    if ( inputState.guessing==0 ) {
2221                            singleVariable_AST = (AST)currentAST.root;
2222                            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));
2223                            currentAST.root = singleVariable_AST;
2224                            currentAST.child = singleVariable_AST!=null &&singleVariable_AST.getFirstChild()!=null ?
2225                                    singleVariable_AST.getFirstChild() : singleVariable_AST;
2226                            currentAST.advanceChildToEnd();
2227                    }
2228                    returnAST = singleVariable_AST;
2229            }
2230            
2231    /** A declaration with one declarator and optional initialization, like a parameterDeclaration.
2232     *  Used to parse declarations used for both binding and effect, in places like argument
2233     *  lists and <code>while</code> statements.
2234     */
2235            public final void singleDeclaration() throws RecognitionException, TokenStreamException {
2236                    
2237                    returnAST = null;
2238                    ASTPair currentAST = new ASTPair();
2239                    AST singleDeclaration_AST = null;
2240                    AST sd_AST = null;
2241                    
2242                    singleDeclarationNoInit();
2243                    sd_AST = (AST)returnAST;
2244                    if ( inputState.guessing==0 ) {
2245                            singleDeclaration_AST = (AST)currentAST.root;
2246                            singleDeclaration_AST = sd_AST;
2247                            currentAST.root = singleDeclaration_AST;
2248                            currentAST.child = singleDeclaration_AST!=null &&singleDeclaration_AST.getFirstChild()!=null ?
2249                                    singleDeclaration_AST.getFirstChild() : singleDeclaration_AST;
2250                            currentAST.advanceChildToEnd();
2251                    }
2252                    {
2253                    switch ( LA(1)) {
2254                    case ASSIGN:
2255                    {
2256                            varInitializer();
2257                            astFactory.addASTChild(currentAST, returnAST);
2258                            break;
2259                    }
2260                    case RBRACK:
2261                    case COMMA:
2262                    case RPAREN:
2263                    case SEMI:
2264                    {
2265                            break;
2266                    }
2267                    default:
2268                    {
2269                            throw new NoViableAltException(LT(1), getFilename());
2270                    }
2271                    }
2272                    }
2273                    singleDeclaration_AST = (AST)currentAST.root;
2274                    returnAST = singleDeclaration_AST;
2275            }
2276            
2277    /** An assignment operator '=' followed by an expression.  (Never empty.) */
2278            public final void varInitializer() throws RecognitionException, TokenStreamException {
2279                    
2280                    returnAST = null;
2281                    ASTPair currentAST = new ASTPair();
2282                    AST varInitializer_AST = null;
2283                    
2284                    AST tmp50_AST = null;
2285                    tmp50_AST = astFactory.create(LT(1));
2286                    astFactory.makeASTRoot(currentAST, tmp50_AST);
2287                    match(ASSIGN);
2288                    nls();
2289                    expression(LC_INIT);
2290                    astFactory.addASTChild(currentAST, returnAST);
2291                    varInitializer_AST = (AST)currentAST.root;
2292                    returnAST = varInitializer_AST;
2293            }
2294            
2295    /** Used only as a lookahead predicate, before diving in and parsing a declaration.
2296     *  A declaration can be unambiguously introduced with "def", an annotation or a modifier token like "final".
2297     *  It may also be introduced by a simple identifier whose first character is an uppercase letter,
2298     *  as in {String x}.  A declaration can also be introduced with a built in type like 'int' or 'void'.
2299     *  Brackets (array and generic) are allowed, as in {List[] x} or {int[][] y}.
2300     *  Anything else is parsed as a statement of some sort (expression or command).
2301     *  <p>
2302     *  (In the absence of explicit method-call parens, we assume a capitalized name is a type name.
2303     *  Yes, this is a little hacky.  Alternatives are to complicate the declaration or command
2304     *  syntaxes, or to have the parser query the symbol table.  Parse-time queries are evil.
2305     *  And we want both {String x} and {println x}.  So we need a syntactic razor-edge to slip
2306     *  between 'println' and 'String'.)
2307     *  
2308     *   *TODO* The declarationStart production needs to be strengthened to recognize
2309     *  things like {List<String> foo}.
2310     *  Right now it only knows how to skip square brackets after the type, not
2311     *  angle brackets.
2312     *  This probably turns out to be tricky because of >> vs. > >. If so,
2313     *  just put a TODO comment in.
2314     */
2315            public final void declarationStart() throws RecognitionException, TokenStreamException {
2316                    
2317                    returnAST = null;
2318                    ASTPair currentAST = new ASTPair();
2319                    AST declarationStart_AST = null;
2320                    
2321                    switch ( LA(1)) {
2322                    case LITERAL_def:
2323                    {
2324                            match(LITERAL_def);
2325                            break;
2326                    }
2327                    case FINAL:
2328                    case ABSTRACT:
2329                    case STRICTFP:
2330                    case LITERAL_static:
2331                    case LITERAL_private:
2332                    case LITERAL_public:
2333                    case LITERAL_protected:
2334                    case LITERAL_transient:
2335                    case LITERAL_native:
2336                    case LITERAL_threadsafe:
2337                    case LITERAL_synchronized:
2338                    case LITERAL_volatile:
2339                    {
2340                            modifier();
2341                            break;
2342                    }
2343                    case AT:
2344                    {
2345                            AST tmp52_AST = null;
2346                            tmp52_AST = astFactory.create(LT(1));
2347                            match(AT);
2348                            AST tmp53_AST = null;
2349                            tmp53_AST = astFactory.create(LT(1));
2350                            match(IDENT);
2351                            break;
2352                    }
2353                    case IDENT:
2354                    case LITERAL_void:
2355                    case LITERAL_boolean:
2356                    case LITERAL_byte:
2357                    case LITERAL_char:
2358                    case LITERAL_short:
2359                    case LITERAL_int:
2360                    case LITERAL_float:
2361                    case LITERAL_long:
2362                    case LITERAL_double:
2363                    case LITERAL_any:
2364                    {
2365                            {
2366                            if ((LA(1)==IDENT) && (LA(2)==IDENT||LA(2)==LBRACK)) {
2367                                    upperCaseIdent();
2368                            }
2369                            else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_any))) {
2370                                    builtInType();
2371                            }
2372                            else if ((LA(1)==IDENT) && (LA(2)==DOT)) {
2373                                    qualifiedTypeName();
2374                            }
2375                            else {
2376                                    throw new NoViableAltException(LT(1), getFilename());
2377                            }
2378                            
2379                            }
2380                            {
2381                            _loop24:
2382                            do {
2383                                    if ((LA(1)==LBRACK)) {
2384                                            AST tmp54_AST = null;
2385                                            tmp54_AST = astFactory.create(LT(1));
2386                                            match(LBRACK);
2387                                            balancedTokens();
2388                                            AST tmp55_AST = null;
2389                                            tmp55_AST = astFactory.create(LT(1));
2390                                            match(RBRACK);
2391                                    }
2392                                    else {
2393                                            break _loop24;
2394                                    }
2395                                    
2396                            } while (true);
2397                            }
2398                            AST tmp56_AST = null;
2399                            tmp56_AST = astFactory.create(LT(1));
2400                            match(IDENT);
2401                            break;
2402                    }
2403                    default:
2404                    {
2405                            throw new NoViableAltException(LT(1), getFilename());
2406                    }
2407                    }
2408                    returnAST = declarationStart_AST;
2409            }
2410            
2411            public final void modifier() throws RecognitionException, TokenStreamException {
2412                    
2413                    returnAST = null;
2414                    ASTPair currentAST = new ASTPair();
2415                    AST modifier_AST = null;
2416                    
2417                    switch ( LA(1)) {
2418                    case LITERAL_private:
2419                    {
2420                            AST tmp57_AST = null;
2421                            tmp57_AST = astFactory.create(LT(1));
2422                            astFactory.addASTChild(currentAST, tmp57_AST);
2423                            match(LITERAL_private);
2424                            modifier_AST = (AST)currentAST.root;
2425                            break;
2426                    }
2427                    case LITERAL_public:
2428                    {
2429                            AST tmp58_AST = null;
2430                            tmp58_AST = astFactory.create(LT(1));
2431                            astFactory.addASTChild(currentAST, tmp58_AST);
2432                            match(LITERAL_public);
2433                            modifier_AST = (AST)currentAST.root;
2434                            break;
2435                    }
2436                    case LITERAL_protected:
2437                    {
2438                            AST tmp59_AST = null;
2439                            tmp59_AST = astFactory.create(LT(1));
2440                            astFactory.addASTChild(currentAST, tmp59_AST);
2441                            match(LITERAL_protected);
2442                            modifier_AST = (AST)currentAST.root;
2443                            break;
2444                    }
2445                    case LITERAL_static:
2446                    {
2447                            AST tmp60_AST = null;
2448                            tmp60_AST = astFactory.create(LT(1));
2449                            astFactory.addASTChild(currentAST, tmp60_AST);
2450                            match(LITERAL_static);
2451                            modifier_AST = (AST)currentAST.root;
2452                            break;
2453                    }
2454                    case LITERAL_transient:
2455                    {
2456                            AST tmp61_AST = null;
2457                            tmp61_AST = astFactory.create(LT(1));
2458                            astFactory.addASTChild(currentAST, tmp61_AST);
2459                            match(LITERAL_transient);
2460                            modifier_AST = (AST)currentAST.root;
2461                            break;
2462                    }
2463                    case FINAL:
2464                    {
2465                            AST tmp62_AST = null;
2466                            tmp62_AST = astFactory.create(LT(1));
2467                            astFactory.addASTChild(currentAST, tmp62_AST);
2468                            match(FINAL);
2469                            modifier_AST = (AST)currentAST.root;
2470                            break;
2471                    }
2472                    case ABSTRACT:
2473                    {
2474                            AST tmp63_AST = null;
2475                            tmp63_AST = astFactory.create(LT(1));
2476                            astFactory.addASTChild(currentAST, tmp63_AST);
2477                            match(ABSTRACT);
2478                            modifier_AST = (AST)currentAST.root;
2479                            break;
2480                    }
2481                    case LITERAL_native:
2482                    {
2483                            AST tmp64_AST = null;
2484                            tmp64_AST = astFactory.create(LT(1));
2485                            astFactory.addASTChild(currentAST, tmp64_AST);
2486                            match(LITERAL_native);
2487                            modifier_AST = (AST)currentAST.root;
2488                            break;
2489                    }
2490                    case LITERAL_threadsafe:
2491                    {
2492                            AST tmp65_AST = null;
2493                            tmp65_AST = astFactory.create(LT(1));
2494                            astFactory.addASTChild(currentAST, tmp65_AST);
2495                            match(LITERAL_threadsafe);
2496                            modifier_AST = (AST)currentAST.root;
2497                            break;
2498                    }
2499                    case LITERAL_synchronized:
2500                    {
2501                            AST tmp66_AST = null;
2502                            tmp66_AST = astFactory.create(LT(1));
2503                            astFactory.addASTChild(currentAST, tmp66_AST);
2504                            match(LITERAL_synchronized);
2505                            modifier_AST = (AST)currentAST.root;
2506                            break;
2507                    }
2508                    case LITERAL_volatile:
2509                    {
2510                            AST tmp67_AST = null;
2511                            tmp67_AST = astFactory.create(LT(1));
2512                            astFactory.addASTChild(currentAST, tmp67_AST);
2513                            match(LITERAL_volatile);
2514                            modifier_AST = (AST)currentAST.root;
2515                            break;
2516                    }
2517                    case STRICTFP:
2518                    {
2519                            AST tmp68_AST = null;
2520                            tmp68_AST = astFactory.create(LT(1));
2521                            astFactory.addASTChild(currentAST, tmp68_AST);
2522                            match(STRICTFP);
2523                            modifier_AST = (AST)currentAST.root;
2524                            break;
2525                    }
2526                    default:
2527                    {
2528                            throw new NoViableAltException(LT(1), getFilename());
2529                    }
2530                    }
2531                    returnAST = modifier_AST;
2532            }
2533            
2534    /** An IDENT token whose spelling is required to start with an uppercase letter.
2535     *  In the case of a simple statement {UpperID name} the identifier is taken to be a type name, not a command name.
2536     */
2537            public final void upperCaseIdent() throws RecognitionException, TokenStreamException {
2538                    
2539                    returnAST = null;
2540                    ASTPair currentAST = new ASTPair();
2541                    AST upperCaseIdent_AST = null;
2542                    
2543                    if (!(isUpperCase(LT(1))))
2544                      throw new SemanticException("isUpperCase(LT(1))");
2545                    AST tmp69_AST = null;
2546                    tmp69_AST = astFactory.create(LT(1));
2547                    astFactory.addASTChild(currentAST, tmp69_AST);
2548                    match(IDENT);
2549                    upperCaseIdent_AST = (AST)currentAST.root;
2550                    returnAST = upperCaseIdent_AST;
2551            }
2552            
2553            public final void builtInType() throws RecognitionException, TokenStreamException {
2554                    
2555                    returnAST = null;
2556                    ASTPair currentAST = new ASTPair();
2557                    AST builtInType_AST = null;
2558                    
2559                    switch ( LA(1)) {
2560                    case LITERAL_void:
2561                    {
2562                            AST tmp70_AST = null;
2563                            tmp70_AST = astFactory.create(LT(1));
2564                            astFactory.addASTChild(currentAST, tmp70_AST);
2565                            match(LITERAL_void);
2566                            builtInType_AST = (AST)currentAST.root;
2567                            break;
2568                    }
2569                    case LITERAL_boolean:
2570                    {
2571                            AST tmp71_AST = null;
2572                            tmp71_AST = astFactory.create(LT(1));
2573                            astFactory.addASTChild(currentAST, tmp71_AST);
2574                            match(LITERAL_boolean);
2575                            builtInType_AST = (AST)currentAST.root;
2576                            break;
2577                    }
2578                    case LITERAL_byte:
2579                    {
2580                            AST tmp72_AST = null;
2581                            tmp72_AST = astFactory.create(LT(1));
2582                            astFactory.addASTChild(currentAST, tmp72_AST);
2583                            match(LITERAL_byte);
2584                            builtInType_AST = (AST)currentAST.root;
2585                            break;
2586                    }
2587                    case LITERAL_char:
2588                    {
2589                            AST tmp73_AST = null;
2590                            tmp73_AST = astFactory.create(LT(1));
2591                            astFactory.addASTChild(currentAST, tmp73_AST);
2592                            match(LITERAL_char);
2593                            builtInType_AST = (AST)currentAST.root;
2594                            break;
2595                    }
2596                    case LITERAL_short:
2597                    {
2598                            AST tmp74_AST = null;
2599                            tmp74_AST = astFactory.create(LT(1));
2600                            astFactory.addASTChild(currentAST, tmp74_AST);
2601                            match(LITERAL_short);
2602                            builtInType_AST = (AST)currentAST.root;
2603                            break;
2604                    }
2605                    case LITERAL_int:
2606                    {
2607                            AST tmp75_AST = null;
2608                            tmp75_AST = astFactory.create(LT(1));
2609                            astFactory.addASTChild(currentAST, tmp75_AST);
2610                            match(LITERAL_int);
2611                            builtInType_AST = (AST)currentAST.root;
2612                            break;
2613                    }
2614                    case LITERAL_float:
2615                    {
2616                            AST tmp76_AST = null;
2617                            tmp76_AST = astFactory.create(LT(1));
2618                            astFactory.addASTChild(currentAST, tmp76_AST);
2619                            match(LITERAL_float);
2620                            builtInType_AST = (AST)currentAST.root;
2621                            break;
2622                    }
2623                    case LITERAL_long:
2624                    {
2625                            AST tmp77_AST = null;
2626                            tmp77_AST = astFactory.create(LT(1));
2627                            astFactory.addASTChild(currentAST, tmp77_AST);
2628                            match(LITERAL_long);
2629                            builtInType_AST = (AST)currentAST.root;
2630                            break;
2631                    }
2632                    case LITERAL_double:
2633                    {
2634                            AST tmp78_AST = null;
2635                            tmp78_AST = astFactory.create(LT(1));
2636                            astFactory.addASTChild(currentAST, tmp78_AST);
2637                            match(LITERAL_double);
2638                            builtInType_AST = (AST)currentAST.root;
2639                            break;
2640                    }
2641                    case LITERAL_any:
2642                    {
2643                            AST tmp79_AST = null;
2644                            tmp79_AST = astFactory.create(LT(1));
2645                            astFactory.addASTChild(currentAST, tmp79_AST);
2646                            match(LITERAL_any);
2647                            builtInType_AST = (AST)currentAST.root;
2648                            break;
2649                    }
2650                    default:
2651                    {
2652                            throw new NoViableAltException(LT(1), getFilename());
2653                    }
2654                    }
2655                    returnAST = builtInType_AST;
2656            }
2657            
2658    /** Not yet used - but we could use something like this to look for fully qualified type names 
2659     */
2660            public final void qualifiedTypeName() throws RecognitionException, TokenStreamException {
2661                    
2662                    returnAST = null;
2663                    ASTPair currentAST = new ASTPair();
2664                    AST qualifiedTypeName_AST = null;
2665                    
2666                    AST tmp80_AST = null;
2667                    tmp80_AST = astFactory.create(LT(1));
2668                    match(IDENT);
2669                    {
2670                    _loop27:
2671                    do {
2672                            if ((LA(1)==DOT) && (LA(2)==IDENT) && (LA(3)==DOT)) {
2673                                    AST tmp81_AST = null;
2674                                    tmp81_AST = astFactory.create(LT(1));
2675                                    match(DOT);
2676                                    AST tmp82_AST = null;
2677                                    tmp82_AST = astFactory.create(LT(1));
2678                                    match(IDENT);
2679                            }
2680                            else {
2681                                    break _loop27;
2682                            }
2683                            
2684                    } while (true);
2685                    }
2686                    AST tmp83_AST = null;
2687                    tmp83_AST = astFactory.create(LT(1));
2688                    match(DOT);
2689                    upperCaseIdent();
2690                    returnAST = qualifiedTypeName_AST;
2691            }
2692            
2693            public final void balancedTokens() throws RecognitionException, TokenStreamException {
2694                    
2695                    returnAST = null;
2696                    ASTPair currentAST = new ASTPair();
2697                    AST balancedTokens_AST = null;
2698                    
2699                    {
2700                    _loop472:
2701                    do {
2702                            if ((_tokenSet_36.member(LA(1)))) {
2703                                    balancedBrackets();
2704                            }
2705                            else if ((_tokenSet_37.member(LA(1)))) {
2706                                    {
2707                                    match(_tokenSet_37);
2708                                    }
2709                            }
2710                            else {
2711                                    break _loop472;
2712                            }
2713                            
2714                    } while (true);
2715                    }
2716                    returnAST = balancedTokens_AST;
2717            }
2718            
2719    /** Used to look ahead for a constructor 
2720     */
2721            public final void constructorStart() throws RecognitionException, TokenStreamException {
2722                    
2723                    returnAST = null;
2724                    ASTPair currentAST = new ASTPair();
2725                    AST constructorStart_AST = null;
2726                    Token  id = null;
2727                    AST id_AST = null;
2728                    
2729                    modifiersOpt();
2730                    id = LT(1);
2731                    id_AST = astFactory.create(id);
2732                    match(IDENT);
2733                    if (!(isConstructorIdent(id)))
2734                      throw new SemanticException("isConstructorIdent(id)");
2735                    nls();
2736                    match(LPAREN);
2737                    returnAST = constructorStart_AST;
2738            }
2739            
2740    /** A list of zero or more modifiers, annotations, or "def". */
2741            public final void modifiersOpt() throws RecognitionException, TokenStreamException {
2742                    
2743                    returnAST = null;
2744                    ASTPair currentAST = new ASTPair();
2745                    AST modifiersOpt_AST = null;
2746                    Token first = LT(1);
2747                    
2748                    {
2749                    if ((_tokenSet_38.member(LA(1))) && (_tokenSet_39.member(LA(2))) && (_tokenSet_40.member(LA(3)))) {
2750                            modifiersInternal();
2751                            astFactory.addASTChild(currentAST, returnAST);
2752                    }
2753                    else if ((_tokenSet_41.member(LA(1))) && (_tokenSet_42.member(LA(2))) && (_tokenSet_43.member(LA(3)))) {
2754                    }
2755                    else {
2756                            throw new NoViableAltException(LT(1), getFilename());
2757                    }
2758                    
2759                    }
2760                    if ( inputState.guessing==0 ) {
2761                            modifiersOpt_AST = (AST)currentAST.root;
2762                            modifiersOpt_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(modifiersOpt_AST));
2763                            currentAST.root = modifiersOpt_AST;
2764                            currentAST.child = modifiersOpt_AST!=null &&modifiersOpt_AST.getFirstChild()!=null ?
2765                                    modifiersOpt_AST.getFirstChild() : modifiersOpt_AST;
2766                            currentAST.advanceChildToEnd();
2767                    }
2768                    modifiersOpt_AST = (AST)currentAST.root;
2769                    returnAST = modifiersOpt_AST;
2770            }
2771            
2772    /** Used only as a lookahead predicate for nested type declarations. */
2773            public final void typeDeclarationStart() throws RecognitionException, TokenStreamException {
2774                    
2775                    returnAST = null;
2776                    ASTPair currentAST = new ASTPair();
2777                    AST typeDeclarationStart_AST = null;
2778                    
2779                    modifiersOpt();
2780                    {
2781                    switch ( LA(1)) {
2782                    case LITERAL_class:
2783                    {
2784                            match(LITERAL_class);
2785                            break;
2786                    }
2787                    case LITERAL_interface:
2788                    {
2789                            match(LITERAL_interface);
2790                            break;
2791                    }
2792                    case LITERAL_enum:
2793                    {
2794                            match(LITERAL_enum);
2795                            break;
2796                    }
2797                    case AT:
2798                    {
2799                            AST tmp89_AST = null;
2800                            tmp89_AST = astFactory.create(LT(1));
2801                            match(AT);
2802                            match(LITERAL_interface);
2803                            break;
2804                    }
2805                    default:
2806                    {
2807                            throw new NoViableAltException(LT(1), getFilename());
2808                    }
2809                    }
2810                    }
2811                    returnAST = typeDeclarationStart_AST;
2812            }
2813            
2814            public final void classTypeSpec(
2815                    boolean addImagNode
2816            ) throws RecognitionException, TokenStreamException {
2817                    
2818                    returnAST = null;
2819                    ASTPair currentAST = new ASTPair();
2820                    AST classTypeSpec_AST = null;
2821                    AST ct_AST = null;
2822                    Token first = LT(1);
2823                    
2824                    classOrInterfaceType(false);
2825                    ct_AST = (AST)returnAST;
2826                    declaratorBrackets(ct_AST);
2827                    astFactory.addASTChild(currentAST, returnAST);
2828                    if ( inputState.guessing==0 ) {
2829                            classTypeSpec_AST = (AST)currentAST.root;
2830                            
2831                            if ( addImagNode ) {
2832                            classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(classTypeSpec_AST));
2833                            }
2834                            
2835                            currentAST.root = classTypeSpec_AST;
2836                            currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
2837                                    classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
2838                            currentAST.advanceChildToEnd();
2839                    }
2840                    classTypeSpec_AST = (AST)currentAST.root;
2841                    returnAST = classTypeSpec_AST;
2842            }
2843            
2844            public final void builtInTypeSpec(
2845                    boolean addImagNode
2846            ) throws RecognitionException, TokenStreamException {
2847                    
2848                    returnAST = null;
2849                    ASTPair currentAST = new ASTPair();
2850                    AST builtInTypeSpec_AST = null;
2851                    AST bt_AST = null;
2852                    Token first = LT(1);
2853                    
2854                    builtInType();
2855                    bt_AST = (AST)returnAST;
2856                    declaratorBrackets(bt_AST);
2857                    astFactory.addASTChild(currentAST, returnAST);
2858                    if ( inputState.guessing==0 ) {
2859                            builtInTypeSpec_AST = (AST)currentAST.root;
2860                            
2861                            if ( addImagNode ) {
2862                            builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(builtInTypeSpec_AST));
2863                            }
2864                            
2865                            currentAST.root = builtInTypeSpec_AST;
2866                            currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
2867                                    builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
2868                            currentAST.advanceChildToEnd();
2869                    }
2870                    builtInTypeSpec_AST = (AST)currentAST.root;
2871                    returnAST = builtInTypeSpec_AST;
2872            }
2873            
2874            public final void classOrInterfaceType(
2875                    boolean addImagNode
2876            ) throws RecognitionException, TokenStreamException {
2877                    
2878                    returnAST = null;
2879                    ASTPair currentAST = new ASTPair();
2880                    AST classOrInterfaceType_AST = null;
2881                    Token first = LT(1);
2882                    
2883                    AST tmp91_AST = null;
2884                    tmp91_AST = astFactory.create(LT(1));
2885                    astFactory.makeASTRoot(currentAST, tmp91_AST);
2886                    match(IDENT);
2887                    {
2888                    switch ( LA(1)) {
2889                    case LT:
2890                    {
2891                            typeArguments();
2892                            astFactory.addASTChild(currentAST, returnAST);
2893                            break;
2894                    }
2895                    case EOF:
2896                    case UNUSED_DO:
2897                    case LITERAL_def:
2898                    case AT:
2899                    case IDENT:
2900                    case LBRACK:
2901                    case RBRACK:
2902                    case DOT:
2903                    case LPAREN:
2904                    case LITERAL_class:
2905                    case QUESTION:
2906                    case LITERAL_extends:
2907                    case LITERAL_super:
2908                    case COMMA:
2909                    case GT:
2910                    case SR:
2911                    case BSR:
2912                    case LITERAL_void:
2913                    case LITERAL_boolean:
2914                    case LITERAL_byte:
2915                    case LITERAL_char:
2916                    case LITERAL_short:
2917                    case LITERAL_int:
2918                    case LITERAL_float:
2919                    case LITERAL_long:
2920                    case LITERAL_double:
2921                    case LITERAL_any:
2922                    case LITERAL_as:
2923                    case RPAREN:
2924                    case ASSIGN:
2925                    case BAND:
2926                    case LCURLY:
2927                    case RCURLY:
2928                    case SEMI:
2929                    case NLS:
2930                    case LITERAL_default:
2931                    case LITERAL_implements:
2932                    case LITERAL_this:
2933                    case STRING_LITERAL:
2934                    case TRIPLE_DOT:
2935                    case CLOSABLE_BLOCK_OP:
2936                    case COLON:
2937                    case LITERAL_if:
2938                    case LITERAL_else:
2939                    case LITERAL_while:
2940                    case LITERAL_switch:
2941                    case LITERAL_for:
2942                    case LITERAL_in:
2943                    case PLUS:
2944                    case MINUS:
2945                    case LITERAL_case:
2946                    case LITERAL_try:
2947                    case LITERAL_finally:
2948                    case LITERAL_catch:
2949                    case PLUS_ASSIGN:
2950                    case MINUS_ASSIGN:
2951                    case STAR_ASSIGN:
2952                    case DIV_ASSIGN:
2953                    case MOD_ASSIGN:
2954                    case SR_ASSIGN:
2955                    case BSR_ASSIGN:
2956                    case SL_ASSIGN:
2957                    case BAND_ASSIGN:
2958                    case BXOR_ASSIGN:
2959                    case BOR_ASSIGN:
2960                    case STAR_STAR_ASSIGN:
2961                    case LOR:
2962                    case LAND:
2963                    case BOR:
2964                    case BXOR:
2965                    case REGEX_FIND:
2966                    case REGEX_MATCH:
2967                    case NOT_EQUAL:
2968                    case EQUAL:
2969                    case COMPARE_TO:
2970                    case INC:
2971                    case DEC:
2972                    case BNOT:
2973                    case LNOT:
2974                    case DOLLAR:
2975                    case STRING_CTOR_START:
2976                    case LITERAL_new:
2977                    case LITERAL_true:
2978                    case LITERAL_false:
2979                    case LITERAL_null:
2980                    case NUM_INT:
2981                    case NUM_FLOAT:
2982                    case NUM_LONG:
2983                    case NUM_DOUBLE:
2984                    case NUM_BIG_INT:
2985                    case NUM_BIG_DECIMAL:
2986                    {
2987                            break;
2988                    }
2989                    default:
2990                    {
2991                            throw new NoViableAltException(LT(1), getFilename());
2992                    }
2993                    }
2994                    }
2995                    {
2996                    _loop38:
2997                    do {
2998                            if ((LA(1)==DOT) && (LA(2)==IDENT) && (_tokenSet_44.member(LA(3)))) {
2999                                    AST tmp92_AST = null;
3000                                    tmp92_AST = astFactory.create(LT(1));
3001                                    astFactory.makeASTRoot(currentAST, tmp92_AST);
3002                                    match(DOT);
3003                                    AST tmp93_AST = null;
3004                                    tmp93_AST = astFactory.create(LT(1));
3005                                    astFactory.addASTChild(currentAST, tmp93_AST);
3006                                    match(IDENT);
3007                                    {
3008                                    switch ( LA(1)) {
3009                                    case LT:
3010                                    {
3011                                            typeArguments();
3012                                            astFactory.addASTChild(currentAST, returnAST);
3013                                            break;
3014                                    }
3015                                    case EOF:
3016                                    case UNUSED_DO:
3017                                    case LITERAL_def:
3018                                    case AT:
3019                                    case IDENT:
3020                                    case LBRACK:
3021                                    case RBRACK:
3022                                    case DOT:
3023                                    case LPAREN:
3024                                    case LITERAL_class:
3025                                    case QUESTION:
3026                                    case LITERAL_extends:
3027                                    case LITERAL_super:
3028                                    case COMMA:
3029                                    case GT:
3030                                    case SR:
3031                                    case BSR:
3032                                    case LITERAL_void:
3033                                    case LITERAL_boolean:
3034                                    case LITERAL_byte:
3035                                    case LITERAL_char:
3036                                    case LITERAL_short:
3037                                    case LITERAL_int:
3038                                    case LITERAL_float:
3039                                    case LITERAL_long:
3040                                    case LITERAL_double:
3041                                    case LITERAL_any:
3042                                    case LITERAL_as:
3043                                    case RPAREN:
3044                                    case ASSIGN:
3045                                    case BAND:
3046                                    case LCURLY:
3047                                    case RCURLY:
3048                                    case SEMI:
3049                                    case NLS:
3050                                    case LITERAL_default:
3051                                    case LITERAL_implements:
3052                                    case LITERAL_this:
3053                                    case STRING_LITERAL:
3054                                    case TRIPLE_DOT:
3055                                    case CLOSABLE_BLOCK_OP:
3056                                    case COLON:
3057                                    case LITERAL_if:
3058                                    case LITERAL_else:
3059                                    case LITERAL_while:
3060                                    case LITERAL_switch:
3061                                    case LITERAL_for:
3062                                    case LITERAL_in:
3063                                    case PLUS:
3064                                    case MINUS:
3065                                    case LITERAL_case:
3066                                    case LITERAL_try:
3067                                    case LITERAL_finally:
3068                                    case LITERAL_catch:
3069                                    case PLUS_ASSIGN:
3070                                    case MINUS_ASSIGN:
3071                                    case STAR_ASSIGN:
3072                                    case DIV_ASSIGN:
3073                                    case MOD_ASSIGN:
3074                                    case SR_ASSIGN:
3075                                    case BSR_ASSIGN:
3076                                    case SL_ASSIGN:
3077                                    case BAND_ASSIGN:
3078                                    case BXOR_ASSIGN:
3079                                    case BOR_ASSIGN:
3080                                    case STAR_STAR_ASSIGN:
3081                                    case LOR:
3082                                    case LAND:
3083                                    case BOR:
3084                                    case BXOR:
3085                                    case REGEX_FIND:
3086                                    case REGEX_MATCH:
3087                                    case NOT_EQUAL:
3088                                    case EQUAL:
3089                                    case COMPARE_TO:
3090                                    case INC:
3091                                    case DEC:
3092                                    case BNOT:
3093                                    case LNOT:
3094                                    case DOLLAR:
3095                                    case STRING_CTOR_START:
3096                                    case LITERAL_new:
3097                                    case LITERAL_true:
3098                                    case LITERAL_false:
3099                                    case LITERAL_null:
3100                                    case NUM_INT:
3101                                    case NUM_FLOAT:
3102                                    case NUM_LONG:
3103                                    case NUM_DOUBLE:
3104                                    case NUM_BIG_INT:
3105                                    case NUM_BIG_DECIMAL:
3106                                    {
3107                                            break;
3108                                    }
3109                                    default:
3110                                    {
3111                                            throw new NoViableAltException(LT(1), getFilename());
3112                                    }
3113                                    }
3114                                    }
3115                            }
3116                            else {
3117                                    break _loop38;
3118                            }
3119                            
3120                    } while (true);
3121                    }
3122                    if ( inputState.guessing==0 ) {
3123                            classOrInterfaceType_AST = (AST)currentAST.root;
3124                            
3125                            if ( addImagNode ) {
3126                            classOrInterfaceType_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(classOrInterfaceType_AST));
3127                            }
3128                            
3129                            currentAST.root = classOrInterfaceType_AST;
3130                            currentAST.child = classOrInterfaceType_AST!=null &&classOrInterfaceType_AST.getFirstChild()!=null ?
3131                                    classOrInterfaceType_AST.getFirstChild() : classOrInterfaceType_AST;
3132                            currentAST.advanceChildToEnd();
3133                    }
3134                    classOrInterfaceType_AST = (AST)currentAST.root;
3135                    returnAST = classOrInterfaceType_AST;
3136            }
3137            
3138    /** After some type names, where zero or more empty bracket pairs are allowed.
3139     *  We use ARRAY_DECLARATOR to represent this.
3140     *  TODO:  Is there some more Groovy way to view this in terms of the indexed property syntax?
3141     */
3142            public final void declaratorBrackets(
3143                    AST typ
3144            ) throws RecognitionException, TokenStreamException {
3145                    
3146                    returnAST = null;
3147                    ASTPair currentAST = new ASTPair();
3148                    AST declaratorBrackets_AST = null;
3149                    Token  lb = null;
3150                    AST lb_AST = null;
3151                    
3152                    if ( inputState.guessing==0 ) {
3153                            declaratorBrackets_AST = (AST)currentAST.root;
3154                            declaratorBrackets_AST=typ;
3155                            currentAST.root = declaratorBrackets_AST;
3156                            currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
3157                                    declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
3158                            currentAST.advanceChildToEnd();
3159                    }
3160                    {
3161                    _loop209:
3162                    do {
3163                            if ((LA(1)==LBRACK) && (LA(2)==RBRACK) && (_tokenSet_45.member(LA(3)))) {
3164                                    lb = LT(1);
3165                                    lb_AST = astFactory.create(lb);
3166                                    astFactory.makeASTRoot(currentAST, lb_AST);
3167                                    match(LBRACK);
3168                                    if ( inputState.guessing==0 ) {
3169                                            lb_AST.setType(ARRAY_DECLARATOR);
3170                                    }
3171                                    match(RBRACK);
3172                            }
3173                            else {
3174                                    break _loop209;
3175                            }
3176                            
3177                    } while (true);
3178                    }
3179                    declaratorBrackets_AST = (AST)currentAST.root;
3180                    returnAST = declaratorBrackets_AST;
3181            }
3182            
3183            public final void typeArguments() throws RecognitionException, TokenStreamException {
3184                    
3185                    returnAST = null;
3186                    ASTPair currentAST = new ASTPair();
3187                    AST typeArguments_AST = null;
3188                    Token first = LT(1);
3189                    int currentLtLevel = 0;
3190                    
3191                    if ( inputState.guessing==0 ) {
3192                            currentLtLevel = ltCounter;
3193                    }
3194                    match(LT);
3195                    if ( inputState.guessing==0 ) {
3196                            ltCounter++;
3197                    }
3198                    nls();
3199                    typeArgument();
3200                    astFactory.addASTChild(currentAST, returnAST);
3201                    {
3202                    _loop48:
3203                    do {
3204                            if (((LA(1)==COMMA) && (_tokenSet_46.member(LA(2))) && (_tokenSet_44.member(LA(3))))&&(inputState.guessing !=0 || ltCounter == currentLtLevel + 1)) {
3205                                    match(COMMA);
3206                                    nls();
3207                                    typeArgument();
3208                                    astFactory.addASTChild(currentAST, returnAST);
3209                            }
3210                            else {
3211                                    break _loop48;
3212                            }
3213                            
3214                    } while (true);
3215                    }
3216                    nls();
3217                    {
3218                    if (((LA(1) >= GT && LA(1) <= BSR)) && (_tokenSet_45.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
3219                            typeArgumentsOrParametersEnd();
3220                            astFactory.addASTChild(currentAST, returnAST);
3221                    }
3222                    else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
3223                    }
3224                    else {
3225                            throw new NoViableAltException(LT(1), getFilename());
3226                    }
3227                    
3228                    }
3229                    if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
3230                      throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel");
3231                    if ( inputState.guessing==0 ) {
3232                            typeArguments_AST = (AST)currentAST.root;
3233                            typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS",first,LT(1))).add(typeArguments_AST));
3234                            currentAST.root = typeArguments_AST;
3235                            currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ?
3236                                    typeArguments_AST.getFirstChild() : typeArguments_AST;
3237                            currentAST.advanceChildToEnd();
3238                    }
3239                    typeArguments_AST = (AST)currentAST.root;
3240                    returnAST = typeArguments_AST;
3241            }
3242            
3243            public final void typeArgumentSpec() throws RecognitionException, TokenStreamException {
3244                    
3245                    returnAST = null;
3246                    ASTPair currentAST = new ASTPair();
3247                    AST typeArgumentSpec_AST = null;
3248                    
3249                    switch ( LA(1)) {
3250                    case IDENT:
3251                    {
3252                            classTypeSpec(true);
3253                            astFactory.addASTChild(currentAST, returnAST);
3254                            typeArgumentSpec_AST = (AST)currentAST.root;
3255                            break;
3256                    }
3257                    case LITERAL_void:
3258                    case LITERAL_boolean:
3259                    case LITERAL_byte:
3260                    case LITERAL_char:
3261                    case LITERAL_short:
3262                    case LITERAL_int:
3263                    case LITERAL_float:
3264                    case LITERAL_long:
3265                    case LITERAL_double:
3266                    case LITERAL_any:
3267                    {
3268                            builtInTypeArraySpec(true);
3269                            astFactory.addASTChild(currentAST, returnAST);
3270                            typeArgumentSpec_AST = (AST)currentAST.root;
3271                            break;
3272                    }
3273                    default:
3274                    {
3275                            throw new NoViableAltException(LT(1), getFilename());
3276                    }
3277                    }
3278                    returnAST = typeArgumentSpec_AST;
3279            }
3280            
3281            public final void builtInTypeArraySpec(
3282                    boolean addImagNode
3283            ) throws RecognitionException, TokenStreamException {
3284                    
3285                    returnAST = null;
3286                    ASTPair currentAST = new ASTPair();
3287                    AST builtInTypeArraySpec_AST = null;
3288                    AST bt_AST = null;
3289                    Token first = LT(1);
3290                    
3291                    builtInType();
3292                    bt_AST = (AST)returnAST;
3293                    {
3294                    boolean synPredMatched56 = false;
3295                    if (((_tokenSet_45.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3))))) {
3296                            int _m56 = mark();
3297                            synPredMatched56 = true;
3298                            inputState.guessing++;
3299                            try {
3300                                    {
3301                                    match(LBRACK);
3302                                    }
3303                            }
3304                            catch (RecognitionException pe) {
3305                                    synPredMatched56 = false;
3306                            }
3307                            rewind(_m56);
3308    inputState.guessing--;
3309                    }
3310                    if ( synPredMatched56 ) {
3311                            declaratorBrackets(bt_AST);
3312                            astFactory.addASTChild(currentAST, returnAST);
3313                    }
3314                    else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
3315                            if ( inputState.guessing==0 ) {
3316                                    require(false,
3317                                    "primitive type parameters not allowed here",
3318                                    "use the corresponding wrapper type, such as Integer for int"
3319                                    );
3320                            }
3321                    }
3322                    else {
3323                            throw new NoViableAltException(LT(1), getFilename());
3324                    }
3325                    
3326                    }
3327                    if ( inputState.guessing==0 ) {
3328                            builtInTypeArraySpec_AST = (AST)currentAST.root;
3329                            
3330                            if ( addImagNode ) {
3331                            builtInTypeArraySpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(builtInTypeArraySpec_AST));
3332                            }
3333                            
3334                            currentAST.root = builtInTypeArraySpec_AST;
3335                            currentAST.child = builtInTypeArraySpec_AST!=null &&builtInTypeArraySpec_AST.getFirstChild()!=null ?
3336                                    builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST;
3337                            currentAST.advanceChildToEnd();
3338                    }
3339                    builtInTypeArraySpec_AST = (AST)currentAST.root;
3340                    returnAST = builtInTypeArraySpec_AST;
3341            }
3342            
3343            public final void typeArgument() throws RecognitionException, TokenStreamException {
3344                    
3345                    returnAST = null;
3346                    ASTPair currentAST = new ASTPair();
3347                    AST typeArgument_AST = null;
3348                    Token first = LT(1);
3349                    
3350                    {
3351                    switch ( LA(1)) {
3352                    case IDENT:
3353                    case LITERAL_void:
3354                    case LITERAL_boolean:
3355                    case LITERAL_byte:
3356                    case LITERAL_char:
3357                    case LITERAL_short:
3358                    case LITERAL_int:
3359                    case LITERAL_float:
3360                    case LITERAL_long:
3361                    case LITERAL_double:
3362                    case LITERAL_any:
3363                    {
3364                            typeArgumentSpec();
3365                            astFactory.addASTChild(currentAST, returnAST);
3366                            break;
3367                    }
3368                    case QUESTION:
3369                    {
3370                            wildcardType();
3371                            astFactory.addASTChild(currentAST, returnAST);
3372                            break;
3373                    }
3374                    default:
3375                    {
3376                            throw new NoViableAltException(LT(1), getFilename());
3377                    }
3378                    }
3379                    }
3380                    if ( inputState.guessing==0 ) {
3381                            typeArgument_AST = (AST)currentAST.root;
3382                            typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_ARGUMENT,"TYPE_ARGUMENT",first,LT(1))).add(typeArgument_AST));
3383                            currentAST.root = typeArgument_AST;
3384                            currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ?
3385                                    typeArgument_AST.getFirstChild() : typeArgument_AST;
3386                            currentAST.advanceChildToEnd();
3387                    }
3388                    typeArgument_AST = (AST)currentAST.root;
3389                    returnAST = typeArgument_AST;
3390            }
3391            
3392            public final void wildcardType() throws RecognitionException, TokenStreamException {
3393                    
3394                    returnAST = null;
3395                    ASTPair currentAST = new ASTPair();
3396                    AST wildcardType_AST = null;
3397                    Token  q = null;
3398                    AST q_AST = null;
3399                    
3400                    q = LT(1);
3401                    q_AST = astFactory.create(q);
3402                    astFactory.makeASTRoot(currentAST, q_AST);
3403                    match(QUESTION);
3404                    if ( inputState.guessing==0 ) {
3405                            q_AST.setType(WILDCARD_TYPE);
3406                    }
3407                    {
3408                    boolean synPredMatched45 = false;
3409                    if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (LA(2)==IDENT||LA(2)==NLS) && (_tokenSet_44.member(LA(3))))) {
3410                            int _m45 = mark();
3411                            synPredMatched45 = true;
3412                            inputState.guessing++;
3413                            try {
3414                                    {
3415                                    switch ( LA(1)) {
3416                                    case LITERAL_extends:
3417                                    {
3418                                            match(LITERAL_extends);
3419                                            break;
3420                                    }
3421                                    case LITERAL_super:
3422                                    {
3423                                            match(LITERAL_super);
3424                                            break;
3425                                    }
3426                                    default:
3427                                    {
3428                                            throw new NoViableAltException(LT(1), getFilename());
3429                                    }
3430                                    }
3431                                    }
3432                            }
3433                            catch (RecognitionException pe) {
3434                                    synPredMatched45 = false;
3435                            }
3436                            rewind(_m45);
3437    inputState.guessing--;
3438                    }
3439                    if ( synPredMatched45 ) {
3440                            typeArgumentBounds();
3441                            astFactory.addASTChild(currentAST, returnAST);
3442                    }
3443                    else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
3444                    }
3445                    else {
3446                            throw new NoViableAltException(LT(1), getFilename());
3447                    }
3448                    
3449                    }
3450                    wildcardType_AST = (AST)currentAST.root;
3451                    returnAST = wildcardType_AST;
3452            }
3453            
3454            public final void typeArgumentBounds() throws RecognitionException, TokenStreamException {
3455                    
3456                    returnAST = null;
3457                    ASTPair currentAST = new ASTPair();
3458                    AST typeArgumentBounds_AST = null;
3459                    Token first = LT(1);boolean isUpperBounds = false;
3460                    
3461                    {
3462                    switch ( LA(1)) {
3463                    case LITERAL_extends:
3464                    {
3465                            match(LITERAL_extends);
3466                            if ( inputState.guessing==0 ) {
3467                                    isUpperBounds=true;
3468                            }
3469                            break;
3470                    }
3471                    case LITERAL_super:
3472                    {
3473                            match(LITERAL_super);
3474                            break;
3475                    }
3476                    default:
3477                    {
3478                            throw new NoViableAltException(LT(1), getFilename());
3479                    }
3480                    }
3481                    }
3482                    nls();
3483                    classOrInterfaceType(false);
3484                    astFactory.addASTChild(currentAST, returnAST);
3485                    nls();
3486                    if ( inputState.guessing==0 ) {
3487                            typeArgumentBounds_AST = (AST)currentAST.root;
3488                            
3489                            if (isUpperBounds)
3490                            {
3491                            typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS",first,LT(1))).add(typeArgumentBounds_AST));
3492                            }
3493                            else
3494                            {
3495                            typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_LOWER_BOUNDS,"TYPE_LOWER_BOUNDS",first,LT(1))).add(typeArgumentBounds_AST));
3496                            }
3497                            
3498                            currentAST.root = typeArgumentBounds_AST;
3499                            currentAST.child = typeArgumentBounds_AST!=null &&typeArgumentBounds_AST.getFirstChild()!=null ?
3500                                    typeArgumentBounds_AST.getFirstChild() : typeArgumentBounds_AST;
3501                            currentAST.advanceChildToEnd();
3502                    }
3503                    typeArgumentBounds_AST = (AST)currentAST.root;
3504                    returnAST = typeArgumentBounds_AST;
3505            }
3506            
3507            protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException {
3508                    
3509                    returnAST = null;
3510                    ASTPair currentAST = new ASTPair();
3511                    AST typeArgumentsOrParametersEnd_AST = null;
3512                    
3513                    switch ( LA(1)) {
3514                    case GT:
3515                    {
3516                            match(GT);
3517                            if ( inputState.guessing==0 ) {
3518                                    ltCounter-=1;
3519                            }
3520                            nls();
3521                            typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
3522                            break;
3523                    }
3524                    case SR:
3525                    {
3526                            match(SR);
3527                            if ( inputState.guessing==0 ) {
3528                                    ltCounter-=2;
3529                            }
3530                            nls();
3531                            typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
3532                            break;
3533                    }
3534                    case BSR:
3535                    {
3536                            match(BSR);
3537                            if ( inputState.guessing==0 ) {
3538                                    ltCounter-=3;
3539                            }
3540                            nls();
3541                            typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
3542                            break;
3543                    }
3544                    default:
3545                    {
3546                            throw new NoViableAltException(LT(1), getFilename());
3547                    }
3548                    }
3549                    returnAST = typeArgumentsOrParametersEnd_AST;
3550            }
3551            
3552            public final void type() throws RecognitionException, TokenStreamException {
3553                    
3554                    returnAST = null;
3555                    ASTPair currentAST = new ASTPair();
3556                    AST type_AST = null;
3557                    
3558                    switch ( LA(1)) {
3559                    case IDENT:
3560                    {
3561                            classOrInterfaceType(false);
3562                            astFactory.addASTChild(currentAST, returnAST);
3563                            type_AST = (AST)currentAST.root;
3564                            break;
3565                    }
3566                    case LITERAL_void:
3567                    case LITERAL_boolean:
3568                    case LITERAL_byte:
3569                    case LITERAL_char:
3570                    case LITERAL_short:
3571                    case LITERAL_int:
3572                    case LITERAL_float:
3573                    case LITERAL_long:
3574                    case LITERAL_double:
3575                    case LITERAL_any:
3576                    {
3577                            builtInType();
3578                            astFactory.addASTChild(currentAST, returnAST);
3579                            type_AST = (AST)currentAST.root;
3580                            break;
3581                    }
3582                    default:
3583                    {
3584                            throw new NoViableAltException(LT(1), getFilename());
3585                    }
3586                    }
3587                    returnAST = type_AST;
3588            }
3589            
3590            public final void modifiersInternal() throws RecognitionException, TokenStreamException {
3591                    
3592                    returnAST = null;
3593                    ASTPair currentAST = new ASTPair();
3594                    AST modifiersInternal_AST = null;
3595                    int seenDef = 0;
3596                    
3597                    {
3598                    int _cnt69=0;
3599                    _loop69:
3600                    do {
3601                            if (((LA(1)==LITERAL_def))&&(seenDef++ == 0)) {
3602                                    match(LITERAL_def);
3603                                    nls();
3604                            }
3605                            else if ((_tokenSet_47.member(LA(1)))) {
3606                                    modifier();
3607                                    astFactory.addASTChild(currentAST, returnAST);
3608                                    nls();
3609                            }
3610                            else if (((LA(1)==AT) && (LA(2)==IDENT) && (_tokenSet_48.member(LA(3))))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) {
3611                                    annotation();
3612                                    astFactory.addASTChild(currentAST, returnAST);
3613                                    nls();
3614                            }
3615                            else {
3616                                    if ( _cnt69>=1 ) { break _loop69; } else {throw new NoViableAltException(LT(1), getFilename());}
3617                            }
3618                            
3619                            _cnt69++;
3620                    } while (true);
3621                    }
3622                    modifiersInternal_AST = (AST)currentAST.root;
3623                    returnAST = modifiersInternal_AST;
3624            }
3625            
3626            public final void annotation() throws RecognitionException, TokenStreamException {
3627                    
3628                    returnAST = null;
3629                    ASTPair currentAST = new ASTPair();
3630                    AST annotation_AST = null;
3631                    AST i_AST = null;
3632                    AST args_AST = null;
3633                    Token first = LT(1);
3634                    
3635                    match(AT);
3636                    identifier();
3637                    i_AST = (AST)returnAST;
3638                    {
3639                    switch ( LA(1)) {
3640                    case LPAREN:
3641                    {
3642                            match(LPAREN);
3643                            {
3644                            switch ( LA(1)) {
3645                            case AT:
3646                            case IDENT:
3647                            case LBRACK:
3648                            case LPAREN:
3649                            case LITERAL_super:
3650                            case LITERAL_void:
3651                            case LITERAL_boolean:
3652                            case LITERAL_byte:
3653                            case LITERAL_char:
3654                            case LITERAL_short:
3655                            case LITERAL_int:
3656                            case LITERAL_float:
3657                            case LITERAL_long:
3658                            case LITERAL_double:
3659                            case LITERAL_any:
3660                            case LCURLY:
3661                            case LITERAL_this:
3662                            case STRING_LITERAL:
3663                            case PLUS:
3664                            case MINUS:
3665                            case INC:
3666                            case DEC:
3667                            case BNOT:
3668                            case LNOT:
3669                            case DOLLAR:
3670                            case STRING_CTOR_START:
3671                            case LITERAL_new:
3672                            case LITERAL_true:
3673                            case LITERAL_false:
3674                            case LITERAL_null:
3675                            case NUM_INT:
3676                            case NUM_FLOAT:
3677                            case NUM_LONG:
3678                            case NUM_DOUBLE:
3679                            case NUM_BIG_INT:
3680                            case NUM_BIG_DECIMAL:
3681                            {
3682                                    annotationArguments();
3683                                    args_AST = (AST)returnAST;
3684                                    break;
3685                            }
3686                            case RPAREN:
3687                            {
3688                                    break;
3689                            }
3690                            default:
3691                            {
3692                                    throw new NoViableAltException(LT(1), getFilename());
3693                            }
3694                            }
3695                            }
3696                            match(RPAREN);
3697                            break;
3698                    }
3699                    case EOF:
3700                    case FINAL:
3701                    case ABSTRACT:
3702                    case STRICTFP:
3703                    case LITERAL_package:
3704                    case LITERAL_static:
3705                    case LITERAL_def:
3706                    case AT:
3707                    case IDENT:
3708                    case RBRACK:
3709                    case LITERAL_class:
3710                    case LITERAL_interface:
3711                    case LITERAL_enum:
3712                    case LT:
3713                    case COMMA:
3714                    case LITERAL_void:
3715                    case LITERAL_boolean:
3716                    case LITERAL_byte:
3717                    case LITERAL_char:
3718                    case LITERAL_short:
3719                    case LITERAL_int:
3720                    case LITERAL_float:
3721                    case LITERAL_long:
3722                    case LITERAL_double:
3723                    case LITERAL_any:
3724                    case LITERAL_private:
3725                    case LITERAL_public:
3726                    case LITERAL_protected:
3727                    case LITERAL_transient:
3728                    case LITERAL_native:
3729                    case LITERAL_threadsafe:
3730                    case LITERAL_synchronized:
3731                    case LITERAL_volatile:
3732                    case RPAREN:
3733                    case RCURLY:
3734                    case SEMI:
3735                    case NLS:
3736                    case STRING_LITERAL:
3737                    case TRIPLE_DOT:
3738                    {
3739                            break;
3740                    }
3741                    default:
3742                    {
3743                            throw new NoViableAltException(LT(1), getFilename());
3744                    }
3745                    }
3746                    }
3747                    if ( inputState.guessing==0 ) {
3748                            annotation_AST = (AST)currentAST.root;
3749                            annotation_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(ANNOTATION,"ANNOTATION",first,LT(1))).add(i_AST).add(args_AST));
3750                            currentAST.root = annotation_AST;
3751                            currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ?
3752                                    annotation_AST.getFirstChild() : annotation_AST;
3753                            currentAST.advanceChildToEnd();
3754                    }
3755                    returnAST = annotation_AST;
3756            }
3757            
3758            public final void annotationArguments() throws RecognitionException, TokenStreamException {
3759                    
3760                    returnAST = null;
3761                    ASTPair currentAST = new ASTPair();
3762                    AST annotationArguments_AST = null;
3763                    
3764                    if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) {
3765                            annotationMemberValueInitializer();
3766                            astFactory.addASTChild(currentAST, returnAST);
3767                            annotationArguments_AST = (AST)currentAST.root;
3768                    }
3769                    else if ((LA(1)==IDENT) && (LA(2)==ASSIGN)) {
3770                            anntotationMemberValuePairs();
3771                            astFactory.addASTChild(currentAST, returnAST);
3772                            annotationArguments_AST = (AST)currentAST.root;
3773                    }
3774                    else {
3775                            throw new NoViableAltException(LT(1), getFilename());
3776                    }
3777                    
3778                    returnAST = annotationArguments_AST;
3779            }
3780            
3781            public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException {
3782                    
3783                    returnAST = null;
3784                    ASTPair currentAST = new ASTPair();
3785                    AST annotationMemberValueInitializer_AST = null;
3786                    
3787                    switch ( LA(1)) {
3788                    case IDENT:
3789                    case LBRACK:
3790                    case LPAREN:
3791                    case LITERAL_super:
3792                    case LITERAL_void:
3793                    case LITERAL_boolean:
3794                    case LITERAL_byte:
3795                    case LITERAL_char:
3796                    case LITERAL_short:
3797                    case LITERAL_int:
3798                    case LITERAL_float:
3799                    case LITERAL_long:
3800                    case LITERAL_double:
3801                    case LITERAL_any:
3802                    case LCURLY:
3803                    case LITERAL_this:
3804                    case STRING_LITERAL:
3805                    case PLUS:
3806                    case MINUS:
3807                    case INC:
3808                    case DEC:
3809                    case BNOT:
3810                    case LNOT:
3811                    case DOLLAR:
3812                    case STRING_CTOR_START:
3813                    case LITERAL_new:
3814                    case LITERAL_true:
3815                    case LITERAL_false:
3816                    case LITERAL_null:
3817                    case NUM_INT:
3818                    case NUM_FLOAT:
3819                    case NUM_LONG:
3820                    case NUM_DOUBLE:
3821                    case NUM_BIG_INT:
3822                    case NUM_BIG_DECIMAL:
3823                    {
3824                            conditionalExpression(0);
3825                            astFactory.addASTChild(currentAST, returnAST);
3826                            annotationMemberValueInitializer_AST = (AST)currentAST.root;
3827                            break;
3828                    }
3829                    case AT:
3830                    {
3831                            annotation();
3832                            astFactory.addASTChild(currentAST, returnAST);
3833                            annotationMemberValueInitializer_AST = (AST)currentAST.root;
3834                            break;
3835                    }
3836                    default:
3837                    {
3838                            throw new NoViableAltException(LT(1), getFilename());
3839                    }
3840                    }
3841                    returnAST = annotationMemberValueInitializer_AST;
3842            }
3843            
3844            public final void anntotationMemberValuePairs() throws RecognitionException, TokenStreamException {
3845                    
3846                    returnAST = null;
3847                    ASTPair currentAST = new ASTPair();
3848                    AST anntotationMemberValuePairs_AST = null;
3849                    
3850                    annotationMemberValuePair();
3851                    astFactory.addASTChild(currentAST, returnAST);
3852                    {
3853                    _loop83:
3854                    do {
3855                            if ((LA(1)==COMMA)) {
3856                                    match(COMMA);
3857                                    nls();
3858                                    annotationMemberValuePair();
3859                                    astFactory.addASTChild(currentAST, returnAST);
3860                            }
3861                            else {
3862                                    break _loop83;
3863                            }
3864                            
3865                    } while (true);
3866                    }
3867                    anntotationMemberValuePairs_AST = (AST)currentAST.root;
3868                    returnAST = anntotationMemberValuePairs_AST;
3869            }
3870            
3871            public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException {
3872                    
3873                    returnAST = null;
3874                    ASTPair currentAST = new ASTPair();
3875                    AST annotationMemberValuePair_AST = null;
3876                    Token  i = null;
3877                    AST i_AST = null;
3878                    AST v_AST = null;
3879                    Token first = LT(1);
3880                    
3881                    i = LT(1);
3882                    i_AST = astFactory.create(i);
3883                    match(IDENT);
3884                    match(ASSIGN);
3885                    nls();
3886                    annotationMemberValueInitializer();
3887                    v_AST = (AST)returnAST;
3888                    if ( inputState.guessing==0 ) {
3889                            annotationMemberValuePair_AST = (AST)currentAST.root;
3890                            annotationMemberValuePair_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",first,LT(1))).add(i_AST).add(v_AST));
3891                            currentAST.root = annotationMemberValuePair_AST;
3892                            currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ?
3893                                    annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST;
3894                            currentAST.advanceChildToEnd();
3895                    }
3896                    returnAST = annotationMemberValuePair_AST;
3897            }
3898            
3899            public final void conditionalExpression(
3900                    int lc_stmt
3901            ) throws RecognitionException, TokenStreamException {
3902                    
3903                    returnAST = null;
3904                    ASTPair currentAST = new ASTPair();
3905                    AST conditionalExpression_AST = null;
3906                    
3907                    logicalOrExpression(lc_stmt);
3908                    astFactory.addASTChild(currentAST, returnAST);
3909                    {
3910                    switch ( LA(1)) {
3911                    case QUESTION:
3912                    {
3913                            AST tmp108_AST = null;
3914                            tmp108_AST = astFactory.create(LT(1));
3915                            astFactory.makeASTRoot(currentAST, tmp108_AST);
3916                            match(QUESTION);
3917                            nls();
3918                            assignmentExpression(0);
3919                            astFactory.addASTChild(currentAST, returnAST);
3920                            match(COLON);
3921                            nls();
3922                            conditionalExpression(0);
3923                            astFactory.addASTChild(currentAST, returnAST);
3924                            break;
3925                    }
3926                    case EOF:
3927                    case IDENT:
3928                    case LBRACK:
3929                    case RBRACK:
3930                    case LPAREN:
3931                    case LITERAL_super:
3932                    case COMMA:
3933                    case LITERAL_void:
3934                    case LITERAL_boolean:
3935                    case LITERAL_byte:
3936                    case LITERAL_char:
3937                    case LITERAL_short:
3938                    case LITERAL_int:
3939                    case LITERAL_float:
3940                    case LITERAL_long:
3941                    case LITERAL_double:
3942                    case LITERAL_any:
3943                    case RPAREN:
3944                    case ASSIGN:
3945                    case LCURLY:
3946                    case RCURLY:
3947                    case SEMI:
3948                    case NLS:
3949                    case LITERAL_default:
3950                    case LITERAL_this:
3951                    case STRING_LITERAL:
3952                    case CLOSABLE_BLOCK_OP:
3953                    case COLON:
3954                    case LITERAL_else:
3955                    case PLUS:
3956                    case MINUS:
3957                    case LITERAL_case:
3958                    case PLUS_ASSIGN:
3959                    case MINUS_ASSIGN:
3960                    case STAR_ASSIGN:
3961                    case DIV_ASSIGN:
3962                    case MOD_ASSIGN:
3963                    case SR_ASSIGN:
3964                    case BSR_ASSIGN:
3965                    case SL_ASSIGN:
3966                    case BAND_ASSIGN:
3967                    case BXOR_ASSIGN:
3968                    case BOR_ASSIGN:
3969                    case STAR_STAR_ASSIGN:
3970                    case INC:
3971                    case DEC:
3972                    case BNOT:
3973                    case LNOT:
3974                    case DOLLAR:
3975                    case STRING_CTOR_START:
3976                    case LITERAL_new:
3977                    case LITERAL_true:
3978                    case LITERAL_false:
3979                    case LITERAL_null:
3980                    case NUM_INT:
3981                    case NUM_FLOAT:
3982                    case NUM_LONG:
3983                    case NUM_DOUBLE:
3984                    case NUM_BIG_INT:
3985                    case NUM_BIG_DECIMAL:
3986                    {
3987                            break;
3988                    }
3989                    default:
3990                    {
3991                            throw new NoViableAltException(LT(1), getFilename());
3992                    }
3993                    }
3994                    }
3995                    conditionalExpression_AST = (AST)currentAST.root;
3996                    returnAST = conditionalExpression_AST;
3997            }
3998            
3999            public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException {
4000                    
4001                    returnAST = null;
4002                    ASTPair currentAST = new ASTPair();
4003                    AST annotationMemberArrayValueInitializer_AST = null;
4004                    
4005                    switch ( LA(1)) {
4006                    case IDENT:
4007                    case LBRACK:
4008                    case LPAREN:
4009                    case LITERAL_super:
4010                    case LITERAL_void:
4011                    case LITERAL_boolean:
4012                    case LITERAL_byte:
4013                    case LITERAL_char:
4014                    case LITERAL_short:
4015                    case LITERAL_int:
4016                    case LITERAL_float:
4017                    case LITERAL_long:
4018                    case LITERAL_double:
4019                    case LITERAL_any:
4020                    case LCURLY:
4021                    case LITERAL_this:
4022                    case STRING_LITERAL:
4023                    case PLUS:
4024                    case MINUS:
4025                    case INC:
4026                    case DEC:
4027                    case BNOT:
4028                    case LNOT:
4029                    case DOLLAR:
4030                    case STRING_CTOR_START:
4031                    case LITERAL_new:
4032                    case LITERAL_true:
4033                    case LITERAL_false:
4034                    case LITERAL_null:
4035                    case NUM_INT:
4036                    case NUM_FLOAT:
4037                    case NUM_LONG:
4038                    case NUM_DOUBLE:
4039                    case NUM_BIG_INT:
4040                    case NUM_BIG_DECIMAL:
4041                    {
4042                            conditionalExpression(0);
4043                            astFactory.addASTChild(currentAST, returnAST);
4044                            annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
4045                            break;
4046                    }
4047                    case AT:
4048                    {
4049                            annotation();
4050                            astFactory.addASTChild(currentAST, returnAST);
4051                            nls();
4052                            annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
4053                            break;
4054                    }
4055                    default:
4056                    {
4057                            throw new NoViableAltException(LT(1), getFilename());
4058                    }
4059                    }
4060                    returnAST = annotationMemberArrayValueInitializer_AST;
4061            }
4062            
4063            public final void superClassClause() throws RecognitionException, TokenStreamException {
4064                    
4065                    returnAST = null;
4066                    ASTPair currentAST = new ASTPair();
4067                    AST superClassClause_AST = null;
4068                    AST c_AST = null;
4069                    Token first = LT(1);
4070                    
4071                    {
4072                    switch ( LA(1)) {
4073                    case LITERAL_extends:
4074                    {
4075                            match(LITERAL_extends);
4076                            nls();
4077                            classOrInterfaceType(false);
4078                            c_AST = (AST)returnAST;
4079                            nls();
4080                            break;
4081                    }
4082                    case LCURLY:
4083                    case LITERAL_implements:
4084                    {
4085                            break;
4086                    }
4087                    default:
4088                    {
4089                            throw new NoViableAltException(LT(1), getFilename());
4090                    }
4091                    }
4092                    }
4093                    if ( inputState.guessing==0 ) {
4094                            superClassClause_AST = (AST)currentAST.root;
4095                            superClassClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(c_AST));
4096                            currentAST.root = superClassClause_AST;
4097                            currentAST.child = superClassClause_AST!=null &&superClassClause_AST.getFirstChild()!=null ?
4098                                    superClassClause_AST.getFirstChild() : superClassClause_AST;
4099                            currentAST.advanceChildToEnd();
4100                    }
4101                    returnAST = superClassClause_AST;
4102            }
4103            
4104            public final void typeParameters() throws RecognitionException, TokenStreamException {
4105                    
4106                    returnAST = null;
4107                    ASTPair currentAST = new ASTPair();
4108                    AST typeParameters_AST = null;
4109                    Token first = LT(1);int currentLtLevel = 0;
4110                    
4111                    if ( inputState.guessing==0 ) {
4112                            currentLtLevel = ltCounter;
4113                    }
4114                    match(LT);
4115                    if ( inputState.guessing==0 ) {
4116                            ltCounter++;
4117                    }
4118                    nls();
4119                    typeParameter();
4120                    astFactory.addASTChild(currentAST, returnAST);
4121                    {
4122                    _loop97:
4123                    do {
4124                            if ((LA(1)==COMMA)) {
4125                                    match(COMMA);
4126                                    nls();
4127                                    typeParameter();
4128                                    astFactory.addASTChild(currentAST, returnAST);
4129                            }
4130                            else {
4131                                    break _loop97;
4132                            }
4133                            
4134                    } while (true);
4135                    }
4136                    nls();
4137                    {
4138                    switch ( LA(1)) {
4139                    case GT:
4140                    case SR:
4141                    case BSR:
4142                    {
4143                            typeArgumentsOrParametersEnd();
4144                            astFactory.addASTChild(currentAST, returnAST);
4145                            break;
4146                    }
4147                    case IDENT:
4148                    case LITERAL_extends:
4149                    case LITERAL_void:
4150                    case LITERAL_boolean:
4151                    case LITERAL_byte:
4152                    case LITERAL_char:
4153                    case LITERAL_short:
4154                    case LITERAL_int:
4155                    case LITERAL_float:
4156                    case LITERAL_long:
4157                    case LITERAL_double:
4158                    case LITERAL_any:
4159                    case LCURLY:
4160                    case LITERAL_implements:
4161                    {
4162                            break;
4163                    }
4164                    default:
4165                    {
4166                            throw new NoViableAltException(LT(1), getFilename());
4167                    }
4168                    }
4169                    }
4170                    if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
4171                      throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel");
4172                    if ( inputState.guessing==0 ) {
4173                            typeParameters_AST = (AST)currentAST.root;
4174                            typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETERS,"TYPE_PARAMETERS",first,LT(1))).add(typeParameters_AST));
4175                            currentAST.root = typeParameters_AST;
4176                            currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ?
4177                                    typeParameters_AST.getFirstChild() : typeParameters_AST;
4178                            currentAST.advanceChildToEnd();
4179                    }
4180                    typeParameters_AST = (AST)currentAST.root;
4181                    returnAST = typeParameters_AST;
4182            }
4183            
4184            public final void implementsClause() throws RecognitionException, TokenStreamException {
4185                    
4186                    returnAST = null;
4187                    ASTPair currentAST = new ASTPair();
4188                    AST implementsClause_AST = null;
4189                    Token  i = null;
4190                    AST i_AST = null;
4191                    Token first = LT(1);
4192                    
4193                    {
4194                    switch ( LA(1)) {
4195                    case LITERAL_implements:
4196                    {
4197                            i = LT(1);
4198                            i_AST = astFactory.create(i);
4199                            match(LITERAL_implements);
4200                            nls();
4201                            classOrInterfaceType(false);
4202                            astFactory.addASTChild(currentAST, returnAST);
4203                            {
4204                            _loop165:
4205                            do {
4206                                    if ((LA(1)==COMMA)) {
4207                                            match(COMMA);
4208                                            nls();
4209                                            classOrInterfaceType(false);
4210                                            astFactory.addASTChild(currentAST, returnAST);
4211                                    }
4212                                    else {
4213                                            break _loop165;
4214                                    }
4215                                    
4216                            } while (true);
4217                            }
4218                            nls();
4219                            break;
4220                    }
4221                    case LCURLY:
4222                    {
4223                            break;
4224                    }
4225                    default:
4226                    {
4227                            throw new NoViableAltException(LT(1), getFilename());
4228                    }
4229                    }
4230                    }
4231                    if ( inputState.guessing==0 ) {
4232                            implementsClause_AST = (AST)currentAST.root;
4233                            implementsClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE",first,LT(1))).add(implementsClause_AST));
4234                            currentAST.root = implementsClause_AST;
4235                            currentAST.child = implementsClause_AST!=null &&implementsClause_AST.getFirstChild()!=null ?
4236                                    implementsClause_AST.getFirstChild() : implementsClause_AST;
4237                            currentAST.advanceChildToEnd();
4238                    }
4239                    implementsClause_AST = (AST)currentAST.root;
4240                    returnAST = implementsClause_AST;
4241            }
4242            
4243            public final void classBlock() throws RecognitionException, TokenStreamException {
4244                    
4245                    returnAST = null;
4246                    ASTPair currentAST = new ASTPair();
4247                    AST classBlock_AST = null;
4248                    Token first = LT(1);
4249                    
4250                    match(LCURLY);
4251                    {
4252                    switch ( LA(1)) {
4253                    case FINAL:
4254                    case ABSTRACT:
4255                    case STRICTFP:
4256                    case LITERAL_static:
4257                    case LITERAL_def:
4258                    case AT:
4259                    case IDENT:
4260                    case LITERAL_class:
4261                    case LITERAL_interface:
4262                    case LITERAL_enum:
4263                    case LITERAL_void:
4264                    case LITERAL_boolean:
4265                    case LITERAL_byte:
4266                    case LITERAL_char:
4267                    case LITERAL_short:
4268                    case LITERAL_int:
4269                    case LITERAL_float:
4270                    case LITERAL_long:
4271                    case LITERAL_double:
4272                    case LITERAL_any:
4273                    case LITERAL_private:
4274                    case LITERAL_public:
4275                    case LITERAL_protected:
4276                    case LITERAL_transient:
4277                    case LITERAL_native:
4278                    case LITERAL_threadsafe:
4279                    case LITERAL_synchronized:
4280                    case LITERAL_volatile:
4281                    case LCURLY:
4282                    {
4283                            classField();
4284                            astFactory.addASTChild(currentAST, returnAST);
4285                            break;
4286                    }
4287                    case RCURLY:
4288                    case SEMI:
4289                    case NLS:
4290                    {
4291                            break;
4292                    }
4293                    default:
4294                    {
4295                            throw new NoViableAltException(LT(1), getFilename());
4296                    }
4297                    }
4298                    }
4299                    {
4300                    _loop109:
4301                    do {
4302                            if ((LA(1)==SEMI||LA(1)==NLS)) {
4303                                    sep();
4304                                    {
4305                                    switch ( LA(1)) {
4306                                    case FINAL:
4307                                    case ABSTRACT:
4308                                    case STRICTFP:
4309                                    case LITERAL_static:
4310                                    case LITERAL_def:
4311                                    case AT:
4312                                    case IDENT:
4313                                    case LITERAL_class:
4314                                    case LITERAL_interface:
4315                                    case LITERAL_enum:
4316                                    case LITERAL_void:
4317                                    case LITERAL_boolean:
4318                                    case LITERAL_byte:
4319                                    case LITERAL_char:
4320                                    case LITERAL_short:
4321                                    case LITERAL_int:
4322                                    case LITERAL_float:
4323                                    case LITERAL_long:
4324                                    case LITERAL_double:
4325                                    case LITERAL_any:
4326                                    case LITERAL_private:
4327                                    case LITERAL_public:
4328                                    case LITERAL_protected:
4329                                    case LITERAL_transient:
4330                                    case LITERAL_native:
4331                                    case LITERAL_threadsafe:
4332                                    case LITERAL_synchronized:
4333                                    case LITERAL_volatile:
4334                                    case LCURLY:
4335                                    {
4336                                            classField();
4337                                            astFactory.addASTChild(currentAST, returnAST);
4338                                            break;
4339                                    }
4340                                    case RCURLY:
4341                                    case SEMI:
4342                                    case NLS:
4343                                    {
4344                                            break;
4345                                    }
4346                                    default:
4347                                    {
4348                                            throw new NoViableAltException(LT(1), getFilename());
4349                                    }
4350                                    }
4351                                    }
4352                            }
4353                            else {
4354                                    break _loop109;
4355                            }
4356                            
4357                    } while (true);
4358                    }
4359                    match(RCURLY);
4360                    if ( inputState.guessing==0 ) {
4361                            classBlock_AST = (AST)currentAST.root;
4362                            classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(classBlock_AST));
4363                            currentAST.root = classBlock_AST;
4364                            currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
4365                                    classBlock_AST.getFirstChild() : classBlock_AST;
4366                            currentAST.advanceChildToEnd();
4367                    }
4368                    classBlock_AST = (AST)currentAST.root;
4369                    returnAST = classBlock_AST;
4370            }
4371            
4372            public final void interfaceExtends() throws RecognitionException, TokenStreamException {
4373                    
4374                    returnAST = null;
4375                    ASTPair currentAST = new ASTPair();
4376                    AST interfaceExtends_AST = null;
4377                    Token  e = null;
4378                    AST e_AST = null;
4379                    Token first = LT(1);
4380                    
4381                    {
4382                    switch ( LA(1)) {
4383                    case LITERAL_extends:
4384                    {
4385                            e = LT(1);
4386                            e_AST = astFactory.create(e);
4387                            match(LITERAL_extends);
4388                            nls();
4389                            classOrInterfaceType(false);
4390                            astFactory.addASTChild(currentAST, returnAST);
4391                            {
4392                            _loop161:
4393                            do {
4394                                    if ((LA(1)==COMMA)) {
4395                                            match(COMMA);
4396                                            nls();
4397                                            classOrInterfaceType(false);
4398                                            astFactory.addASTChild(currentAST, returnAST);
4399                                    }
4400                                    else {
4401                                            break _loop161;
4402                                    }
4403                                    
4404                            } while (true);
4405                            }
4406                            nls();
4407                            break;
4408                    }
4409                    case LCURLY:
4410                    {
4411                            break;
4412                    }
4413                    default:
4414                    {
4415                            throw new NoViableAltException(LT(1), getFilename());
4416                    }
4417                    }
4418                    }
4419                    if ( inputState.guessing==0 ) {
4420                            interfaceExtends_AST = (AST)currentAST.root;
4421                            interfaceExtends_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(interfaceExtends_AST));
4422                            currentAST.root = interfaceExtends_AST;
4423                            currentAST.child = interfaceExtends_AST!=null &&interfaceExtends_AST.getFirstChild()!=null ?
4424                                    interfaceExtends_AST.getFirstChild() : interfaceExtends_AST;
4425                            currentAST.advanceChildToEnd();
4426                    }
4427                    interfaceExtends_AST = (AST)currentAST.root;
4428                    returnAST = interfaceExtends_AST;
4429            }
4430            
4431            public final void interfaceBlock() throws RecognitionException, TokenStreamException {
4432                    
4433                    returnAST = null;
4434                    ASTPair currentAST = new ASTPair();
4435                    AST interfaceBlock_AST = null;
4436                    Token first = LT(1);
4437                    
4438                    match(LCURLY);
4439                    {
4440                    switch ( LA(1)) {
4441                    case FINAL:
4442                    case ABSTRACT:
4443                    case STRICTFP:
4444                    case LITERAL_static:
4445                    case LITERAL_def:
4446                    case AT:
4447                    case IDENT:
4448                    case LITERAL_class:
4449                    case LITERAL_interface:
4450                    case LITERAL_enum:
4451                    case LITERAL_void:
4452                    case LITERAL_boolean:
4453                    case LITERAL_byte:
4454                    case LITERAL_char:
4455                    case LITERAL_short:
4456                    case LITERAL_int:
4457                    case LITERAL_float:
4458                    case LITERAL_long:
4459                    case LITERAL_double:
4460                    case LITERAL_any:
4461                    case LITERAL_private:
4462                    case LITERAL_public:
4463                    case LITERAL_protected:
4464                    case LITERAL_transient:
4465                    case LITERAL_native:
4466                    case LITERAL_threadsafe:
4467                    case LITERAL_synchronized:
4468                    case LITERAL_volatile:
4469                    {
4470                            interfaceField();
4471                            astFactory.addASTChild(currentAST, returnAST);
4472                            break;
4473                    }
4474                    case RCURLY:
4475                    case SEMI:
4476                    case NLS:
4477                    {
4478                            break;
4479                    }
4480                    default:
4481                    {
4482                            throw new NoViableAltException(LT(1), getFilename());
4483                    }
4484                    }
4485                    }
4486                    {
4487                    _loop114:
4488                    do {
4489                            if ((LA(1)==SEMI||LA(1)==NLS)) {
4490                                    sep();
4491                                    {
4492                                    switch ( LA(1)) {
4493                                    case FINAL:
4494                                    case ABSTRACT:
4495                                    case STRICTFP:
4496                                    case LITERAL_static:
4497                                    case LITERAL_def:
4498                                    case AT:
4499                                    case IDENT:
4500                                    case LITERAL_class:
4501                                    case LITERAL_interface:
4502                                    case LITERAL_enum:
4503                                    case LITERAL_void:
4504                                    case LITERAL_boolean:
4505                                    case LITERAL_byte:
4506                                    case LITERAL_char:
4507                                    case LITERAL_short:
4508                                    case LITERAL_int:
4509                                    case LITERAL_float:
4510                                    case LITERAL_long:
4511                                    case LITERAL_double:
4512                                    case LITERAL_any:
4513                                    case LITERAL_private:
4514                                    case LITERAL_public:
4515                                    case LITERAL_protected:
4516                                    case LITERAL_transient:
4517                                    case LITERAL_native:
4518                                    case LITERAL_threadsafe:
4519                                    case LITERAL_synchronized:
4520                                    case LITERAL_volatile:
4521                                    {
4522                                            interfaceField();
4523                                            astFactory.addASTChild(currentAST, returnAST);
4524                                            break;
4525                                    }
4526                                    case RCURLY:
4527                                    case SEMI:
4528                                    case NLS:
4529                                    {
4530                                            break;
4531                                    }
4532                                    default:
4533                                    {
4534                                            throw new NoViableAltException(LT(1), getFilename());
4535                                    }
4536                                    }
4537                                    }
4538                            }
4539                            else {
4540                                    break _loop114;
4541                            }
4542                            
4543                    } while (true);
4544                    }
4545                    match(RCURLY);
4546                    if ( inputState.guessing==0 ) {
4547                            interfaceBlock_AST = (AST)currentAST.root;
4548                            interfaceBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(interfaceBlock_AST));
4549                            currentAST.root = interfaceBlock_AST;
4550                            currentAST.child = interfaceBlock_AST!=null &&interfaceBlock_AST.getFirstChild()!=null ?
4551                                    interfaceBlock_AST.getFirstChild() : interfaceBlock_AST;
4552                            currentAST.advanceChildToEnd();
4553                    }
4554                    interfaceBlock_AST = (AST)currentAST.root;
4555                    returnAST = interfaceBlock_AST;
4556            }
4557            
4558            public final void enumBlock() throws RecognitionException, TokenStreamException {
4559                    
4560                    returnAST = null;
4561                    ASTPair currentAST = new ASTPair();
4562                    AST enumBlock_AST = null;
4563                    Token first = LT(1);
4564                    
4565                    match(LCURLY);
4566                    {
4567                    boolean synPredMatched123 = false;
4568                    if (((LA(1)==AT||LA(1)==IDENT) && (_tokenSet_51.member(LA(2))) && (_tokenSet_52.member(LA(3))))) {
4569                            int _m123 = mark();
4570                            synPredMatched123 = true;
4571                            inputState.guessing++;
4572                            try {
4573                                    {
4574                                    enumConstantsStart();
4575                                    }
4576                            }
4577                            catch (RecognitionException pe) {
4578                                    synPredMatched123 = false;
4579                            }
4580                            rewind(_m123);
4581    inputState.guessing--;
4582                    }
4583                    if ( synPredMatched123 ) {
4584                            enumConstants();
4585                            astFactory.addASTChild(currentAST, returnAST);
4586                    }
4587                    else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_54.member(LA(2))) && (_tokenSet_18.member(LA(3)))) {
4588                            {
4589                            switch ( LA(1)) {
4590                            case FINAL:
4591                            case ABSTRACT:
4592                            case STRICTFP:
4593                            case LITERAL_static:
4594                            case LITERAL_def:
4595                            case AT:
4596                            case IDENT:
4597                            case LITERAL_class:
4598                            case LITERAL_interface:
4599                            case LITERAL_enum:
4600                            case LITERAL_void:
4601                            case LITERAL_boolean:
4602                            case LITERAL_byte:
4603                            case LITERAL_char:
4604                            case LITERAL_short:
4605                            case LITERAL_int:
4606                            case LITERAL_float:
4607                            case LITERAL_long:
4608                            case LITERAL_double:
4609                            case LITERAL_any:
4610                            case LITERAL_private:
4611                            case LITERAL_public:
4612                            case LITERAL_protected:
4613                            case LITERAL_transient:
4614                            case LITERAL_native:
4615                            case LITERAL_threadsafe:
4616                            case LITERAL_synchronized:
4617                            case LITERAL_volatile:
4618                            case LCURLY:
4619                            {
4620                                    classField();
4621                                    astFactory.addASTChild(currentAST, returnAST);
4622                                    break;
4623                            }
4624                            case RCURLY:
4625                            case SEMI:
4626                            case NLS:
4627                            {
4628                                    break;
4629                            }
4630                            default:
4631                            {
4632                                    throw new NoViableAltException(LT(1), getFilename());
4633                            }
4634                            }
4635                            }
4636                    }
4637                    else {
4638                            throw new NoViableAltException(LT(1), getFilename());
4639                    }
4640                    
4641                    }
4642                    {
4643                    _loop127:
4644                    do {
4645                            if ((LA(1)==SEMI||LA(1)==NLS)) {
4646                                    sep();
4647                                    {
4648                                    switch ( LA(1)) {
4649                                    case FINAL:
4650                                    case ABSTRACT:
4651                                    case STRICTFP:
4652                                    case LITERAL_static:
4653                                    case LITERAL_def:
4654                                    case AT:
4655                                    case IDENT:
4656                                    case LITERAL_class:
4657                                    case LITERAL_interface:
4658                                    case LITERAL_enum:
4659                                    case LITERAL_void:
4660                                    case LITERAL_boolean:
4661                                    case LITERAL_byte:
4662                                    case LITERAL_char:
4663                                    case LITERAL_short:
4664                                    case LITERAL_int:
4665                                    case LITERAL_float:
4666                                    case LITERAL_long:
4667                                    case LITERAL_double:
4668                                    case LITERAL_any:
4669                                    case LITERAL_private:
4670                                    case LITERAL_public:
4671                                    case LITERAL_protected:
4672                                    case LITERAL_transient:
4673                                    case LITERAL_native:
4674                                    case LITERAL_threadsafe:
4675                                    case LITERAL_synchronized:
4676                                    case LITERAL_volatile:
4677                                    case LCURLY:
4678                                    {
4679                                            classField();
4680                                            astFactory.addASTChild(currentAST, returnAST);
4681                                            break;
4682                                    }
4683                                    case RCURLY:
4684                                    case SEMI:
4685                                    case NLS:
4686                                    {
4687                                            break;
4688                                    }
4689                                    default:
4690                                    {
4691                                            throw new NoViableAltException(LT(1), getFilename());
4692                                    }
4693                                    }
4694                                    }
4695                            }
4696                            else {
4697                                    break _loop127;
4698                            }
4699                            
4700                    } while (true);
4701                    }
4702                    match(RCURLY);
4703                    if ( inputState.guessing==0 ) {
4704                            enumBlock_AST = (AST)currentAST.root;
4705                            enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(enumBlock_AST));
4706                            currentAST.root = enumBlock_AST;
4707                            currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ?
4708                                    enumBlock_AST.getFirstChild() : enumBlock_AST;
4709                            currentAST.advanceChildToEnd();
4710                    }
4711                    enumBlock_AST = (AST)currentAST.root;
4712                    returnAST = enumBlock_AST;
4713            }
4714            
4715            public final void annotationBlock() throws RecognitionException, TokenStreamException {
4716                    
4717                    returnAST = null;
4718                    ASTPair currentAST = new ASTPair();
4719                    AST annotationBlock_AST = null;
4720                    Token first = LT(1);
4721                    
4722                    match(LCURLY);
4723                    {
4724                    switch ( LA(1)) {
4725                    case FINAL:
4726                    case ABSTRACT:
4727                    case STRICTFP:
4728                    case LITERAL_static:
4729                    case LITERAL_def:
4730                    case AT:
4731                    case IDENT:
4732                    case LITERAL_class:
4733                    case LITERAL_interface:
4734                    case LITERAL_enum:
4735                    case LITERAL_void:
4736                    case LITERAL_boolean:
4737                    case LITERAL_byte:
4738                    case LITERAL_char:
4739                    case LITERAL_short:
4740                    case LITERAL_int:
4741                    case LITERAL_float:
4742                    case LITERAL_long:
4743                    case LITERAL_double:
4744                    case LITERAL_any:
4745                    case LITERAL_private:
4746                    case LITERAL_public:
4747                    case LITERAL_protected:
4748                    case LITERAL_transient:
4749                    case LITERAL_native:
4750                    case LITERAL_threadsafe:
4751                    case LITERAL_synchronized:
4752                    case LITERAL_volatile:
4753                    {
4754                            annotationField();
4755                            astFactory.addASTChild(currentAST, returnAST);
4756                            break;
4757                    }
4758                    case RCURLY:
4759                    case SEMI:
4760                    case NLS:
4761                    {
4762                            break;
4763                    }
4764                    default:
4765                    {
4766                            throw new NoViableAltException(LT(1), getFilename());
4767                    }
4768                    }
4769                    }
4770                    {
4771                    _loop119:
4772                    do {
4773                            if ((LA(1)==SEMI||LA(1)==NLS)) {
4774                                    sep();
4775                                    {
4776                                    switch ( LA(1)) {
4777                                    case FINAL:
4778                                    case ABSTRACT:
4779                                    case STRICTFP:
4780                                    case LITERAL_static:
4781                                    case LITERAL_def:
4782                                    case AT:
4783                                    case IDENT:
4784                                    case LITERAL_class:
4785                                    case LITERAL_interface:
4786                                    case LITERAL_enum:
4787                                    case LITERAL_void:
4788                                    case LITERAL_boolean:
4789                                    case LITERAL_byte:
4790                                    case LITERAL_char:
4791                                    case LITERAL_short:
4792                                    case LITERAL_int:
4793                                    case LITERAL_float:
4794                                    case LITERAL_long:
4795                                    case LITERAL_double:
4796                                    case LITERAL_any:
4797                                    case LITERAL_private:
4798                                    case LITERAL_public:
4799                                    case LITERAL_protected:
4800                                    case LITERAL_transient:
4801                                    case LITERAL_native:
4802                                    case LITERAL_threadsafe:
4803                                    case LITERAL_synchronized:
4804                                    case LITERAL_volatile:
4805                                    {
4806                                            annotationField();
4807                                            astFactory.addASTChild(currentAST, returnAST);
4808                                            break;
4809                                    }
4810                                    case RCURLY:
4811                                    case SEMI:
4812                                    case NLS:
4813                                    {
4814                                            break;
4815                                    }
4816                                    default:
4817                                    {
4818                                            throw new NoViableAltException(LT(1), getFilename());
4819                                    }
4820                                    }
4821                                    }
4822                            }
4823                            else {
4824                                    break _loop119;
4825                            }
4826                            
4827                    } while (true);
4828                    }
4829                    match(RCURLY);
4830                    if ( inputState.guessing==0 ) {
4831                            annotationBlock_AST = (AST)currentAST.root;
4832                            annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(annotationBlock_AST));
4833                            currentAST.root = annotationBlock_AST;
4834                            currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ?
4835                                    annotationBlock_AST.getFirstChild() : annotationBlock_AST;
4836                            currentAST.advanceChildToEnd();
4837                    }
4838                    annotationBlock_AST = (AST)currentAST.root;
4839                    returnAST = annotationBlock_AST;
4840            }
4841            
4842            public final void typeParameter() throws RecognitionException, TokenStreamException {
4843                    
4844                    returnAST = null;
4845                    ASTPair currentAST = new ASTPair();
4846                    AST typeParameter_AST = null;
4847                    Token  id = null;
4848                    AST id_AST = null;
4849                    Token first = LT(1);
4850                    
4851                    {
4852                    id = LT(1);
4853                    id_AST = astFactory.create(id);
4854                    astFactory.addASTChild(currentAST, id_AST);
4855                    match(IDENT);
4856                    }
4857                    {
4858                    if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==NLS) && (_tokenSet_55.member(LA(3)))) {
4859                            typeParameterBounds();
4860                            astFactory.addASTChild(currentAST, returnAST);
4861                    }
4862                    else if ((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2))) && (_tokenSet_58.member(LA(3)))) {
4863                    }
4864                    else {
4865                            throw new NoViableAltException(LT(1), getFilename());
4866                    }
4867                    
4868                    }
4869                    if ( inputState.guessing==0 ) {
4870                            typeParameter_AST = (AST)currentAST.root;
4871                            typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETER,"TYPE_PARAMETER",first,LT(1))).add(typeParameter_AST));
4872                            currentAST.root = typeParameter_AST;
4873                            currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ?
4874                                    typeParameter_AST.getFirstChild() : typeParameter_AST;
4875                            currentAST.advanceChildToEnd();
4876                    }
4877                    typeParameter_AST = (AST)currentAST.root;
4878                    returnAST = typeParameter_AST;
4879            }
4880            
4881            public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
4882                    
4883                    returnAST = null;
4884                    ASTPair currentAST = new ASTPair();
4885                    AST typeParameterBounds_AST = null;
4886                    Token first = LT(1);
4887                    
4888                    match(LITERAL_extends);
4889                    nls();
4890                    classOrInterfaceType(false);
4891                    astFactory.addASTChild(currentAST, returnAST);
4892                    {
4893                    _loop104:
4894                    do {
4895                            if ((LA(1)==BAND)) {
4896                                    match(BAND);
4897                                    nls();
4898                                    classOrInterfaceType(false);
4899                                    astFactory.addASTChild(currentAST, returnAST);
4900                            }
4901                            else {
4902                                    break _loop104;
4903                            }
4904                            
4905                    } while (true);
4906                    }
4907                    if ( inputState.guessing==0 ) {
4908                            typeParameterBounds_AST = (AST)currentAST.root;
4909                            typeParameterBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS",first,LT(1))).add(typeParameterBounds_AST));
4910                            currentAST.root = typeParameterBounds_AST;
4911                            currentAST.child = typeParameterBounds_AST!=null &&typeParameterBounds_AST.getFirstChild()!=null ?
4912                                    typeParameterBounds_AST.getFirstChild() : typeParameterBounds_AST;
4913                            currentAST.advanceChildToEnd();
4914                    }
4915                    typeParameterBounds_AST = (AST)currentAST.root;
4916                    returnAST = typeParameterBounds_AST;
4917            }
4918            
4919            public final void classField() throws RecognitionException, TokenStreamException {
4920                    
4921                    returnAST = null;
4922                    ASTPair currentAST = new ASTPair();
4923                    AST classField_AST = null;
4924                    AST mc_AST = null;
4925                    AST ctor_AST = null;
4926                    AST d_AST = null;
4927                    AST mods_AST = null;
4928                    AST td_AST = null;
4929                    AST s3_AST = null;
4930                    AST s4_AST = null;
4931                    Token first = LT(1);
4932                    
4933                    boolean synPredMatched168 = false;
4934                    if (((_tokenSet_59.member(LA(1))) && (_tokenSet_60.member(LA(2))) && (_tokenSet_61.member(LA(3))))) {
4935                            int _m168 = mark();
4936                            synPredMatched168 = true;
4937                            inputState.guessing++;
4938                            try {
4939                                    {
4940                                    constructorStart();
4941                                    }
4942                            }
4943                            catch (RecognitionException pe) {
4944                                    synPredMatched168 = false;
4945                            }
4946                            rewind(_m168);
4947    inputState.guessing--;
4948                    }
4949                    if ( synPredMatched168 ) {
4950                            modifiersOpt();
4951                            mc_AST = (AST)returnAST;
4952                            constructorDefinition(mc_AST);
4953                            ctor_AST = (AST)returnAST;
4954                            if ( inputState.guessing==0 ) {
4955                                    classField_AST = (AST)currentAST.root;
4956                                    classField_AST = ctor_AST;
4957                                    currentAST.root = classField_AST;
4958                                    currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
4959                                            classField_AST.getFirstChild() : classField_AST;
4960                                    currentAST.advanceChildToEnd();
4961                            }
4962                    }
4963                    else {
4964                            boolean synPredMatched170 = false;
4965                            if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))) && (_tokenSet_62.member(LA(3))))) {
4966                                    int _m170 = mark();
4967                                    synPredMatched170 = true;
4968                                    inputState.guessing++;
4969                                    try {
4970                                            {
4971                                            declarationStart();
4972                                            }
4973                                    }
4974                                    catch (RecognitionException pe) {
4975                                            synPredMatched170 = false;
4976                                    }
4977                                    rewind(_m170);
4978    inputState.guessing--;
4979                            }
4980                            if ( synPredMatched170 ) {
4981                                    declaration();
4982                                    d_AST = (AST)returnAST;
4983                                    if ( inputState.guessing==0 ) {
4984                                            classField_AST = (AST)currentAST.root;
4985                                            classField_AST = d_AST;
4986                                            currentAST.root = classField_AST;
4987                                            currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
4988                                                    classField_AST.getFirstChild() : classField_AST;
4989                                            currentAST.advanceChildToEnd();
4990                                    }
4991                            }
4992                            else {
4993                                    boolean synPredMatched172 = false;
4994                                    if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))) && (_tokenSet_23.member(LA(3))))) {
4995                                            int _m172 = mark();
4996                                            synPredMatched172 = true;
4997                                            inputState.guessing++;
4998                                            try {
4999                                                    {
5000                                                    typeDeclarationStart();
5001                                                    }
5002                                            }
5003                                            catch (RecognitionException pe) {
5004                                                    synPredMatched172 = false;
5005                                            }
5006                                            rewind(_m172);
5007    inputState.guessing--;
5008                                    }
5009                                    if ( synPredMatched172 ) {
5010                                            modifiersOpt();
5011                                            mods_AST = (AST)returnAST;
5012                                            {
5013                                            typeDefinitionInternal(mods_AST);
5014                                            td_AST = (AST)returnAST;
5015                                            if ( inputState.guessing==0 ) {
5016                                                    classField_AST = (AST)currentAST.root;
5017                                                    classField_AST = td_AST;
5018                                                    currentAST.root = classField_AST;
5019                                                    currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5020                                                            classField_AST.getFirstChild() : classField_AST;
5021                                                    currentAST.advanceChildToEnd();
5022                                            }
5023                                            }
5024                                    }
5025                                    else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) {
5026                                            match(LITERAL_static);
5027                                            compoundStatement();
5028                                            s3_AST = (AST)returnAST;
5029                                            if ( inputState.guessing==0 ) {
5030                                                    classField_AST = (AST)currentAST.root;
5031                                                    classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(STATIC_INIT,"STATIC_INIT",first,LT(1))).add(s3_AST));
5032                                                    currentAST.root = classField_AST;
5033                                                    currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5034                                                            classField_AST.getFirstChild() : classField_AST;
5035                                                    currentAST.advanceChildToEnd();
5036                                            }
5037                                    }
5038                                    else if ((LA(1)==LCURLY)) {
5039                                            compoundStatement();
5040                                            s4_AST = (AST)returnAST;
5041                                            if ( inputState.guessing==0 ) {
5042                                                    classField_AST = (AST)currentAST.root;
5043                                                    classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(INSTANCE_INIT,"INSTANCE_INIT",first,LT(1))).add(s4_AST));
5044                                                    currentAST.root = classField_AST;
5045                                                    currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5046                                                            classField_AST.getFirstChild() : classField_AST;
5047                                                    currentAST.advanceChildToEnd();
5048                                            }
5049                                    }
5050                                    else {
5051                                            throw new NoViableAltException(LT(1), getFilename());
5052                                    }
5053                                    }}
5054                                    returnAST = classField_AST;
5055                            }
5056                            
5057            public final void interfaceField() throws RecognitionException, TokenStreamException {
5058                    
5059                    returnAST = null;
5060                    ASTPair currentAST = new ASTPair();
5061                    AST interfaceField_AST = null;
5062                    AST d_AST = null;
5063                    AST mods_AST = null;
5064                    AST td_AST = null;
5065                    
5066                    boolean synPredMatched176 = false;
5067                    if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))) && (_tokenSet_62.member(LA(3))))) {
5068                            int _m176 = mark();
5069                            synPredMatched176 = true;
5070                            inputState.guessing++;
5071                            try {
5072                                    {
5073                                    declarationStart();
5074                                    }
5075                            }
5076                            catch (RecognitionException pe) {
5077                                    synPredMatched176 = false;
5078                            }
5079                            rewind(_m176);
5080    inputState.guessing--;
5081                    }
5082                    if ( synPredMatched176 ) {
5083                            declaration();
5084                            d_AST = (AST)returnAST;
5085                            if ( inputState.guessing==0 ) {
5086                                    interfaceField_AST = (AST)currentAST.root;
5087                                    interfaceField_AST = d_AST;
5088                                    currentAST.root = interfaceField_AST;
5089                                    currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
5090                                            interfaceField_AST.getFirstChild() : interfaceField_AST;
5091                                    currentAST.advanceChildToEnd();
5092                            }
5093                    }
5094                    else {
5095                            boolean synPredMatched178 = false;
5096                            if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))) && (_tokenSet_23.member(LA(3))))) {
5097                                    int _m178 = mark();
5098                                    synPredMatched178 = true;
5099                                    inputState.guessing++;
5100                                    try {
5101                                            {
5102                                            typeDeclarationStart();
5103                                            }
5104                                    }
5105                                    catch (RecognitionException pe) {
5106                                            synPredMatched178 = false;
5107                                    }
5108                                    rewind(_m178);
5109    inputState.guessing--;
5110                            }
5111                            if ( synPredMatched178 ) {
5112                                    modifiersOpt();
5113                                    mods_AST = (AST)returnAST;
5114                                    {
5115                                    typeDefinitionInternal(mods_AST);
5116                                    td_AST = (AST)returnAST;
5117                                    if ( inputState.guessing==0 ) {
5118                                            interfaceField_AST = (AST)currentAST.root;
5119                                            interfaceField_AST = td_AST;
5120                                            currentAST.root = interfaceField_AST;
5121                                            currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
5122                                                    interfaceField_AST.getFirstChild() : interfaceField_AST;
5123                                            currentAST.advanceChildToEnd();
5124                                    }
5125                                    }
5126                            }
5127                            else {
5128                                    throw new NoViableAltException(LT(1), getFilename());
5129                            }
5130                            }
5131                            returnAST = interfaceField_AST;
5132                    }
5133                    
5134            public final void annotationField() throws RecognitionException, TokenStreamException {
5135                    
5136                    returnAST = null;
5137                    ASTPair currentAST = new ASTPair();
5138                    AST annotationField_AST = null;
5139                    AST mods_AST = null;
5140                    AST td_AST = null;
5141                    AST t_AST = null;
5142                    Token  i = null;
5143                    AST i_AST = null;
5144                    AST amvi_AST = null;
5145                    AST v_AST = null;
5146                    Token first = LT(1);
5147                    
5148                    modifiersOpt();
5149                    mods_AST = (AST)returnAST;
5150                    {
5151                    switch ( LA(1)) {
5152                    case AT:
5153                    case LITERAL_class:
5154                    case LITERAL_interface:
5155                    case LITERAL_enum:
5156                    {
5157                            typeDefinitionInternal(mods_AST);
5158                            td_AST = (AST)returnAST;
5159                            if ( inputState.guessing==0 ) {
5160                                    annotationField_AST = (AST)currentAST.root;
5161                                    annotationField_AST = td_AST;
5162                                    currentAST.root = annotationField_AST;
5163                                    currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
5164                                            annotationField_AST.getFirstChild() : annotationField_AST;
5165                                    currentAST.advanceChildToEnd();
5166                            }
5167                            break;
5168                    }
5169                    case IDENT:
5170                    case LITERAL_void:
5171                    case LITERAL_boolean:
5172                    case LITERAL_byte:
5173                    case LITERAL_char:
5174                    case LITERAL_short:
5175                    case LITERAL_int:
5176                    case LITERAL_float:
5177                    case LITERAL_long:
5178                    case LITERAL_double:
5179                    case LITERAL_any:
5180                    {
5181                            typeSpec(false);
5182                            t_AST = (AST)returnAST;
5183                            {
5184                            boolean synPredMatched138 = false;
5185                            if (((LA(1)==IDENT) && (LA(2)==LPAREN) && (LA(3)==RPAREN))) {
5186                                    int _m138 = mark();
5187                                    synPredMatched138 = true;
5188                                    inputState.guessing++;
5189                                    try {
5190                                            {
5191                                            match(IDENT);
5192                                            match(LPAREN);
5193                                            }
5194                                    }
5195                                    catch (RecognitionException pe) {
5196                                            synPredMatched138 = false;
5197                                    }
5198                                    rewind(_m138);
5199    inputState.guessing--;
5200                            }
5201                            if ( synPredMatched138 ) {
5202                                    i = LT(1);
5203                                    i_AST = astFactory.create(i);
5204                                    match(IDENT);
5205                                    match(LPAREN);
5206                                    match(RPAREN);
5207                                    {
5208                                    switch ( LA(1)) {
5209                                    case LITERAL_default:
5210                                    {
5211                                            match(LITERAL_default);
5212                                            nls();
5213                                            annotationMemberValueInitializer();
5214                                            amvi_AST = (AST)returnAST;
5215                                            break;
5216                                    }
5217                                    case RCURLY:
5218                                    case SEMI:
5219                                    case NLS:
5220                                    {
5221                                            break;
5222                                    }
5223                                    default:
5224                                    {
5225                                            throw new NoViableAltException(LT(1), getFilename());
5226                                    }
5227                                    }
5228                                    }
5229                                    if ( inputState.guessing==0 ) {
5230                                            annotationField_AST = (AST)currentAST.root;
5231                                            annotationField_AST =
5232                                            (AST)astFactory.make( (new ASTArray(5)).add(create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF",first,LT(1))).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t_AST))).add(i_AST).add(amvi_AST));
5233                                            currentAST.root = annotationField_AST;
5234                                            currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
5235                                                    annotationField_AST.getFirstChild() : annotationField_AST;
5236                                            currentAST.advanceChildToEnd();
5237                                    }
5238                            }
5239                            else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (_tokenSet_63.member(LA(2))) && (_tokenSet_64.member(LA(3)))) {
5240                                    variableDefinitions(mods_AST,t_AST);
5241                                    v_AST = (AST)returnAST;
5242                                    if ( inputState.guessing==0 ) {
5243                                            annotationField_AST = (AST)currentAST.root;
5244                                            annotationField_AST = v_AST;
5245                                            currentAST.root = annotationField_AST;
5246                                            currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
5247                                                    annotationField_AST.getFirstChild() : annotationField_AST;
5248                                            currentAST.advanceChildToEnd();
5249                                    }
5250                            }
5251                            else {
5252                                    throw new NoViableAltException(LT(1), getFilename());
5253                            }
5254                            
5255                            }
5256                            break;
5257                    }
5258                    default:
5259                    {
5260                            throw new NoViableAltException(LT(1), getFilename());
5261                    }
5262                    }
5263                    }
5264                    returnAST = annotationField_AST;
5265            }
5266            
5267    /** Guard for enumConstants.  */
5268            public final void enumConstantsStart() throws RecognitionException, TokenStreamException {
5269                    
5270                    returnAST = null;
5271                    ASTPair currentAST = new ASTPair();
5272                    AST enumConstantsStart_AST = null;
5273                    
5274                    enumConstant();
5275                    astFactory.addASTChild(currentAST, returnAST);
5276                    {
5277                    switch ( LA(1)) {
5278                    case COMMA:
5279                    {
5280                            AST tmp129_AST = null;
5281                            tmp129_AST = astFactory.create(LT(1));
5282                            astFactory.addASTChild(currentAST, tmp129_AST);
5283                            match(COMMA);
5284                            break;
5285                    }
5286                    case SEMI:
5287                    {
5288                            AST tmp130_AST = null;
5289                            tmp130_AST = astFactory.create(LT(1));
5290                            astFactory.addASTChild(currentAST, tmp130_AST);
5291                            match(SEMI);
5292                            break;
5293                    }
5294                    case NLS:
5295                    {
5296                            AST tmp131_AST = null;
5297                            tmp131_AST = astFactory.create(LT(1));
5298                            astFactory.addASTChild(currentAST, tmp131_AST);
5299                            match(NLS);
5300                            break;
5301                    }
5302                    case RCURLY:
5303                    {
5304                            AST tmp132_AST = null;
5305                            tmp132_AST = astFactory.create(LT(1));
5306                            astFactory.addASTChild(currentAST, tmp132_AST);
5307                            match(RCURLY);
5308                            break;
5309                    }
5310                    default:
5311                    {
5312                            throw new NoViableAltException(LT(1), getFilename());
5313                    }
5314                    }
5315                    }
5316                    enumConstantsStart_AST = (AST)currentAST.root;
5317                    returnAST = enumConstantsStart_AST;
5318            }
5319            
5320    /** Comma-separated list of one or more enum constant definitions.  */
5321            public final void enumConstants() throws RecognitionException, TokenStreamException {
5322                    
5323                    returnAST = null;
5324                    ASTPair currentAST = new ASTPair();
5325                    AST enumConstants_AST = null;
5326                    
5327                    enumConstant();
5328                    astFactory.addASTChild(currentAST, returnAST);
5329                    {
5330                    _loop132:
5331                    do {
5332                            if ((LA(1)==COMMA) && (_tokenSet_65.member(LA(2))) && (_tokenSet_66.member(LA(3)))) {
5333                                    match(COMMA);
5334                                    nls();
5335                                    enumConstant();
5336                                    astFactory.addASTChild(currentAST, returnAST);
5337                            }
5338                            else {
5339                                    break _loop132;
5340                            }
5341                            
5342                    } while (true);
5343                    }
5344                    {
5345                    switch ( LA(1)) {
5346                    case COMMA:
5347                    {
5348                            match(COMMA);
5349                            nls();
5350                            break;
5351                    }
5352                    case RCURLY:
5353                    case SEMI:
5354                    case NLS:
5355                    {
5356                            break;
5357                    }
5358                    default:
5359                    {
5360                            throw new NoViableAltException(LT(1), getFilename());
5361                    }
5362                    }
5363                    }
5364                    enumConstants_AST = (AST)currentAST.root;
5365                    returnAST = enumConstants_AST;
5366            }
5367            
5368            public final void enumConstant() throws RecognitionException, TokenStreamException {
5369                    
5370                    returnAST = null;
5371                    ASTPair currentAST = new ASTPair();
5372                    AST enumConstant_AST = null;
5373                    AST an_AST = null;
5374                    Token  i = null;
5375                    AST i_AST = null;
5376                    AST a_AST = null;
5377                    AST b_AST = null;
5378                    Token first = LT(1);
5379                    
5380                    annotationsOpt();
5381                    an_AST = (AST)returnAST;
5382                    i = LT(1);
5383                    i_AST = astFactory.create(i);
5384                    match(IDENT);
5385                    {
5386                    switch ( LA(1)) {
5387                    case LPAREN:
5388                    {
5389                            match(LPAREN);
5390                            argList();
5391                            a_AST = (AST)returnAST;
5392                            match(RPAREN);
5393                            break;
5394                    }
5395                    case COMMA:
5396                    case LCURLY:
5397                    case RCURLY:
5398                    case SEMI:
5399                    case NLS:
5400                    {
5401                            break;
5402                    }
5403                    default:
5404                    {
5405                            throw new NoViableAltException(LT(1), getFilename());
5406                    }
5407                    }
5408                    }
5409                    {
5410                    switch ( LA(1)) {
5411                    case LCURLY:
5412                    {
5413                            enumConstantBlock();
5414                            b_AST = (AST)returnAST;
5415                            break;
5416                    }
5417                    case COMMA:
5418                    case RCURLY:
5419                    case SEMI:
5420                    case NLS:
5421                    {
5422                            break;
5423                    }
5424                    default:
5425                    {
5426                            throw new NoViableAltException(LT(1), getFilename());
5427                    }
5428                    }
5429                    }
5430                    if ( inputState.guessing==0 ) {
5431                            enumConstant_AST = (AST)currentAST.root;
5432                            enumConstant_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF",first,LT(1))).add(an_AST).add(i_AST).add(a_AST).add(b_AST));
5433                            currentAST.root = enumConstant_AST;
5434                            currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ?
5435                                    enumConstant_AST.getFirstChild() : enumConstant_AST;
5436                            currentAST.advanceChildToEnd();
5437                    }
5438                    returnAST = enumConstant_AST;
5439            }
5440            
5441            public final void argList() throws RecognitionException, TokenStreamException {
5442                    
5443                    returnAST = null;
5444                    ASTPair currentAST = new ASTPair();
5445                    AST argList_AST = null;
5446                    Token first = LT(1); boolean hl = false, hl2;
5447                    
5448                    {
5449                    switch ( LA(1)) {
5450                    case FINAL:
5451                    case ABSTRACT:
5452                    case UNUSED_DO:
5453                    case STRICTFP:
5454                    case LITERAL_static:
5455                    case LITERAL_def:
5456                    case AT:
5457                    case IDENT:
5458                    case LBRACK:
5459                    case LPAREN:
5460                    case LITERAL_class:
5461                    case LITERAL_super:
5462                    case LITERAL_void:
5463                    case LITERAL_boolean:
5464                    case LITERAL_byte:
5465                    case LITERAL_char:
5466                    case LITERAL_short:
5467                    case LITERAL_int:
5468                    case LITERAL_float:
5469                    case LITERAL_long:
5470                    case LITERAL_double:
5471                    case LITERAL_any:
5472                    case STAR:
5473                    case LITERAL_as:
5474                    case LITERAL_private:
5475                    case LITERAL_public:
5476                    case LITERAL_protected:
5477                    case LITERAL_transient:
5478                    case LITERAL_native:
5479                    case LITERAL_threadsafe:
5480                    case LITERAL_synchronized:
5481                    case LITERAL_volatile:
5482                    case LCURLY:
5483                    case LITERAL_this:
5484                    case STRING_LITERAL:
5485                    case LITERAL_if:
5486                    case LITERAL_else:
5487                    case LITERAL_while:
5488                    case LITERAL_switch:
5489                    case LITERAL_for:
5490                    case LITERAL_in:
5491                    case LITERAL_return:
5492                    case LITERAL_break:
5493                    case LITERAL_continue:
5494                    case LITERAL_throw:
5495                    case LITERAL_assert:
5496                    case PLUS:
5497                    case MINUS:
5498                    case LITERAL_try:
5499                    case LITERAL_finally:
5500                    case LITERAL_catch:
5501                    case INC:
5502                    case DEC:
5503                    case BNOT:
5504                    case LNOT:
5505                    case DOLLAR:
5506                    case STRING_CTOR_START:
5507                    case LITERAL_new:
5508                    case LITERAL_true:
5509                    case LITERAL_false:
5510                    case LITERAL_null:
5511                    case NUM_INT:
5512                    case NUM_FLOAT:
5513                    case NUM_LONG:
5514                    case NUM_DOUBLE:
5515                    case NUM_BIG_INT:
5516                    case NUM_BIG_DECIMAL:
5517                    {
5518                            hl=argument();
5519                            astFactory.addASTChild(currentAST, returnAST);
5520                            {
5521                            _loop446:
5522                            do {
5523                                    if ((LA(1)==COMMA) && (_tokenSet_67.member(LA(2))) && (_tokenSet_68.member(LA(3)))) {
5524                                            match(COMMA);
5525                                            hl2=argument();
5526                                            astFactory.addASTChild(currentAST, returnAST);
5527                                            if ( inputState.guessing==0 ) {
5528                                                    hl |= hl2;
5529                                            }
5530                                    }
5531                                    else {
5532                                            break _loop446;
5533                                    }
5534                                    
5535                            } while (true);
5536                            }
5537                            if ( inputState.guessing==0 ) {
5538                                    argList_AST = (AST)currentAST.root;
5539                                    argList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ELIST,"ELIST",first,LT(1))).add(argList_AST));
5540                                    currentAST.root = argList_AST;
5541                                    currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
5542                                            argList_AST.getFirstChild() : argList_AST;
5543                                    currentAST.advanceChildToEnd();
5544                            }
5545                            break;
5546                    }
5547                    case RBRACK:
5548                    case COMMA:
5549                    case RPAREN:
5550                    {
5551                            if ( inputState.guessing==0 ) {
5552                                    argList_AST = (AST)currentAST.root;
5553                                    argList_AST = create(ELIST,"ELIST",first,LT(1));
5554                                    currentAST.root = argList_AST;
5555                                    currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
5556                                            argList_AST.getFirstChild() : argList_AST;
5557                                    currentAST.advanceChildToEnd();
5558                            }
5559                            break;
5560                    }
5561                    default:
5562                    {
5563                            throw new NoViableAltException(LT(1), getFilename());
5564                    }
5565                    }
5566                    }
5567                    {
5568                    switch ( LA(1)) {
5569                    case COMMA:
5570                    {
5571                            match(COMMA);
5572                            break;
5573                    }
5574                    case RBRACK:
5575                    case RPAREN:
5576                    {
5577                            break;
5578                    }
5579                    default:
5580                    {
5581                            throw new NoViableAltException(LT(1), getFilename());
5582                    }
5583                    }
5584                    }
5585                    if ( inputState.guessing==0 ) {
5586                            argListHasLabels = hl;
5587                    }
5588                    argList_AST = (AST)currentAST.root;
5589                    returnAST = argList_AST;
5590            }
5591            
5592            public final void enumConstantBlock() throws RecognitionException, TokenStreamException {
5593                    
5594                    returnAST = null;
5595                    ASTPair currentAST = new ASTPair();
5596                    AST enumConstantBlock_AST = null;
5597                    Token first = LT(1);
5598                    
5599                    match(LCURLY);
5600                    {
5601                    switch ( LA(1)) {
5602                    case FINAL:
5603                    case ABSTRACT:
5604                    case STRICTFP:
5605                    case LITERAL_static:
5606                    case LITERAL_def:
5607                    case AT:
5608                    case IDENT:
5609                    case LITERAL_class:
5610                    case LITERAL_interface:
5611                    case LITERAL_enum:
5612                    case LT:
5613                    case LITERAL_void:
5614                    case LITERAL_boolean:
5615                    case LITERAL_byte:
5616                    case LITERAL_char:
5617                    case LITERAL_short:
5618                    case LITERAL_int:
5619                    case LITERAL_float:
5620                    case LITERAL_long:
5621                    case LITERAL_double:
5622                    case LITERAL_any:
5623                    case LITERAL_private:
5624                    case LITERAL_public:
5625                    case LITERAL_protected:
5626                    case LITERAL_transient:
5627                    case LITERAL_native:
5628                    case LITERAL_threadsafe:
5629                    case LITERAL_synchronized:
5630                    case LITERAL_volatile:
5631                    case LCURLY:
5632                    {
5633                            enumConstantField();
5634                            astFactory.addASTChild(currentAST, returnAST);
5635                            break;
5636                    }
5637                    case RCURLY:
5638                    case SEMI:
5639                    case NLS:
5640                    {
5641                            break;
5642                    }
5643                    default:
5644                    {
5645                            throw new NoViableAltException(LT(1), getFilename());
5646                    }
5647                    }
5648                    }
5649                    {
5650                    _loop147:
5651                    do {
5652                            if ((LA(1)==SEMI||LA(1)==NLS)) {
5653                                    sep();
5654                                    {
5655                                    switch ( LA(1)) {
5656                                    case FINAL:
5657                                    case ABSTRACT:
5658                                    case STRICTFP:
5659                                    case LITERAL_static:
5660                                    case LITERAL_def:
5661                                    case AT:
5662                                    case IDENT:
5663                                    case LITERAL_class:
5664                                    case LITERAL_interface:
5665                                    case LITERAL_enum:
5666                                    case LT:
5667                                    case LITERAL_void:
5668                                    case LITERAL_boolean:
5669                                    case LITERAL_byte:
5670                                    case LITERAL_char:
5671                                    case LITERAL_short:
5672                                    case LITERAL_int:
5673                                    case LITERAL_float:
5674                                    case LITERAL_long:
5675                                    case LITERAL_double:
5676                                    case LITERAL_any:
5677                                    case LITERAL_private:
5678                                    case LITERAL_public:
5679                                    case LITERAL_protected:
5680                                    case LITERAL_transient:
5681                                    case LITERAL_native:
5682                                    case LITERAL_threadsafe:
5683                                    case LITERAL_synchronized:
5684                                    case LITERAL_volatile:
5685                                    case LCURLY:
5686                                    {
5687                                            enumConstantField();
5688                                            astFactory.addASTChild(currentAST, returnAST);
5689                                            break;
5690                                    }
5691                                    case RCURLY:
5692                                    case SEMI:
5693                                    case NLS:
5694                                    {
5695                                            break;
5696                                    }
5697                                    default:
5698                                    {
5699                                            throw new NoViableAltException(LT(1), getFilename());
5700                                    }
5701                                    }
5702                                    }
5703                            }
5704                            else {
5705                                    break _loop147;
5706                            }
5707                            
5708                    } while (true);
5709                    }
5710                    match(RCURLY);
5711                    if ( inputState.guessing==0 ) {
5712                            enumConstantBlock_AST = (AST)currentAST.root;
5713                            enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(enumConstantBlock_AST));
5714                            currentAST.root = enumConstantBlock_AST;
5715                            currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ?
5716                                    enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST;
5717                            currentAST.advanceChildToEnd();
5718                    }
5719                    enumConstantBlock_AST = (AST)currentAST.root;
5720                    returnAST = enumConstantBlock_AST;
5721            }
5722            
5723            public final void enumConstantField() throws RecognitionException, TokenStreamException {
5724                    
5725                    returnAST = null;
5726                    ASTPair currentAST = new ASTPair();
5727                    AST enumConstantField_AST = null;
5728                    AST mods_AST = null;
5729                    AST td_AST = null;
5730                    AST tp_AST = null;
5731                    AST t_AST = null;
5732                    AST param_AST = null;
5733                    AST tc_AST = null;
5734                    AST s2_AST = null;
5735                    AST v_AST = null;
5736                    AST s4_AST = null;
5737                    Token first = LT(1);
5738                    
5739                    switch ( LA(1)) {
5740                    case FINAL:
5741                    case ABSTRACT:
5742                    case STRICTFP:
5743                    case LITERAL_static:
5744                    case LITERAL_def:
5745                    case AT:
5746                    case IDENT:
5747                    case LITERAL_class:
5748                    case LITERAL_interface:
5749                    case LITERAL_enum:
5750                    case LT:
5751                    case LITERAL_void:
5752                    case LITERAL_boolean:
5753                    case LITERAL_byte:
5754                    case LITERAL_char:
5755                    case LITERAL_short:
5756                    case LITERAL_int:
5757                    case LITERAL_float:
5758                    case LITERAL_long:
5759                    case LITERAL_double:
5760                    case LITERAL_any:
5761                    case LITERAL_private:
5762                    case LITERAL_public:
5763                    case LITERAL_protected:
5764                    case LITERAL_transient:
5765                    case LITERAL_native:
5766                    case LITERAL_threadsafe:
5767                    case LITERAL_synchronized:
5768                    case LITERAL_volatile:
5769                    {
5770                            modifiersOpt();
5771                            mods_AST = (AST)returnAST;
5772                            {
5773                            switch ( LA(1)) {
5774                            case AT:
5775                            case LITERAL_class:
5776                            case LITERAL_interface:
5777                            case LITERAL_enum:
5778                            {
5779                                    typeDefinitionInternal(mods_AST);
5780                                    td_AST = (AST)returnAST;
5781                                    if ( inputState.guessing==0 ) {
5782                                            enumConstantField_AST = (AST)currentAST.root;
5783                                            enumConstantField_AST = td_AST;
5784                                            currentAST.root = enumConstantField_AST;
5785                                            currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
5786                                                    enumConstantField_AST.getFirstChild() : enumConstantField_AST;
5787                                            currentAST.advanceChildToEnd();
5788                                    }
5789                                    break;
5790                            }
5791                            case IDENT:
5792                            case LT:
5793                            case LITERAL_void:
5794                            case LITERAL_boolean:
5795                            case LITERAL_byte:
5796                            case LITERAL_char:
5797                            case LITERAL_short:
5798                            case LITERAL_int:
5799                            case LITERAL_float:
5800                            case LITERAL_long:
5801                            case LITERAL_double:
5802                            case LITERAL_any:
5803                            {
5804                                    {
5805                                    switch ( LA(1)) {
5806                                    case LT:
5807                                    {
5808                                            typeParameters();
5809                                            tp_AST = (AST)returnAST;
5810                                            break;
5811                                    }
5812                                    case IDENT:
5813                                    case LITERAL_void:
5814                                    case LITERAL_boolean:
5815                                    case LITERAL_byte:
5816                                    case LITERAL_char:
5817                                    case LITERAL_short:
5818                                    case LITERAL_int:
5819                                    case LITERAL_float:
5820                                    case LITERAL_long:
5821                                    case LITERAL_double:
5822                                    case LITERAL_any:
5823                                    {
5824                                            break;
5825                                    }
5826                                    default:
5827                                    {
5828                                            throw new NoViableAltException(LT(1), getFilename());
5829                                    }
5830                                    }
5831                                    }
5832                                    typeSpec(false);
5833                                    t_AST = (AST)returnAST;
5834                                    {
5835                                    boolean synPredMatched153 = false;
5836                                    if (((LA(1)==IDENT) && (LA(2)==LPAREN) && (_tokenSet_69.member(LA(3))))) {
5837                                            int _m153 = mark();
5838                                            synPredMatched153 = true;
5839                                            inputState.guessing++;
5840                                            try {
5841                                                    {
5842                                                    match(IDENT);
5843                                                    match(LPAREN);
5844                                                    }
5845                                            }
5846                                            catch (RecognitionException pe) {
5847                                                    synPredMatched153 = false;
5848                                            }
5849                                            rewind(_m153);
5850    inputState.guessing--;
5851                                    }
5852                                    if ( synPredMatched153 ) {
5853                                            AST tmp141_AST = null;
5854                                            tmp141_AST = astFactory.create(LT(1));
5855                                            match(IDENT);
5856                                            match(LPAREN);
5857                                            parameterDeclarationList();
5858                                            param_AST = (AST)returnAST;
5859                                            match(RPAREN);
5860                                            {
5861                                            boolean synPredMatched156 = false;
5862                                            if (((LA(1)==NLS||LA(1)==LITERAL_throws) && (_tokenSet_30.member(LA(2))) && (_tokenSet_70.member(LA(3))))) {
5863                                                    int _m156 = mark();
5864                                                    synPredMatched156 = true;
5865                                                    inputState.guessing++;
5866                                                    try {
5867                                                            {
5868                                                            nls();
5869                                                            match(LITERAL_throws);
5870                                                            }
5871                                                    }
5872                                                    catch (RecognitionException pe) {
5873                                                            synPredMatched156 = false;
5874                                                    }
5875                                                    rewind(_m156);
5876    inputState.guessing--;
5877                                            }
5878                                            if ( synPredMatched156 ) {
5879                                                    throwsClause();
5880                                                    tc_AST = (AST)returnAST;
5881                                            }
5882                                            else if (((LA(1) >= LCURLY && LA(1) <= NLS)) && (_tokenSet_71.member(LA(2))) && (_tokenSet_8.member(LA(3)))) {
5883                                            }
5884                                            else {
5885                                                    throw new NoViableAltException(LT(1), getFilename());
5886                                            }
5887                                            
5888                                            }
5889                                            {
5890                                            switch ( LA(1)) {
5891                                            case LCURLY:
5892                                            {
5893                                                    compoundStatement();
5894                                                    s2_AST = (AST)returnAST;
5895                                                    break;
5896                                            }
5897                                            case RCURLY:
5898                                            case SEMI:
5899                                            case NLS:
5900                                            {
5901                                                    break;
5902                                            }
5903                                            default:
5904                                            {
5905                                                    throw new NoViableAltException(LT(1), getFilename());
5906                                            }
5907                                            }
5908                                            }
5909                                            if ( inputState.guessing==0 ) {
5910                                                    enumConstantField_AST = (AST)currentAST.root;
5911                                                    enumConstantField_AST = (AST)astFactory.make( (new ASTArray(8)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t_AST))).add(tmp141_AST).add(param_AST).add(tc_AST).add(s2_AST));
5912                                                    currentAST.root = enumConstantField_AST;
5913                                                    currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
5914                                                            enumConstantField_AST.getFirstChild() : enumConstantField_AST;
5915                                                    currentAST.advanceChildToEnd();
5916                                            }
5917                                    }
5918                                    else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (_tokenSet_63.member(LA(2))) && (_tokenSet_72.member(LA(3)))) {
5919                                            variableDefinitions(mods_AST,t_AST);
5920                                            v_AST = (AST)returnAST;
5921                                            if ( inputState.guessing==0 ) {
5922                                                    enumConstantField_AST = (AST)currentAST.root;
5923                                                    enumConstantField_AST = v_AST;
5924                                                    currentAST.root = enumConstantField_AST;
5925                                                    currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
5926                                                            enumConstantField_AST.getFirstChild() : enumConstantField_AST;
5927                                                    currentAST.advanceChildToEnd();
5928                                            }
5929                                    }
5930                                    else {
5931                                            throw new NoViableAltException(LT(1), getFilename());
5932                                    }
5933                                    
5934                                    }
5935                                    break;
5936                            }
5937                            default:
5938                            {
5939                                    throw new NoViableAltException(LT(1), getFilename());
5940                            }
5941                            }
5942                            }
5943                            break;
5944                    }
5945                    case LCURLY:
5946                    {
5947                            compoundStatement();
5948                            s4_AST = (AST)returnAST;
5949                            if ( inputState.guessing==0 ) {
5950                                    enumConstantField_AST = (AST)currentAST.root;
5951                                    enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(INSTANCE_INIT,"INSTANCE_INIT",first,LT(1))).add(s4_AST));
5952                                    currentAST.root = enumConstantField_AST;
5953                                    currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
5954                                            enumConstantField_AST.getFirstChild() : enumConstantField_AST;
5955                                    currentAST.advanceChildToEnd();
5956                            }
5957                            break;
5958                    }
5959                    default:
5960                    {
5961                            throw new NoViableAltException(LT(1), getFilename());
5962                    }
5963                    }
5964                    returnAST = enumConstantField_AST;
5965            }
5966            
5967    /** A list of zero or more formal parameters.
5968     *  If a parameter is variable length (e.g. String... myArg) it should be
5969     *  to the right of any other parameters of the same kind.
5970     *  General form:  (req, ..., opt, ..., [rest], key, ..., [restKeys], [block]
5971     *  This must be sorted out after parsing, since the various declaration forms
5972     *  are impossible to tell apart without backtracking.
5973     */
5974            public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
5975                    
5976                    returnAST = null;
5977                    ASTPair currentAST = new ASTPair();
5978                    AST parameterDeclarationList_AST = null;
5979                    Token first = LT(1);
5980                    
5981                    {
5982                    switch ( LA(1)) {
5983                    case FINAL:
5984                    case LITERAL_def:
5985                    case AT:
5986                    case IDENT:
5987                    case LITERAL_void:
5988                    case LITERAL_boolean:
5989                    case LITERAL_byte:
5990                    case LITERAL_char:
5991                    case LITERAL_short:
5992                    case LITERAL_int:
5993                    case LITERAL_float:
5994                    case LITERAL_long:
5995                    case LITERAL_double:
5996                    case LITERAL_any:
5997                    case TRIPLE_DOT:
5998                    {
5999                            parameterDeclaration();
6000                            astFactory.addASTChild(currentAST, returnAST);
6001                            {
6002                            _loop217:
6003                            do {
6004                                    if ((LA(1)==COMMA)) {
6005                                            match(COMMA);
6006                                            nls();
6007                                            parameterDeclaration();
6008                                            astFactory.addASTChild(currentAST, returnAST);
6009                                    }
6010                                    else {
6011                                            break _loop217;
6012                                    }
6013                                    
6014                            } while (true);
6015                            }
6016                            break;
6017                    }
6018                    case RPAREN:
6019                    case NLS:
6020                    case CLOSABLE_BLOCK_OP:
6021                    {
6022                            break;
6023                    }
6024                    default:
6025                    {
6026                            throw new NoViableAltException(LT(1), getFilename());
6027                    }
6028                    }
6029                    }
6030                    if ( inputState.guessing==0 ) {
6031                            parameterDeclarationList_AST = (AST)currentAST.root;
6032                            parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(PARAMETERS,"PARAMETERS",first,LT(1))).add(parameterDeclarationList_AST));
6033                            currentAST.root = parameterDeclarationList_AST;
6034                            currentAST.child = parameterDeclarationList_AST!=null &&parameterDeclarationList_AST.getFirstChild()!=null ?
6035                                    parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
6036                            currentAST.advanceChildToEnd();
6037                    }
6038                    parameterDeclarationList_AST = (AST)currentAST.root;
6039                    returnAST = parameterDeclarationList_AST;
6040            }
6041            
6042            public final void throwsClause() throws RecognitionException, TokenStreamException {
6043                    
6044                    returnAST = null;
6045                    ASTPair currentAST = new ASTPair();
6046                    AST throwsClause_AST = null;
6047                    
6048                    nls();
6049                    AST tmp145_AST = null;
6050                    tmp145_AST = astFactory.create(LT(1));
6051                    astFactory.makeASTRoot(currentAST, tmp145_AST);
6052                    match(LITERAL_throws);
6053                    nls();
6054                    identifier();
6055                    astFactory.addASTChild(currentAST, returnAST);
6056                    {
6057                    _loop213:
6058                    do {
6059                            if ((LA(1)==COMMA)) {
6060                                    match(COMMA);
6061                                    nls();
6062                                    identifier();
6063                                    astFactory.addASTChild(currentAST, returnAST);
6064                            }
6065                            else {
6066                                    break _loop213;
6067                            }
6068                            
6069                    } while (true);
6070                    }
6071                    throwsClause_AST = (AST)currentAST.root;
6072                    returnAST = throwsClause_AST;
6073            }
6074            
6075            public final void compoundStatement() throws RecognitionException, TokenStreamException {
6076                    
6077                    returnAST = null;
6078                    ASTPair currentAST = new ASTPair();
6079                    AST compoundStatement_AST = null;
6080                    
6081                    openBlock();
6082                    astFactory.addASTChild(currentAST, returnAST);
6083                    compoundStatement_AST = (AST)currentAST.root;
6084                    returnAST = compoundStatement_AST;
6085            }
6086            
6087    /** I've split out constructors separately; we could maybe integrate back into variableDefinitions 
6088     *  later on if we maybe simplified 'def' to be a type declaration?
6089     */
6090            public final void constructorDefinition(
6091                    AST mods
6092            ) throws RecognitionException, TokenStreamException {
6093                    
6094                    returnAST = null;
6095                    ASTPair currentAST = new ASTPair();
6096                    AST constructorDefinition_AST = null;
6097                    Token  id = null;
6098                    AST id_AST = null;
6099                    AST param_AST = null;
6100                    AST tc_AST = null;
6101                    AST cb_AST = null;
6102                    Token first = LT(1);
6103                    
6104                    id = LT(1);
6105                    id_AST = astFactory.create(id);
6106                    astFactory.addASTChild(currentAST, id_AST);
6107                    match(IDENT);
6108                    match(LPAREN);
6109                    parameterDeclarationList();
6110                    param_AST = (AST)returnAST;
6111                    match(RPAREN);
6112                    {
6113                    boolean synPredMatched202 = false;
6114                    if (((LA(1)==NLS||LA(1)==LITERAL_throws) && (_tokenSet_30.member(LA(2))) && (_tokenSet_73.member(LA(3))))) {
6115                            int _m202 = mark();
6116                            synPredMatched202 = true;
6117                            inputState.guessing++;
6118                            try {
6119                                    {
6120                                    nls();
6121                                    match(LITERAL_throws);
6122                                    }
6123                            }
6124                            catch (RecognitionException pe) {
6125                                    synPredMatched202 = false;
6126                            }
6127                            rewind(_m202);
6128    inputState.guessing--;
6129                    }
6130                    if ( synPredMatched202 ) {
6131                            throwsClause();
6132                            tc_AST = (AST)returnAST;
6133                    }
6134                    else if ((LA(1)==LCURLY||LA(1)==NLS) && (_tokenSet_74.member(LA(2))) && (_tokenSet_75.member(LA(3)))) {
6135                    }
6136                    else {
6137                            throw new NoViableAltException(LT(1), getFilename());
6138                    }
6139                    
6140                    }
6141                    nlsWarn();
6142                    if ( inputState.guessing==0 ) {
6143                            isConstructorIdent(id);
6144                    }
6145                    constructorBody();
6146                    cb_AST = (AST)returnAST;
6147                    if ( inputState.guessing==0 ) {
6148                            constructorDefinition_AST = (AST)currentAST.root;
6149                            constructorDefinition_AST =  (AST)astFactory.make( (new ASTArray(5)).add(create(CTOR_IDENT,"CTOR_IDENT",first,LT(1))).add(mods).add(param_AST).add(tc_AST).add(cb_AST));
6150                            
6151                            currentAST.root = constructorDefinition_AST;
6152                            currentAST.child = constructorDefinition_AST!=null &&constructorDefinition_AST.getFirstChild()!=null ?
6153                                    constructorDefinition_AST.getFirstChild() : constructorDefinition_AST;
6154                            currentAST.advanceChildToEnd();
6155                    }
6156                    constructorDefinition_AST = (AST)currentAST.root;
6157                    returnAST = constructorDefinition_AST;
6158            }
6159            
6160            public final void constructorBody() throws RecognitionException, TokenStreamException {
6161                    
6162                    returnAST = null;
6163                    ASTPair currentAST = new ASTPair();
6164                    AST constructorBody_AST = null;
6165                    Token  lc = null;
6166                    AST lc_AST = null;
6167                    
6168                    lc = LT(1);
6169                    lc_AST = astFactory.create(lc);
6170                    astFactory.makeASTRoot(currentAST, lc_AST);
6171                    match(LCURLY);
6172                    nls();
6173                    if ( inputState.guessing==0 ) {
6174                            lc_AST.setType(SLIST);
6175                    }
6176                    {
6177                    boolean synPredMatched183 = false;
6178                    if (((_tokenSet_76.member(LA(1))) && (_tokenSet_77.member(LA(2))) && (_tokenSet_78.member(LA(3))))) {
6179                            int _m183 = mark();
6180                            synPredMatched183 = true;
6181                            inputState.guessing++;
6182                            try {
6183                                    {
6184                                    explicitConstructorInvocation();
6185                                    }
6186                            }
6187                            catch (RecognitionException pe) {
6188                                    synPredMatched183 = false;
6189                            }
6190                            rewind(_m183);
6191    inputState.guessing--;
6192                    }
6193                    if ( synPredMatched183 ) {
6194                            explicitConstructorInvocation();
6195                            astFactory.addASTChild(currentAST, returnAST);
6196                            {
6197                            switch ( LA(1)) {
6198                            case SEMI:
6199                            case NLS:
6200                            {
6201                                    sep();
6202                                    blockBody(sepToken);
6203                                    astFactory.addASTChild(currentAST, returnAST);
6204                                    break;
6205                            }
6206                            case RCURLY:
6207                            {
6208                                    break;
6209                            }
6210                            default:
6211                            {
6212                                    throw new NoViableAltException(LT(1), getFilename());
6213                            }
6214                            }
6215                            }
6216                    }
6217                    else if ((_tokenSet_33.member(LA(1))) && (_tokenSet_75.member(LA(2))) && (_tokenSet_18.member(LA(3)))) {
6218                            blockBody(EOF);
6219                            astFactory.addASTChild(currentAST, returnAST);
6220                    }
6221                    else {
6222                            throw new NoViableAltException(LT(1), getFilename());
6223                    }
6224                    
6225                    }
6226                    match(RCURLY);
6227                    constructorBody_AST = (AST)currentAST.root;
6228                    returnAST = constructorBody_AST;
6229            }
6230            
6231    /** Catch obvious constructor calls, but not the expr.super(...) calls */
6232            public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
6233                    
6234                    returnAST = null;
6235                    ASTPair currentAST = new ASTPair();
6236                    AST explicitConstructorInvocation_AST = null;
6237                    Token  lp1 = null;
6238                    AST lp1_AST = null;
6239                    Token  lp2 = null;
6240                    AST lp2_AST = null;
6241                    
6242                    {
6243                    switch ( LA(1)) {
6244                    case LT:
6245                    {
6246                            typeArguments();
6247                            astFactory.addASTChild(currentAST, returnAST);
6248                            break;
6249                    }
6250                    case LITERAL_super:
6251                    case LITERAL_this:
6252                    {
6253                            break;
6254                    }
6255                    default:
6256                    {
6257                            throw new NoViableAltException(LT(1), getFilename());
6258                    }
6259                    }
6260                    }
6261                    {
6262                    switch ( LA(1)) {
6263                    case LITERAL_this:
6264                    {
6265                            match(LITERAL_this);
6266                            lp1 = LT(1);
6267                            lp1_AST = astFactory.create(lp1);
6268                            astFactory.makeASTRoot(currentAST, lp1_AST);
6269                            match(LPAREN);
6270                            argList();
6271                            astFactory.addASTChild(currentAST, returnAST);
6272                            match(RPAREN);
6273                            if ( inputState.guessing==0 ) {
6274                                    lp1_AST.setType(CTOR_CALL);
6275                            }
6276                            break;
6277                    }
6278                    case LITERAL_super:
6279                    {
6280                            match(LITERAL_super);
6281                            lp2 = LT(1);
6282                            lp2_AST = astFactory.create(lp2);
6283                            astFactory.makeASTRoot(currentAST, lp2_AST);
6284                            match(LPAREN);
6285                            argList();
6286                            astFactory.addASTChild(currentAST, returnAST);
6287                            match(RPAREN);
6288                            if ( inputState.guessing==0 ) {
6289                                    lp2_AST.setType(SUPER_CTOR_CALL);
6290                            }
6291                            break;
6292                    }
6293                    default:
6294                    {
6295                            throw new NoViableAltException(LT(1), getFilename());
6296                    }
6297                    }
6298                    }
6299                    explicitConstructorInvocation_AST = (AST)currentAST.root;
6300                    returnAST = explicitConstructorInvocation_AST;
6301            }
6302            
6303    /** Declaration of a variable. This can be a class/instance variable,
6304     *  or a local variable in a method
6305     *  It can also include possible initialization.
6306     */
6307            public final void variableDeclarator(
6308                    AST mods, AST t
6309            ) throws RecognitionException, TokenStreamException {
6310                    
6311                    returnAST = null;
6312                    ASTPair currentAST = new ASTPair();
6313                    AST variableDeclarator_AST = null;
6314                    AST id_AST = null;
6315                    AST v_AST = null;
6316                    Token first = LT(1);
6317                    
6318                    variableName();
6319                    id_AST = (AST)returnAST;
6320                    {
6321                    switch ( LA(1)) {
6322                    case ASSIGN:
6323                    {
6324                            varInitializer();
6325                            v_AST = (AST)returnAST;
6326                            break;
6327                    }
6328                    case EOF:
6329                    case COMMA:
6330                    case RCURLY:
6331                    case SEMI:
6332                    case NLS:
6333                    case LITERAL_default:
6334                    case LITERAL_else:
6335                    case LITERAL_case:
6336                    {
6337                            break;
6338                    }
6339                    default:
6340                    {
6341                            throw new NoViableAltException(LT(1), getFilename());
6342                    }
6343                    }
6344                    }
6345                    if ( inputState.guessing==0 ) {
6346                            variableDeclarator_AST = (AST)currentAST.root;
6347                            variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).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).add(v_AST));
6348                            currentAST.root = variableDeclarator_AST;
6349                            currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ?
6350                                    variableDeclarator_AST.getFirstChild() : variableDeclarator_AST;
6351                            currentAST.advanceChildToEnd();
6352                    }
6353                    returnAST = variableDeclarator_AST;
6354            }
6355            
6356    /** Zero or more insignificant newlines, all gobbled up and thrown away,
6357     *  but a warning message is left for the user, if there was a newline.
6358     */
6359            public final void nlsWarn() throws RecognitionException, TokenStreamException {
6360                    
6361                    returnAST = null;
6362                    ASTPair currentAST = new ASTPair();
6363                    AST nlsWarn_AST = null;
6364                    
6365                    {
6366                    boolean synPredMatched485 = false;
6367                    if (((_tokenSet_15.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_18.member(LA(3))))) {
6368                            int _m485 = mark();
6369                            synPredMatched485 = true;
6370                            inputState.guessing++;
6371                            try {
6372                                    {
6373                                    match(NLS);
6374                                    }
6375                            }
6376                            catch (RecognitionException pe) {
6377                                    synPredMatched485 = false;
6378                            }
6379                            rewind(_m485);
6380    inputState.guessing--;
6381                    }
6382                    if ( synPredMatched485 ) {
6383                            if ( inputState.guessing==0 ) {
6384                                    addWarning(
6385                                    "A newline at this point does not follow the Groovy Coding Conventions.",
6386                                    "Keep this statement on one line, or use curly braces to break across multiple lines."
6387                                    );
6388                            }
6389                    }
6390                    else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_18.member(LA(3)))) {
6391                    }
6392                    else {
6393                            throw new NoViableAltException(LT(1), getFilename());
6394                    }
6395                    
6396                    }
6397                    nls();
6398                    returnAST = nlsWarn_AST;
6399            }
6400            
6401    /** An open block is not allowed to have closure arguments. */
6402            public final void openBlock() throws RecognitionException, TokenStreamException {
6403                    
6404                    returnAST = null;
6405                    ASTPair currentAST = new ASTPair();
6406                    AST openBlock_AST = null;
6407                    Token  lc = null;
6408                    AST lc_AST = null;
6409                    
6410                    lc = LT(1);
6411                    lc_AST = astFactory.create(lc);
6412                    astFactory.makeASTRoot(currentAST, lc_AST);
6413                    match(LCURLY);
6414                    nls();
6415                    if ( inputState.guessing==0 ) {
6416                            lc_AST.setType(SLIST);
6417                    }
6418                    blockBody(EOF);
6419                    astFactory.addASTChild(currentAST, returnAST);
6420                    match(RCURLY);
6421                    openBlock_AST = (AST)currentAST.root;
6422                    returnAST = openBlock_AST;
6423            }
6424            
6425            public final void variableName() throws RecognitionException, TokenStreamException {
6426                    
6427                    returnAST = null;
6428                    ASTPair currentAST = new ASTPair();
6429                    AST variableName_AST = null;
6430                    
6431                    AST tmp155_AST = null;
6432                    tmp155_AST = astFactory.create(LT(1));
6433                    astFactory.addASTChild(currentAST, tmp155_AST);
6434                    match(IDENT);
6435                    variableName_AST = (AST)currentAST.root;
6436                    returnAST = variableName_AST;
6437            }
6438            
6439            public final void expression(
6440                    int lc_stmt
6441            ) throws RecognitionException, TokenStreamException {
6442                    
6443                    returnAST = null;
6444                    ASTPair currentAST = new ASTPair();
6445                    AST expression_AST = null;
6446                    
6447                    assignmentExpression(lc_stmt);
6448                    astFactory.addASTChild(currentAST, returnAST);
6449                    expression_AST = (AST)currentAST.root;
6450                    returnAST = expression_AST;
6451            }
6452            
6453    /** A formal parameter for a method or closure. */
6454            public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
6455                    
6456                    returnAST = null;
6457                    ASTPair currentAST = new ASTPair();
6458                    AST parameterDeclaration_AST = null;
6459                    AST pm_AST = null;
6460                    AST t_AST = null;
6461                    Token  id = null;
6462                    AST id_AST = null;
6463                    AST exp_AST = null;
6464                    Token first = LT(1);boolean spreadParam = false;
6465                    
6466                    parameterModifiersOpt();
6467                    pm_AST = (AST)returnAST;
6468                    {
6469                    if ((_tokenSet_26.member(LA(1))) && (_tokenSet_79.member(LA(2))) && (_tokenSet_80.member(LA(3)))) {
6470                            typeSpec(false);
6471                            t_AST = (AST)returnAST;
6472                    }
6473                    else if ((LA(1)==IDENT||LA(1)==TRIPLE_DOT) && (_tokenSet_81.member(LA(2))) && (_tokenSet_82.member(LA(3)))) {
6474                    }
6475                    else {
6476                            throw new NoViableAltException(LT(1), getFilename());
6477                    }
6478                    
6479                    }
6480                    {
6481                    switch ( LA(1)) {
6482                    case TRIPLE_DOT:
6483                    {
6484                            match(TRIPLE_DOT);
6485                            if ( inputState.guessing==0 ) {
6486                                    spreadParam = true;
6487                            }
6488                            break;
6489                    }
6490                    case IDENT:
6491                    {
6492                            break;
6493                    }
6494                    default:
6495                    {
6496                            throw new NoViableAltException(LT(1), getFilename());
6497                    }
6498                    }
6499                    }
6500                    id = LT(1);
6501                    id_AST = astFactory.create(id);
6502                    match(IDENT);
6503                    {
6504                    switch ( LA(1)) {
6505                    case ASSIGN:
6506                    {
6507                            varInitializer();
6508                            exp_AST = (AST)returnAST;
6509                            break;
6510                    }
6511                    case COMMA:
6512                    case RPAREN:
6513                    case NLS:
6514                    case CLOSABLE_BLOCK_OP:
6515                    {
6516                            break;
6517                    }
6518                    default:
6519                    {
6520                            throw new NoViableAltException(LT(1), getFilename());
6521                    }
6522                    }
6523                    }
6524                    if ( inputState.guessing==0 ) {
6525                            parameterDeclaration_AST = (AST)currentAST.root;
6526                            
6527                            if (spreadParam) {
6528                            parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(VARIABLE_PARAMETER_DEF,"VARIABLE_PARAMETER_DEF",first,LT(1))).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t_AST))).add(id_AST).add(exp_AST));
6529                            } else {
6530                            parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(PARAMETER_DEF,"PARAMETER_DEF",first,LT(1))).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t_AST))).add(id_AST).add(exp_AST));
6531                            }
6532                            
6533                            currentAST.root = parameterDeclaration_AST;
6534                            currentAST.child = parameterDeclaration_AST!=null &&parameterDeclaration_AST.getFirstChild()!=null ?
6535                                    parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
6536                            currentAST.advanceChildToEnd();
6537                    }
6538                    returnAST = parameterDeclaration_AST;
6539            }
6540            
6541            public final void parameterModifiersOpt() throws RecognitionException, TokenStreamException {
6542                    
6543                    returnAST = null;
6544                    ASTPair currentAST = new ASTPair();
6545                    AST parameterModifiersOpt_AST = null;
6546                    Token first = LT(1);int seenDef = 0;
6547                    
6548                    {
6549                    _loop224:
6550                    do {
6551                            switch ( LA(1)) {
6552                            case FINAL:
6553                            {
6554                                    AST tmp157_AST = null;
6555                                    tmp157_AST = astFactory.create(LT(1));
6556                                    astFactory.addASTChild(currentAST, tmp157_AST);
6557                                    match(FINAL);
6558                                    nls();
6559                                    break;
6560                            }
6561                            case AT:
6562                            {
6563                                    annotation();
6564                                    astFactory.addASTChild(currentAST, returnAST);
6565                                    nls();
6566                                    break;
6567                            }
6568                            default:
6569                                    if (((LA(1)==LITERAL_def))&&(seenDef++ == 0)) {
6570                                            match(LITERAL_def);
6571                                            nls();
6572                                    }
6573                            else {
6574                                    break _loop224;
6575                            }
6576                            }
6577                    } while (true);
6578                    }
6579                    if ( inputState.guessing==0 ) {
6580                            parameterModifiersOpt_AST = (AST)currentAST.root;
6581                            parameterModifiersOpt_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(parameterModifiersOpt_AST));
6582                            currentAST.root = parameterModifiersOpt_AST;
6583                            currentAST.child = parameterModifiersOpt_AST!=null &&parameterModifiersOpt_AST.getFirstChild()!=null ?
6584                                    parameterModifiersOpt_AST.getFirstChild() : parameterModifiersOpt_AST;
6585                            currentAST.advanceChildToEnd();
6586                    }
6587                    parameterModifiersOpt_AST = (AST)currentAST.root;
6588                    returnAST = parameterModifiersOpt_AST;
6589            }
6590            
6591    /** Closure parameters are exactly like method parameters,
6592     *  except that they are not enclosed in parentheses, but rather
6593     *  are prepended to the front of a block, just after the brace.
6594     *  They are separated from the closure body by a CLOSABLE_BLOCK_OP token '->'.
6595     */
6596            public final void closableBlockParamsOpt(
6597                    boolean addImplicit
6598            ) throws RecognitionException, TokenStreamException {
6599                    
6600                    returnAST = null;
6601                    ASTPair currentAST = new ASTPair();
6602                    AST closableBlockParamsOpt_AST = null;
6603                    
6604                    boolean synPredMatched227 = false;
6605                    if (((_tokenSet_83.member(LA(1))) && (_tokenSet_84.member(LA(2))) && (_tokenSet_20.member(LA(3))))) {
6606                            int _m227 = mark();
6607                            synPredMatched227 = true;
6608                            inputState.guessing++;
6609                            try {
6610                                    {
6611                                    parameterDeclarationList();
6612                                    nls();
6613                                    match(CLOSABLE_BLOCK_OP);
6614                                    }
6615                            }
6616                            catch (RecognitionException pe) {
6617                                    synPredMatched227 = false;
6618                            }
6619                            rewind(_m227);
6620    inputState.guessing--;
6621                    }
6622                    if ( synPredMatched227 ) {
6623                            parameterDeclarationList();
6624                            astFactory.addASTChild(currentAST, returnAST);
6625                            nls();
6626                            match(CLOSABLE_BLOCK_OP);
6627                            nls();
6628                            closableBlockParamsOpt_AST = (AST)currentAST.root;
6629                    }
6630                    else if (((_tokenSet_33.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_5.member(LA(3))))&&(addImplicit)) {
6631                            implicitParameters();
6632                            astFactory.addASTChild(currentAST, returnAST);
6633                            closableBlockParamsOpt_AST = (AST)currentAST.root;
6634                    }
6635                    else if ((_tokenSet_33.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
6636                            closableBlockParamsOpt_AST = (AST)currentAST.root;
6637                    }
6638                    else {
6639                            throw new NoViableAltException(LT(1), getFilename());
6640                    }
6641                    
6642                    returnAST = closableBlockParamsOpt_AST;
6643            }
6644            
6645    /** A block known to be a closure, but which omits its arguments, is given this placeholder.
6646     *  A subsequent pass is responsible for deciding if there is an implicit 'it' parameter,
6647     *  or if the parameter list should be empty.
6648     */
6649            public final void implicitParameters() throws RecognitionException, TokenStreamException {
6650                    
6651                    returnAST = null;
6652                    ASTPair currentAST = new ASTPair();
6653                    AST implicitParameters_AST = null;
6654                    Token first = LT(1);
6655                    
6656                    if ( inputState.guessing==0 ) {
6657                            implicitParameters_AST = (AST)currentAST.root;
6658                            implicitParameters_AST = (AST)astFactory.make( (new ASTArray(1)).add(create(IMPLICIT_PARAMETERS,"IMPLICIT_PARAMETERS",first,LT(1))));
6659                            currentAST.root = implicitParameters_AST;
6660                            currentAST.child = implicitParameters_AST!=null &&implicitParameters_AST.getFirstChild()!=null ?
6661                                    implicitParameters_AST.getFirstChild() : implicitParameters_AST;
6662                            currentAST.advanceChildToEnd();
6663                    }
6664                    implicitParameters_AST = (AST)currentAST.root;
6665                    returnAST = implicitParameters_AST;
6666            }
6667            
6668    /** Lookahead to check whether a block begins with explicit closure arguments. */
6669            public final void closableBlockParamsStart() throws RecognitionException, TokenStreamException {
6670                    
6671                    returnAST = null;
6672                    ASTPair currentAST = new ASTPair();
6673                    AST closableBlockParamsStart_AST = null;
6674                    
6675                    parameterDeclarationList();
6676                    nls();
6677                    AST tmp160_AST = null;
6678                    tmp160_AST = astFactory.create(LT(1));
6679                    match(CLOSABLE_BLOCK_OP);
6680                    returnAST = closableBlockParamsStart_AST;
6681            }
6682            
6683    /** Simple names, as in {x|...}, are completely equivalent to {(def x)|...}.  Build the right AST. */
6684            public final void closableBlockParam() throws RecognitionException, TokenStreamException {
6685                    
6686                    returnAST = null;
6687                    ASTPair currentAST = new ASTPair();
6688                    AST closableBlockParam_AST = null;
6689                    Token  id = null;
6690                    AST id_AST = null;
6691                    Token first = LT(1);
6692                    
6693                    id = LT(1);
6694                    id_AST = astFactory.create(id);
6695                    match(IDENT);
6696                    if ( inputState.guessing==0 ) {
6697                            closableBlockParam_AST = (AST)currentAST.root;
6698                            closableBlockParam_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(PARAMETER_DEF,"PARAMETER_DEF",first,LT(1))).add((AST)astFactory.make( (new ASTArray(1)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))))).add((AST)astFactory.make( (new ASTArray(1)).add(create(TYPE,"TYPE",first,LT(1))))).add(id_AST));
6699                            currentAST.root = closableBlockParam_AST;
6700                            currentAST.child = closableBlockParam_AST!=null &&closableBlockParam_AST.getFirstChild()!=null ?
6701                                    closableBlockParam_AST.getFirstChild() : closableBlockParam_AST;
6702                            currentAST.advanceChildToEnd();
6703                    }
6704                    returnAST = closableBlockParam_AST;
6705            }
6706            
6707    /** A block which is known to be a closure, even if it has no apparent arguments.
6708     *  A block inside an expression or after a method call is always assumed to be a closure.
6709     *  Only labeled, unparameterized blocks which occur directly as substatements are kept open.
6710     */
6711            public final void closableBlock() throws RecognitionException, TokenStreamException {
6712                    
6713                    returnAST = null;
6714                    ASTPair currentAST = new ASTPair();
6715                    AST closableBlock_AST = null;
6716                    Token  lc = null;
6717                    AST lc_AST = null;
6718                    
6719                    lc = LT(1);
6720                    lc_AST = astFactory.create(lc);
6721                    astFactory.makeASTRoot(currentAST, lc_AST);
6722                    match(LCURLY);
6723                    nls();
6724                    if ( inputState.guessing==0 ) {
6725                            lc_AST.setType(CLOSABLE_BLOCK);
6726                    }
6727                    closableBlockParamsOpt(true);
6728                    astFactory.addASTChild(currentAST, returnAST);
6729                    blockBody(EOF);
6730                    astFactory.addASTChild(currentAST, returnAST);
6731                    match(RCURLY);
6732                    closableBlock_AST = (AST)currentAST.root;
6733                    returnAST = closableBlock_AST;
6734            }
6735            
6736    /** A sub-block of a block can be either open or closable.
6737     *  It is closable if and only if there are explicit closure arguments.
6738     *  Compare this to a block which is appended to a method call,
6739     *  which is given closure arguments, even if they are not explicit in the code.
6740     */
6741            public final void openOrClosableBlock() throws RecognitionException, TokenStreamException {
6742                    
6743                    returnAST = null;
6744                    ASTPair currentAST = new ASTPair();
6745                    AST openOrClosableBlock_AST = null;
6746                    Token  lc = null;
6747                    AST lc_AST = null;
6748                    AST cp_AST = null;
6749                    
6750                    lc = LT(1);
6751                    lc_AST = astFactory.create(lc);
6752                    astFactory.makeASTRoot(currentAST, lc_AST);
6753                    match(LCURLY);
6754                    nls();
6755                    closableBlockParamsOpt(false);
6756                    cp_AST = (AST)returnAST;
6757                    astFactory.addASTChild(currentAST, returnAST);
6758                    if ( inputState.guessing==0 ) {
6759                            if (cp_AST == null)    lc_AST.setType(SLIST);
6760                            else                lc_AST.setType(CLOSABLE_BLOCK);
6761                            
6762                    }
6763                    blockBody(EOF);
6764                    astFactory.addASTChild(currentAST, returnAST);
6765                    match(RCURLY);
6766                    openOrClosableBlock_AST = (AST)currentAST.root;
6767                    returnAST = openOrClosableBlock_AST;
6768            }
6769            
6770    /** A labeled statement, consisting of a vanilla identifier followed by a colon. */
6771            public final void statementLabelPrefix() throws RecognitionException, TokenStreamException {
6772                    
6773                    returnAST = null;
6774                    ASTPair currentAST = new ASTPair();
6775                    AST statementLabelPrefix_AST = null;
6776                    Token  c = null;
6777                    AST c_AST = null;
6778                    
6779                    AST tmp163_AST = null;
6780                    tmp163_AST = astFactory.create(LT(1));
6781                    astFactory.addASTChild(currentAST, tmp163_AST);
6782                    match(IDENT);
6783                    c = LT(1);
6784                    c_AST = astFactory.create(c);
6785                    astFactory.makeASTRoot(currentAST, c_AST);
6786                    match(COLON);
6787                    if ( inputState.guessing==0 ) {
6788                            c_AST.setType(LABELED_STAT);
6789                    }
6790                    nls();
6791                    statementLabelPrefix_AST = (AST)currentAST.root;
6792                    returnAST = statementLabelPrefix_AST;
6793            }
6794            
6795    /** An expression statement can be any general expression.
6796     *  <p>
6797     *  An expression statement can also be a <em>command</em>,
6798     *  which is a simple method call in which the outermost parentheses are omitted.
6799     *  <p>
6800     *  Certain "suspicious" looking forms are flagged for the user to disambiguate.
6801     */
6802            public final void expressionStatement(
6803                    int prevToken
6804            ) throws RecognitionException, TokenStreamException {
6805                    
6806                    returnAST = null;
6807                    ASTPair currentAST = new ASTPair();
6808                    AST expressionStatement_AST = null;
6809                    AST head_AST = null;
6810                    AST cmd_AST = null;
6811                    Token first = LT(1);boolean isPathExpr = false;
6812                    
6813                    {
6814                    boolean synPredMatched281 = false;
6815                    if (((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3))))) {
6816                            int _m281 = mark();
6817                            synPredMatched281 = true;
6818                            inputState.guessing++;
6819                            try {
6820                                    {
6821                                    suspiciousExpressionStatementStart();
6822                                    }
6823                            }
6824                            catch (RecognitionException pe) {
6825                                    synPredMatched281 = false;
6826                            }
6827                            rewind(_m281);
6828    inputState.guessing--;
6829                    }
6830                    if ( synPredMatched281 ) {
6831                            checkSuspiciousExpressionStatement(prevToken);
6832                            astFactory.addASTChild(currentAST, returnAST);
6833                    }
6834                    else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
6835                    }
6836                    else {
6837                            throw new NoViableAltException(LT(1), getFilename());
6838                    }
6839                    
6840                    }
6841                    expression(LC_STMT);
6842                    head_AST = (AST)returnAST;
6843                    astFactory.addASTChild(currentAST, returnAST);
6844                    if ( inputState.guessing==0 ) {
6845                            isPathExpr = (head_AST == lastPathExpression);
6846                    }
6847                    {
6848                    if (((_tokenSet_19.member(LA(1))))&&(isPathExpr)) {
6849                            commandArguments(head_AST);
6850                            cmd_AST = (AST)returnAST;
6851                            if ( inputState.guessing==0 ) {
6852                                    expressionStatement_AST = (AST)currentAST.root;
6853                                    expressionStatement_AST = cmd_AST;
6854                                    currentAST.root = expressionStatement_AST;
6855                                    currentAST.child = expressionStatement_AST!=null &&expressionStatement_AST.getFirstChild()!=null ?
6856                                            expressionStatement_AST.getFirstChild() : expressionStatement_AST;
6857                                    currentAST.advanceChildToEnd();
6858                            }
6859                    }
6860                    else if ((_tokenSet_9.member(LA(1)))) {
6861                    }
6862                    else {
6863                            throw new NoViableAltException(LT(1), getFilename());
6864                    }
6865                    
6866                    }
6867                    if ( inputState.guessing==0 ) {
6868                            expressionStatement_AST = (AST)currentAST.root;
6869                            expressionStatement_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXPR,"EXPR",first,LT(1))).add(expressionStatement_AST));
6870                            currentAST.root = expressionStatement_AST;
6871                            currentAST.child = expressionStatement_AST!=null &&expressionStatement_AST.getFirstChild()!=null ?
6872                                    expressionStatement_AST.getFirstChild() : expressionStatement_AST;
6873                            currentAST.advanceChildToEnd();
6874                    }
6875                    expressionStatement_AST = (AST)currentAST.root;
6876                    returnAST = expressionStatement_AST;
6877            }
6878            
6879            public final void assignmentLessExpression() throws RecognitionException, TokenStreamException {
6880                    
6881                    returnAST = null;
6882                    ASTPair currentAST = new ASTPair();
6883                    AST assignmentLessExpression_AST = null;
6884                    Token first = LT(1);
6885                    
6886                    {
6887                    conditionalExpression(0);
6888                    astFactory.addASTChild(currentAST, returnAST);
6889                    }
6890                    if ( inputState.guessing==0 ) {
6891                            assignmentLessExpression_AST = (AST)currentAST.root;
6892                            assignmentLessExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXPR,"EXPR",first,LT(1))).add(assignmentLessExpression_AST));
6893                            currentAST.root = assignmentLessExpression_AST;
6894                            currentAST.child = assignmentLessExpression_AST!=null &&assignmentLessExpression_AST.getFirstChild()!=null ?
6895                                    assignmentLessExpression_AST.getFirstChild() : assignmentLessExpression_AST;
6896                            currentAST.advanceChildToEnd();
6897                    }
6898                    assignmentLessExpression_AST = (AST)currentAST.root;
6899                    returnAST = assignmentLessExpression_AST;
6900            }
6901            
6902    /** In Java, "if", "while", and "for" statements can take random, non-braced statements as their bodies.
6903     *  Support this practice, even though it isn't very Groovy.
6904     */
6905            public final void compatibleBodyStatement() throws RecognitionException, TokenStreamException {
6906                    
6907                    returnAST = null;
6908                    ASTPair currentAST = new ASTPair();
6909                    AST compatibleBodyStatement_AST = null;
6910                    
6911                    boolean synPredMatched267 = false;
6912                    if (((LA(1)==LCURLY) && (_tokenSet_33.member(LA(2))) && (_tokenSet_8.member(LA(3))))) {
6913                            int _m267 = mark();
6914                            synPredMatched267 = true;
6915                            inputState.guessing++;
6916                            try {
6917                                    {
6918                                    match(LCURLY);
6919                                    }
6920                            }
6921                            catch (RecognitionException pe) {
6922                                    synPredMatched267 = false;
6923                            }
6924                            rewind(_m267);
6925    inputState.guessing--;
6926                    }
6927                    if ( synPredMatched267 ) {
6928                            compoundStatement();
6929                            astFactory.addASTChild(currentAST, returnAST);
6930                            compatibleBodyStatement_AST = (AST)currentAST.root;
6931                    }
6932                    else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_18.member(LA(3)))) {
6933                            statement(EOF);
6934                            astFactory.addASTChild(currentAST, returnAST);
6935                            compatibleBodyStatement_AST = (AST)currentAST.root;
6936                    }
6937                    else {
6938                            throw new NoViableAltException(LT(1), getFilename());
6939                    }
6940                    
6941                    returnAST = compatibleBodyStatement_AST;
6942            }
6943            
6944            public final void forStatement() throws RecognitionException, TokenStreamException {
6945                    
6946                    returnAST = null;
6947                    ASTPair currentAST = new ASTPair();
6948                    AST forStatement_AST = null;
6949                    Token  f = null;
6950                    AST f_AST = null;
6951                    
6952                    f = LT(1);
6953                    f_AST = astFactory.create(f);
6954                    astFactory.makeASTRoot(currentAST, f_AST);
6955                    match(LITERAL_for);
6956                    match(LPAREN);
6957                    {
6958                    boolean synPredMatched258 = false;
6959                    if (((_tokenSet_85.member(LA(1))) && (_tokenSet_75.member(LA(2))) && (_tokenSet_86.member(LA(3))))) {
6960                            int _m258 = mark();
6961                            synPredMatched258 = true;
6962                            inputState.guessing++;
6963                            try {
6964                                    {
6965                                    forInit();
6966                                    match(SEMI);
6967                                    }
6968                            }
6969                            catch (RecognitionException pe) {
6970                                    synPredMatched258 = false;
6971                            }
6972                            rewind(_m258);
6973    inputState.guessing--;
6974                    }
6975                    if ( synPredMatched258 ) {
6976                            traditionalForClause();
6977                            astFactory.addASTChild(currentAST, returnAST);
6978                    }
6979                    else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_87.member(LA(2))) && (_tokenSet_88.member(LA(3)))) {
6980                            forInClause();
6981                            astFactory.addASTChild(currentAST, returnAST);
6982                    }
6983                    else {
6984                            throw new NoViableAltException(LT(1), getFilename());
6985                    }
6986                    
6987                    }
6988                    match(RPAREN);
6989                    nlsWarn();
6990                    compatibleBodyStatement();
6991                    astFactory.addASTChild(currentAST, returnAST);
6992                    forStatement_AST = (AST)currentAST.root;
6993                    returnAST = forStatement_AST;
6994            }
6995            
6996    /** Things that can show up as expressions, but only in strict
6997     *  contexts like inside parentheses, argument lists, and list constructors.
6998     */
6999            public final void strictContextExpression() throws RecognitionException, TokenStreamException {
7000                    
7001                    returnAST = null;
7002                    ASTPair currentAST = new ASTPair();
7003                    AST strictContextExpression_AST = null;
7004                    Token first = LT(1);
7005                    
7006                    {
7007                    boolean synPredMatched428 = false;
7008                    if (((_tokenSet_12.member(LA(1))) && (_tokenSet_89.member(LA(2))) && (_tokenSet_90.member(LA(3))))) {
7009                            int _m428 = mark();
7010                            synPredMatched428 = true;
7011                            inputState.guessing++;
7012                            try {
7013                                    {
7014                                    declarationStart();
7015                                    }
7016                            }
7017                            catch (RecognitionException pe) {
7018                                    synPredMatched428 = false;
7019                            }
7020                            rewind(_m428);
7021    inputState.guessing--;
7022                    }
7023                    if ( synPredMatched428 ) {
7024                            singleDeclaration();
7025                            astFactory.addASTChild(currentAST, returnAST);
7026                    }
7027                    else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_68.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
7028                            expression(0);
7029                            astFactory.addASTChild(currentAST, returnAST);
7030                    }
7031                    else if (((LA(1) >= LITERAL_return && LA(1) <= LITERAL_assert))) {
7032                            branchStatement();
7033                            astFactory.addASTChild(currentAST, returnAST);
7034                    }
7035                    else if ((LA(1)==AT) && (LA(2)==IDENT) && (_tokenSet_91.member(LA(3)))) {
7036                            annotation();
7037                            astFactory.addASTChild(currentAST, returnAST);
7038                    }
7039                    else {
7040                            throw new NoViableAltException(LT(1), getFilename());
7041                    }
7042                    
7043                    }
7044                    if ( inputState.guessing==0 ) {
7045                            strictContextExpression_AST = (AST)currentAST.root;
7046                            strictContextExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXPR,"EXPR",first,LT(1))).add(strictContextExpression_AST));
7047                            currentAST.root = strictContextExpression_AST;
7048                            currentAST.child = strictContextExpression_AST!=null &&strictContextExpression_AST.getFirstChild()!=null ?
7049                                    strictContextExpression_AST.getFirstChild() : strictContextExpression_AST;
7050                            currentAST.advanceChildToEnd();
7051                    }
7052                    strictContextExpression_AST = (AST)currentAST.root;
7053                    returnAST = strictContextExpression_AST;
7054            }
7055            
7056            public final void casesGroup() throws RecognitionException, TokenStreamException {
7057                    
7058                    returnAST = null;
7059                    ASTPair currentAST = new ASTPair();
7060                    AST casesGroup_AST = null;
7061                    Token first = LT(1);
7062                    
7063                    {
7064                    int _cnt293=0;
7065                    _loop293:
7066                    do {
7067                            if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case)) {
7068                                    aCase();
7069                                    astFactory.addASTChild(currentAST, returnAST);
7070                            }
7071                            else {
7072                                    if ( _cnt293>=1 ) { break _loop293; } else {throw new NoViableAltException(LT(1), getFilename());}
7073                            }
7074                            
7075                            _cnt293++;
7076                    } while (true);
7077                    }
7078                    caseSList();
7079                    astFactory.addASTChild(currentAST, returnAST);
7080                    if ( inputState.guessing==0 ) {
7081                            casesGroup_AST = (AST)currentAST.root;
7082                            casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(CASE_GROUP,"CASE_GROUP",first,LT(1))).add(casesGroup_AST));
7083                            currentAST.root = casesGroup_AST;
7084                            currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ?
7085                                    casesGroup_AST.getFirstChild() : casesGroup_AST;
7086                            currentAST.advanceChildToEnd();
7087                    }
7088                    casesGroup_AST = (AST)currentAST.root;
7089                    returnAST = casesGroup_AST;
7090            }
7091            
7092            public final void tryBlock() throws RecognitionException, TokenStreamException {
7093                    
7094                    returnAST = null;
7095                    ASTPair currentAST = new ASTPair();
7096                    AST tryBlock_AST = null;
7097                    
7098                    AST tmp166_AST = null;
7099                    tmp166_AST = astFactory.create(LT(1));
7100                    astFactory.makeASTRoot(currentAST, tmp166_AST);
7101                    match(LITERAL_try);
7102                    nlsWarn();
7103                    compoundStatement();
7104                    astFactory.addASTChild(currentAST, returnAST);
7105                    {
7106                    _loop310:
7107                    do {
7108                            if ((LA(1)==NLS||LA(1)==LITERAL_catch) && (LA(2)==LPAREN||LA(2)==LITERAL_catch) && (_tokenSet_92.member(LA(3)))) {
7109                                    nls();
7110                                    handler();
7111                                    astFactory.addASTChild(currentAST, returnAST);
7112                            }
7113                            else {
7114                                    break _loop310;
7115                            }
7116                            
7117                    } while (true);
7118                    }
7119                    {
7120                    if ((LA(1)==NLS||LA(1)==LITERAL_finally) && (_tokenSet_93.member(LA(2))) && (_tokenSet_33.member(LA(3)))) {
7121                            nls();
7122                            finallyClause();
7123                            astFactory.addASTChild(currentAST, returnAST);
7124                    }
7125                    else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
7126                    }
7127                    else {
7128                            throw new NoViableAltException(LT(1), getFilename());
7129                    }
7130                    
7131                    }
7132                    tryBlock_AST = (AST)currentAST.root;
7133                    returnAST = tryBlock_AST;
7134            }
7135            
7136    /** In Groovy, return, break, continue, throw, and assert can be used in a parenthesized expression context.
7137     *  Example:  println (x || (return));  println assert x, "won't print a false value!"
7138     *  If an optional expression is missing, its value is void (this coerces to null when a value is required).
7139     */
7140            public final void branchStatement() throws RecognitionException, TokenStreamException {
7141                    
7142                    returnAST = null;
7143                    ASTPair currentAST = new ASTPair();
7144                    AST branchStatement_AST = null;
7145                    
7146                    switch ( LA(1)) {
7147                    case LITERAL_return:
7148                    {
7149                            AST tmp167_AST = null;
7150                            tmp167_AST = astFactory.create(LT(1));
7151                            astFactory.makeASTRoot(currentAST, tmp167_AST);
7152                            match(LITERAL_return);
7153                            {
7154                            switch ( LA(1)) {
7155                            case IDENT:
7156                            case LBRACK:
7157                            case LPAREN:
7158                            case LITERAL_super:
7159                            case LITERAL_void:
7160                            case LITERAL_boolean:
7161                            case LITERAL_byte:
7162                            case LITERAL_char:
7163                            case LITERAL_short:
7164                            case LITERAL_int:
7165                            case LITERAL_float:
7166                            case LITERAL_long:
7167                            case LITERAL_double:
7168                            case LITERAL_any:
7169                            case LCURLY:
7170                            case LITERAL_this:
7171                            case STRING_LITERAL:
7172                            case PLUS:
7173                            case MINUS:
7174                            case INC:
7175                            case DEC:
7176                            case BNOT:
7177                            case LNOT:
7178                            case DOLLAR:
7179                            case STRING_CTOR_START:
7180                            case LITERAL_new:
7181                            case LITERAL_true:
7182                            case LITERAL_false:
7183                            case LITERAL_null:
7184                            case NUM_INT:
7185                            case NUM_FLOAT:
7186                            case NUM_LONG:
7187                            case NUM_DOUBLE:
7188                            case NUM_BIG_INT:
7189                            case NUM_BIG_DECIMAL:
7190                            {
7191                                    expression(0);
7192                                    astFactory.addASTChild(currentAST, returnAST);
7193                                    break;
7194                            }
7195                            case EOF:
7196                            case RBRACK:
7197                            case COMMA:
7198                            case RPAREN:
7199                            case RCURLY:
7200                            case SEMI:
7201                            case NLS:
7202                            case LITERAL_default:
7203                            case LITERAL_else:
7204                            case LITERAL_case:
7205                            {
7206                                    break;
7207                            }
7208                            default:
7209                            {
7210                                    throw new NoViableAltException(LT(1), getFilename());
7211                            }
7212                            }
7213                            }
7214                            branchStatement_AST = (AST)currentAST.root;
7215                            break;
7216                    }
7217                    case LITERAL_break:
7218                    case LITERAL_continue:
7219                    {
7220                            {
7221                            switch ( LA(1)) {
7222                            case LITERAL_break:
7223                            {
7224                                    AST tmp168_AST = null;
7225                                    tmp168_AST = astFactory.create(LT(1));
7226                                    astFactory.makeASTRoot(currentAST, tmp168_AST);
7227                                    match(LITERAL_break);
7228                                    break;
7229                            }
7230                            case LITERAL_continue:
7231                            {
7232                                    AST tmp169_AST = null;
7233                                    tmp169_AST = astFactory.create(LT(1));
7234                                    astFactory.makeASTRoot(currentAST, tmp169_AST);
7235                                    match(LITERAL_continue);
7236                                    break;
7237                            }
7238                            default:
7239                            {
7240                                    throw new NoViableAltException(LT(1), getFilename());
7241                            }
7242                            }
7243                            }
7244                            {
7245                            boolean synPredMatched273 = false;
7246                            if (((LA(1)==IDENT) && (LA(2)==COLON) && (_tokenSet_94.member(LA(3))))) {
7247                                    int _m273 = mark();
7248                                    synPredMatched273 = true;
7249                                    inputState.guessing++;
7250                                    try {
7251                                            {
7252                                            match(IDENT);
7253                                            match(COLON);
7254                                            }
7255                                    }
7256                                    catch (RecognitionException pe) {
7257                                            synPredMatched273 = false;
7258                                    }
7259                                    rewind(_m273);
7260    inputState.guessing--;
7261                            }
7262                            if ( synPredMatched273 ) {
7263                                    statementLabelPrefix();
7264                                    astFactory.addASTChild(currentAST, returnAST);
7265                            }
7266                            else if ((_tokenSet_94.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
7267                            }
7268                            else {
7269                                    throw new NoViableAltException(LT(1), getFilename());
7270                            }
7271                            
7272                            }
7273                            {
7274                            switch ( LA(1)) {
7275                            case IDENT:
7276                            case LBRACK:
7277                            case LPAREN:
7278                            case LITERAL_super:
7279                            case LITERAL_void:
7280                            case LITERAL_boolean:
7281                            case LITERAL_byte:
7282                            case LITERAL_char:
7283                            case LITERAL_short:
7284                            case LITERAL_int:
7285                            case LITERAL_float:
7286                            case LITERAL_long:
7287                            case LITERAL_double:
7288                            case LITERAL_any:
7289                            case LCURLY:
7290                            case LITERAL_this:
7291                            case STRING_LITERAL:
7292                            case PLUS:
7293                            case MINUS:
7294                            case INC:
7295                            case DEC:
7296                            case BNOT:
7297                            case LNOT:
7298                            case DOLLAR:
7299                            case STRING_CTOR_START:
7300                            case LITERAL_new:
7301                            case LITERAL_true:
7302                            case LITERAL_false:
7303                            case LITERAL_null:
7304                            case NUM_INT:
7305                            case NUM_FLOAT:
7306                            case NUM_LONG:
7307                            case NUM_DOUBLE:
7308                            case NUM_BIG_INT:
7309                            case NUM_BIG_DECIMAL:
7310                            {
7311                                    expression(0);
7312                                    astFactory.addASTChild(currentAST, returnAST);
7313                                    break;
7314                            }
7315                            case EOF:
7316                            case RBRACK:
7317                            case COMMA:
7318                            case RPAREN:
7319                            case RCURLY:
7320                            case SEMI:
7321                            case NLS:
7322                            case LITERAL_default:
7323                            case LITERAL_else:
7324                            case LITERAL_case:
7325                            {
7326                                    break;
7327                            }
7328                            default:
7329                            {
7330                                    throw new NoViableAltException(LT(1), getFilename());
7331                            }
7332                            }
7333                            }
7334                            branchStatement_AST = (AST)currentAST.root;
7335                            break;
7336                    }
7337                    case LITERAL_throw:
7338                    {
7339                            AST tmp170_AST = null;
7340                            tmp170_AST = astFactory.create(LT(1));
7341                            astFactory.makeASTRoot(currentAST, tmp170_AST);
7342                            match(LITERAL_throw);
7343                            expression(0);
7344                            astFactory.addASTChild(currentAST, returnAST);
7345                            branchStatement_AST = (AST)currentAST.root;
7346                            break;
7347                    }
7348                    case LITERAL_assert:
7349                    {
7350                            AST tmp171_AST = null;
7351                            tmp171_AST = astFactory.create(LT(1));
7352                            astFactory.makeASTRoot(currentAST, tmp171_AST);
7353                            match(LITERAL_assert);
7354                            assignmentLessExpression();
7355                            astFactory.addASTChild(currentAST, returnAST);
7356                            {
7357                            if ((LA(1)==COMMA||LA(1)==COLON) && (_tokenSet_19.member(LA(2))) && (_tokenSet_95.member(LA(3)))) {
7358                                    {
7359                                    switch ( LA(1)) {
7360                                    case COMMA:
7361                                    {
7362                                            match(COMMA);
7363                                            break;
7364                                    }
7365                                    case COLON:
7366                                    {
7367                                            match(COLON);
7368                                            break;
7369                                    }
7370                                    default:
7371                                    {
7372                                            throw new NoViableAltException(LT(1), getFilename());
7373                                    }
7374                                    }
7375                                    }
7376                                    expression(0);
7377                                    astFactory.addASTChild(currentAST, returnAST);
7378                            }
7379                            else if ((_tokenSet_96.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
7380                            }
7381                            else {
7382                                    throw new NoViableAltException(LT(1), getFilename());
7383                            }
7384                            
7385                            }
7386                            branchStatement_AST = (AST)currentAST.root;
7387                            break;
7388                    }
7389                    default:
7390                    {
7391                            throw new NoViableAltException(LT(1), getFilename());
7392                    }
7393                    }
7394                    returnAST = branchStatement_AST;
7395            }
7396            
7397            public final void forInit() throws RecognitionException, TokenStreamException {
7398                    
7399                    returnAST = null;
7400                    ASTPair currentAST = new ASTPair();
7401                    AST forInit_AST = null;
7402                    Token first = LT(1);
7403                    
7404                    boolean synPredMatched302 = false;
7405                    if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))) && (_tokenSet_97.member(LA(3))))) {
7406                            int _m302 = mark();
7407                            synPredMatched302 = true;
7408                            inputState.guessing++;
7409                            try {
7410                                    {
7411                                    declarationStart();
7412                                    }
7413                            }
7414                            catch (RecognitionException pe) {
7415                                    synPredMatched302 = false;
7416                            }
7417                            rewind(_m302);
7418    inputState.guessing--;
7419                    }
7420                    if ( synPredMatched302 ) {
7421                            declaration();
7422                            astFactory.addASTChild(currentAST, returnAST);
7423                            forInit_AST = (AST)currentAST.root;
7424                    }
7425                    else if ((_tokenSet_85.member(LA(1))) && (_tokenSet_75.member(LA(2))) && (_tokenSet_86.member(LA(3)))) {
7426                            {
7427                            switch ( LA(1)) {
7428                            case FINAL:
7429                            case ABSTRACT:
7430                            case STRICTFP:
7431                            case LITERAL_static:
7432                            case LITERAL_def:
7433                            case AT:
7434                            case IDENT:
7435                            case LBRACK:
7436                            case LPAREN:
7437                            case LITERAL_super:
7438                            case LITERAL_void:
7439                            case LITERAL_boolean:
7440                            case LITERAL_byte:
7441                            case LITERAL_char:
7442                            case LITERAL_short:
7443                            case LITERAL_int:
7444                            case LITERAL_float:
7445                            case LITERAL_long:
7446                            case LITERAL_double:
7447                            case LITERAL_any:
7448                            case LITERAL_private:
7449                            case LITERAL_public:
7450                            case LITERAL_protected:
7451                            case LITERAL_transient:
7452                            case LITERAL_native:
7453                            case LITERAL_threadsafe:
7454                            case LITERAL_synchronized:
7455                            case LITERAL_volatile:
7456                            case LCURLY:
7457                            case LITERAL_this:
7458                            case STRING_LITERAL:
7459                            case LITERAL_return:
7460                            case LITERAL_break:
7461                            case LITERAL_continue:
7462                            case LITERAL_throw:
7463                            case LITERAL_assert:
7464                            case PLUS:
7465                            case MINUS:
7466                            case INC:
7467                            case DEC:
7468                            case BNOT:
7469                            case LNOT:
7470                            case DOLLAR:
7471                            case STRING_CTOR_START:
7472                            case LITERAL_new:
7473                            case LITERAL_true:
7474                            case LITERAL_false:
7475                            case LITERAL_null:
7476                            case NUM_INT:
7477                            case NUM_FLOAT:
7478                            case NUM_LONG:
7479                            case NUM_DOUBLE:
7480                            case NUM_BIG_INT:
7481                            case NUM_BIG_DECIMAL:
7482                            {
7483                                    controlExpressionList();
7484                                    astFactory.addASTChild(currentAST, returnAST);
7485                                    break;
7486                            }
7487                            case SEMI:
7488                            {
7489                                    break;
7490                            }
7491                            default:
7492                            {
7493                                    throw new NoViableAltException(LT(1), getFilename());
7494                            }
7495                            }
7496                            }
7497                            if ( inputState.guessing==0 ) {
7498                                    forInit_AST = (AST)currentAST.root;
7499                                    forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(FOR_INIT,"FOR_INIT",first,LT(1))).add(forInit_AST));
7500                                    currentAST.root = forInit_AST;
7501                                    currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ?
7502                                            forInit_AST.getFirstChild() : forInit_AST;
7503                                    currentAST.advanceChildToEnd();
7504                            }
7505                            forInit_AST = (AST)currentAST.root;
7506                    }
7507                    else {
7508                            throw new NoViableAltException(LT(1), getFilename());
7509                    }
7510                    
7511                    returnAST = forInit_AST;
7512            }
7513            
7514            public final void traditionalForClause() throws RecognitionException, TokenStreamException {
7515                    
7516                    returnAST = null;
7517                    ASTPair currentAST = new ASTPair();
7518                    AST traditionalForClause_AST = null;
7519                    
7520                    forInit();
7521                    astFactory.addASTChild(currentAST, returnAST);
7522                    match(SEMI);
7523                    forCond();
7524                    astFactory.addASTChild(currentAST, returnAST);
7525                    match(SEMI);
7526                    forIter();
7527                    astFactory.addASTChild(currentAST, returnAST);
7528                    traditionalForClause_AST = (AST)currentAST.root;
7529                    returnAST = traditionalForClause_AST;
7530            }
7531            
7532            public final void forInClause() throws RecognitionException, TokenStreamException {
7533                    
7534                    returnAST = null;
7535                    ASTPair currentAST = new ASTPair();
7536                    AST forInClause_AST = null;
7537                    AST decl_AST = null;
7538                    Token  i = null;
7539                    AST i_AST = null;
7540                    Token  c = null;
7541                    AST c_AST = null;
7542                    
7543                    {
7544                    boolean synPredMatched263 = false;
7545                    if (((_tokenSet_12.member(LA(1))) && (_tokenSet_89.member(LA(2))))) {
7546                            int _m263 = mark();
7547                            synPredMatched263 = true;
7548                            inputState.guessing++;
7549                            try {
7550                                    {
7551                                    declarationStart();
7552                                    }
7553                            }
7554                            catch (RecognitionException pe) {
7555                                    synPredMatched263 = false;
7556                            }
7557                            rewind(_m263);
7558    inputState.guessing--;
7559                    }
7560                    if ( synPredMatched263 ) {
7561                            singleDeclarationNoInit();
7562                            decl_AST = (AST)returnAST;
7563                            astFactory.addASTChild(currentAST, returnAST);
7564                    }
7565                    else if ((LA(1)==IDENT) && (LA(2)==COLON||LA(2)==LITERAL_in)) {
7566                            AST tmp176_AST = null;
7567                            tmp176_AST = astFactory.create(LT(1));
7568                            astFactory.addASTChild(currentAST, tmp176_AST);
7569                            match(IDENT);
7570                    }
7571                    else {
7572                            throw new NoViableAltException(LT(1), getFilename());
7573                    }
7574                    
7575                    }
7576                    {
7577                    switch ( LA(1)) {
7578                    case LITERAL_in:
7579                    {
7580                            i = LT(1);
7581                            i_AST = astFactory.create(i);
7582                            astFactory.makeASTRoot(currentAST, i_AST);
7583                            match(LITERAL_in);
7584                            if ( inputState.guessing==0 ) {
7585                                    i_AST.setType(FOR_IN_ITERABLE);
7586                            }
7587                            shiftExpression(0);
7588                            astFactory.addASTChild(currentAST, returnAST);
7589                            break;
7590                    }
7591                    case COLON:
7592                    {
7593                            if ( inputState.guessing==0 ) {
7594                                    addWarning(
7595                                    "A colon at this point is legal Java but not recommended in Groovy.",
7596                                    "Use the 'in' keyword."
7597                                    );
7598                                    require(decl_AST != null,
7599                                    "Java-style for-each statement requires a type declaration."
7600                                    ,
7601                                    "Use the 'in' keyword, as for (x in y) {...}"
7602                                    );
7603                                    
7604                            }
7605                            c = LT(1);
7606                            c_AST = astFactory.create(c);
7607                            astFactory.makeASTRoot(currentAST, c_AST);
7608                            match(COLON);
7609                            if ( inputState.guessing==0 ) {
7610                                    c_AST.setType(FOR_IN_ITERABLE);
7611                            }
7612                            expression(0);
7613                            astFactory.addASTChild(currentAST, returnAST);
7614                            break;
7615                    }
7616                    default:
7617                    {
7618                            throw new NoViableAltException(LT(1), getFilename());
7619                    }
7620                    }
7621                    }
7622                    forInClause_AST = (AST)currentAST.root;
7623                    returnAST = forInClause_AST;
7624            }
7625            
7626            public final void forCond() throws RecognitionException, TokenStreamException {
7627                    
7628                    returnAST = null;
7629                    ASTPair currentAST = new ASTPair();
7630                    AST forCond_AST = null;
7631                    Token first = LT(1);
7632                    
7633                    {
7634                    switch ( LA(1)) {
7635                    case FINAL:
7636                    case ABSTRACT:
7637                    case STRICTFP:
7638                    case LITERAL_static:
7639                    case LITERAL_def:
7640                    case AT:
7641                    case IDENT:
7642                    case LBRACK:
7643                    case LPAREN:
7644                    case LITERAL_super:
7645                    case LITERAL_void:
7646                    case LITERAL_boolean:
7647                    case LITERAL_byte:
7648                    case LITERAL_char:
7649                    case LITERAL_short:
7650                    case LITERAL_int:
7651                    case LITERAL_float:
7652                    case LITERAL_long:
7653                    case LITERAL_double:
7654                    case LITERAL_any:
7655                    case LITERAL_private:
7656                    case LITERAL_public:
7657                    case LITERAL_protected:
7658                    case LITERAL_transient:
7659                    case LITERAL_native:
7660                    case LITERAL_threadsafe:
7661                    case LITERAL_synchronized:
7662                    case LITERAL_volatile:
7663                    case LCURLY:
7664                    case LITERAL_this:
7665                    case STRING_LITERAL:
7666                    case LITERAL_return:
7667                    case LITERAL_break:
7668                    case LITERAL_continue:
7669                    case LITERAL_throw:
7670                    case LITERAL_assert:
7671                    case PLUS:
7672                    case MINUS:
7673                    case INC:
7674                    case DEC:
7675                    case BNOT:
7676                    case LNOT:
7677                    case DOLLAR:
7678                    case STRING_CTOR_START:
7679                    case LITERAL_new:
7680                    case LITERAL_true:
7681                    case LITERAL_false:
7682                    case LITERAL_null:
7683                    case NUM_INT:
7684                    case NUM_FLOAT:
7685                    case NUM_LONG:
7686                    case NUM_DOUBLE:
7687                    case NUM_BIG_INT:
7688                    case NUM_BIG_DECIMAL:
7689                    {
7690                            strictContextExpression();
7691                            astFactory.addASTChild(currentAST, returnAST);
7692                            break;
7693                    }
7694                    case SEMI:
7695                    {
7696                            break;
7697                    }
7698                    default:
7699                    {
7700                            throw new NoViableAltException(LT(1), getFilename());
7701                    }
7702                    }
7703                    }
7704                    if ( inputState.guessing==0 ) {
7705                            forCond_AST = (AST)currentAST.root;
7706                            forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(FOR_CONDITION,"FOR_CONDITION",first,LT(1))).add(forCond_AST));
7707                            currentAST.root = forCond_AST;
7708                            currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ?
7709                                    forCond_AST.getFirstChild() : forCond_AST;
7710                            currentAST.advanceChildToEnd();
7711                    }
7712                    forCond_AST = (AST)currentAST.root;
7713                    returnAST = forCond_AST;
7714            }
7715            
7716            public final void forIter() throws RecognitionException, TokenStreamException {
7717                    
7718                    returnAST = null;
7719                    ASTPair currentAST = new ASTPair();
7720                    AST forIter_AST = null;
7721                    Token first = LT(1);
7722                    
7723                    {
7724                    switch ( LA(1)) {
7725                    case FINAL:
7726                    case ABSTRACT:
7727                    case STRICTFP:
7728                    case LITERAL_static:
7729                    case LITERAL_def:
7730                    case AT:
7731                    case IDENT:
7732                    case LBRACK:
7733                    case LPAREN:
7734                    case LITERAL_super:
7735                    case LITERAL_void:
7736                    case LITERAL_boolean:
7737                    case LITERAL_byte:
7738                    case LITERAL_char:
7739                    case LITERAL_short:
7740                    case LITERAL_int:
7741                    case LITERAL_float:
7742                    case LITERAL_long:
7743                    case LITERAL_double:
7744                    case LITERAL_any:
7745                    case LITERAL_private:
7746                    case LITERAL_public:
7747                    case LITERAL_protected:
7748                    case LITERAL_transient:
7749                    case LITERAL_native:
7750                    case LITERAL_threadsafe:
7751                    case LITERAL_synchronized:
7752                    case LITERAL_volatile:
7753                    case LCURLY:
7754                    case LITERAL_this:
7755                    case STRING_LITERAL:
7756                    case LITERAL_return:
7757                    case LITERAL_break:
7758                    case LITERAL_continue:
7759                    case LITERAL_throw:
7760                    case LITERAL_assert:
7761                    case PLUS:
7762                    case MINUS:
7763                    case INC:
7764                    case DEC:
7765                    case BNOT:
7766                    case LNOT:
7767                    case DOLLAR:
7768                    case STRING_CTOR_START:
7769                    case LITERAL_new:
7770                    case LITERAL_true:
7771                    case LITERAL_false:
7772                    case LITERAL_null:
7773                    case NUM_INT:
7774                    case NUM_FLOAT:
7775                    case NUM_LONG:
7776                    case NUM_DOUBLE:
7777                    case NUM_BIG_INT:
7778                    case NUM_BIG_DECIMAL:
7779                    {
7780                            controlExpressionList();
7781                            astFactory.addASTChild(currentAST, returnAST);
7782                            break;
7783                    }
7784                    case RPAREN:
7785                    {
7786                            break;
7787                    }
7788                    default:
7789                    {
7790                            throw new NoViableAltException(LT(1), getFilename());
7791                    }
7792                    }
7793                    }
7794                    if ( inputState.guessing==0 ) {
7795                            forIter_AST = (AST)currentAST.root;
7796                            forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(FOR_ITERATOR,"FOR_ITERATOR",first,LT(1))).add(forIter_AST));
7797                            currentAST.root = forIter_AST;
7798                            currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ?
7799                                    forIter_AST.getFirstChild() : forIter_AST;
7800                            currentAST.advanceChildToEnd();
7801                    }
7802                    forIter_AST = (AST)currentAST.root;
7803                    returnAST = forIter_AST;
7804            }
7805            
7806            public final void shiftExpression(
7807                    int lc_stmt
7808            ) throws RecognitionException, TokenStreamException {
7809                    
7810                    returnAST = null;
7811                    ASTPair currentAST = new ASTPair();
7812                    AST shiftExpression_AST = null;
7813                    Token  td = null;
7814                    AST td_AST = null;
7815                    
7816                    additiveExpression(lc_stmt);
7817                    astFactory.addASTChild(currentAST, returnAST);
7818                    {
7819                    _loop380:
7820                    do {
7821                            if ((_tokenSet_98.member(LA(1)))) {
7822                                    {
7823                                    switch ( LA(1)) {
7824                                    case SR:
7825                                    case BSR:
7826                                    case SL:
7827                                    {
7828                                            {
7829                                            switch ( LA(1)) {
7830                                            case SL:
7831                                            {
7832                                                    AST tmp177_AST = null;
7833                                                    tmp177_AST = astFactory.create(LT(1));
7834                                                    astFactory.makeASTRoot(currentAST, tmp177_AST);
7835                                                    match(SL);
7836                                                    break;
7837                                            }
7838                                            case SR:
7839                                            {
7840                                                    AST tmp178_AST = null;
7841                                                    tmp178_AST = astFactory.create(LT(1));
7842                                                    astFactory.makeASTRoot(currentAST, tmp178_AST);
7843                                                    match(SR);
7844                                                    break;
7845                                            }
7846                                            case BSR:
7847                                            {
7848                                                    AST tmp179_AST = null;
7849                                                    tmp179_AST = astFactory.create(LT(1));
7850                                                    astFactory.makeASTRoot(currentAST, tmp179_AST);
7851                                                    match(BSR);
7852                                                    break;
7853                                            }
7854                                            default:
7855                                            {
7856                                                    throw new NoViableAltException(LT(1), getFilename());
7857                                            }
7858                                            }
7859                                            }
7860                                            break;
7861                                    }
7862                                    case RANGE_INCLUSIVE:
7863                                    {
7864                                            AST tmp180_AST = null;
7865                                            tmp180_AST = astFactory.create(LT(1));
7866                                            astFactory.makeASTRoot(currentAST, tmp180_AST);
7867                                            match(RANGE_INCLUSIVE);
7868                                            break;
7869                                    }
7870                                    case RANGE_EXCLUSIVE:
7871                                    {
7872                                            AST tmp181_AST = null;
7873                                            tmp181_AST = astFactory.create(LT(1));
7874                                            astFactory.makeASTRoot(currentAST, tmp181_AST);
7875                                            match(RANGE_EXCLUSIVE);
7876                                            break;
7877                                    }
7878                                    case TRIPLE_DOT:
7879                                    {
7880                                            td = LT(1);
7881                                            td_AST = astFactory.create(td);
7882                                            astFactory.makeASTRoot(currentAST, td_AST);
7883                                            match(TRIPLE_DOT);
7884                                            if ( inputState.guessing==0 ) {
7885                                                    td_AST.setType(RANGE_EXCLUSIVE);
7886                                            }
7887                                            break;
7888                                    }
7889                                    default:
7890                                    {
7891                                            throw new NoViableAltException(LT(1), getFilename());
7892                                    }
7893                                    }
7894                                    }
7895                                    nls();
7896                                    additiveExpression(0);
7897                                    astFactory.addASTChild(currentAST, returnAST);
7898                            }
7899                            else {
7900                                    break _loop380;
7901                            }
7902                            
7903                    } while (true);
7904                    }
7905                    shiftExpression_AST = (AST)currentAST.root;
7906                    returnAST = shiftExpression_AST;
7907            }
7908            
7909    /** Lookahead for suspicious statement warnings and errors. */
7910            public final void suspiciousExpressionStatementStart() throws RecognitionException, TokenStreamException {
7911                    
7912                    returnAST = null;
7913                    ASTPair currentAST = new ASTPair();
7914                    AST suspiciousExpressionStatementStart_AST = null;
7915                    
7916                    {
7917                    switch ( LA(1)) {
7918                    case PLUS:
7919                    case MINUS:
7920                    {
7921                            {
7922                            switch ( LA(1)) {
7923                            case PLUS:
7924                            {
7925                                    AST tmp182_AST = null;
7926                                    tmp182_AST = astFactory.create(LT(1));
7927                                    astFactory.addASTChild(currentAST, tmp182_AST);
7928                                    match(PLUS);
7929                                    break;
7930                            }
7931                            case MINUS:
7932                            {
7933                                    AST tmp183_AST = null;
7934                                    tmp183_AST = astFactory.create(LT(1));
7935                                    astFactory.addASTChild(currentAST, tmp183_AST);
7936                                    match(MINUS);
7937                                    break;
7938                            }
7939                            default:
7940                            {
7941                                    throw new NoViableAltException(LT(1), getFilename());
7942                            }
7943                            }
7944                            }
7945                            break;
7946                    }
7947                    case LBRACK:
7948                    case LPAREN:
7949                    case LCURLY:
7950                    {
7951                            {
7952                            switch ( LA(1)) {
7953                            case LBRACK:
7954                            {
7955                                    AST tmp184_AST = null;
7956                                    tmp184_AST = astFactory.create(LT(1));
7957                                    astFactory.addASTChild(currentAST, tmp184_AST);
7958                                    match(LBRACK);
7959                                    break;
7960                            }
7961                            case LPAREN:
7962                            {
7963                                    AST tmp185_AST = null;
7964                                    tmp185_AST = astFactory.create(LT(1));
7965                                    astFactory.addASTChild(currentAST, tmp185_AST);
7966                                    match(LPAREN);
7967                                    break;
7968                            }
7969                            case LCURLY:
7970                            {
7971                                    AST tmp186_AST = null;
7972                                    tmp186_AST = astFactory.create(LT(1));
7973                                    astFactory.addASTChild(currentAST, tmp186_AST);
7974                                    match(LCURLY);
7975                                    break;
7976                            }
7977                            default:
7978                            {
7979                                    throw new NoViableAltException(LT(1), getFilename());
7980                            }
7981                            }
7982                            }
7983                            break;
7984                    }
7985                    default:
7986                    {
7987                            throw new NoViableAltException(LT(1), getFilename());
7988                    }
7989                    }
7990                    }
7991                    suspiciousExpressionStatementStart_AST = (AST)currentAST.root;
7992                    returnAST = suspiciousExpressionStatementStart_AST;
7993            }
7994            
7995    /**
7996     *  If two statements are separated by newline (not SEMI), the second had
7997     *  better not look like the latter half of an expression.  If it does, issue a warning.
7998     *  <p>
7999     *  Also, if the expression starts with a closure, it needs to
8000     *  have an explicit parameter list, in order to avoid the appearance of a
8001     *  compound statement.  This is a hard error.
8002     *  <p>
8003     *  These rules are different from Java's "dumb expression" restriction.
8004     *  Unlike Java, Groovy blocks can end with arbitrary (even dumb) expressions,
8005     *  as a consequence of optional 'return' and 'continue' tokens.
8006     * <p>
8007     *  To make the programmer's intention clear, a leading closure must have an
8008     *  explicit parameter list, and must not follow a previous statement separated
8009     *  only by newlines.
8010     */
8011            public final void checkSuspiciousExpressionStatement(
8012                    int prevToken
8013            ) throws RecognitionException, TokenStreamException {
8014                    
8015                    returnAST = null;
8016                    ASTPair currentAST = new ASTPair();
8017                    AST checkSuspiciousExpressionStatement_AST = null;
8018                    
8019                    boolean synPredMatched285 = false;
8020                    if (((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3))))) {
8021                            int _m285 = mark();
8022                            synPredMatched285 = true;
8023                            inputState.guessing++;
8024                            try {
8025                                    {
8026                                    if ((_tokenSet_99.member(LA(1)))) {
8027                                            matchNot(LCURLY);
8028                                    }
8029                                    else if ((LA(1)==LCURLY)) {
8030                                            match(LCURLY);
8031                                            closableBlockParamsStart();
8032                                    }
8033                                    else {
8034                                            throw new NoViableAltException(LT(1), getFilename());
8035                                    }
8036                                    
8037                                    }
8038                            }
8039                            catch (RecognitionException pe) {
8040                                    synPredMatched285 = false;
8041                            }
8042                            rewind(_m285);
8043    inputState.guessing--;
8044                    }
8045                    if ( synPredMatched285 ) {
8046                            {
8047                            if (((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3))))&&(prevToken == NLS)) {
8048                                    if ( inputState.guessing==0 ) {
8049                                            addWarning(
8050                                            "Expression statement looks like it may continue a previous statement.",
8051                                            "Either remove previous newline, or add an explicit semicolon ';'.");
8052                                            
8053                                    }
8054                            }
8055                            else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
8056                            }
8057                            else {
8058                                    throw new NoViableAltException(LT(1), getFilename());
8059                            }
8060                            
8061                            }
8062                            checkSuspiciousExpressionStatement_AST = (AST)currentAST.root;
8063                    }
8064                    else if (((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3))))&&(prevToken == NLS)) {
8065                            if ( inputState.guessing==0 ) {
8066                                    require(false,
8067                                    "Closure expression looks like it may be an isolated open block, "+
8068                                    "or it may continue a previous statement."
8069                                    ,
8070                                    "Add an explicit parameter list, as in {it -> ...}, or label it as L:{...}, "+
8071                                    "and also either remove previous newline, or add an explicit semicolon ';'."
8072                                    );
8073                                    
8074                            }
8075                            checkSuspiciousExpressionStatement_AST = (AST)currentAST.root;
8076                    }
8077                    else if (((_tokenSet_19.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_20.member(LA(3))))&&(prevToken != NLS)) {
8078                            if ( inputState.guessing==0 ) {
8079                                    require(false,
8080                                    "Closure expression looks like it may be an isolated open block.",
8081                                    "Add an explicit parameter list, as in {it -> ...}, or label it as L:{...}.");
8082                                    
8083                            }
8084                            checkSuspiciousExpressionStatement_AST = (AST)currentAST.root;
8085                    }
8086                    else {
8087                            throw new NoViableAltException(LT(1), getFilename());
8088                    }
8089                    
8090                    returnAST = checkSuspiciousExpressionStatement_AST;
8091            }
8092            
8093    /** A member name (x.y) or element name (x[y]) can serve as a command name,
8094     *  which may be followed by a list of arguments.
8095     *  Unlike parenthesized arguments, these must be plain expressions,
8096     *  without labels or spread operators.
8097     */
8098            public final void commandArguments(
8099                    AST head
8100            ) throws RecognitionException, TokenStreamException {
8101                    
8102                    returnAST = null;
8103                    ASTPair currentAST = new ASTPair();
8104                    AST commandArguments_AST = null;
8105                    Token first = LT(1);
8106                    
8107                    expression(0);
8108                    astFactory.addASTChild(currentAST, returnAST);
8109                    {
8110                    _loop316:
8111                    do {
8112                            if ((LA(1)==COMMA)) {
8113                                    match(COMMA);
8114                                    nls();
8115                                    expression(0);
8116                                    astFactory.addASTChild(currentAST, returnAST);
8117                            }
8118                            else {
8119                                    break _loop316;
8120                            }
8121                            
8122                    } while (true);
8123                    }
8124                    if ( inputState.guessing==0 ) {
8125                            commandArguments_AST = (AST)currentAST.root;
8126                            
8127                            AST elist = (AST)astFactory.make( (new ASTArray(2)).add(create(ELIST,"ELIST",first,LT(1))).add(commandArguments_AST));
8128                            AST headid = getASTFactory().dup(head);
8129                            headid.setType(METHOD_CALL);
8130                            headid.setText("<command>");
8131                            commandArguments_AST = (AST)astFactory.make( (new ASTArray(3)).add(headid).add(head).add(elist));
8132                            
8133                            currentAST.root = commandArguments_AST;
8134                            currentAST.child = commandArguments_AST!=null &&commandArguments_AST.getFirstChild()!=null ?
8135                                    commandArguments_AST.getFirstChild() : commandArguments_AST;
8136                            currentAST.advanceChildToEnd();
8137                    }
8138                    commandArguments_AST = (AST)currentAST.root;
8139                    returnAST = commandArguments_AST;
8140            }
8141            
8142            public final void aCase() throws RecognitionException, TokenStreamException {
8143                    
8144                    returnAST = null;
8145                    ASTPair currentAST = new ASTPair();
8146                    AST aCase_AST = null;
8147                    
8148                    {
8149                    switch ( LA(1)) {
8150                    case LITERAL_case:
8151                    {
8152                            AST tmp188_AST = null;
8153                            tmp188_AST = astFactory.create(LT(1));
8154                            astFactory.makeASTRoot(currentAST, tmp188_AST);
8155                            match(LITERAL_case);
8156                            expression(0);
8157                            astFactory.addASTChild(currentAST, returnAST);
8158                            break;
8159                    }
8160                    case LITERAL_default:
8161                    {
8162                            AST tmp189_AST = null;
8163                            tmp189_AST = astFactory.create(LT(1));
8164                            astFactory.addASTChild(currentAST, tmp189_AST);
8165                            match(LITERAL_default);
8166                            break;
8167                    }
8168                    default:
8169                    {
8170                            throw new NoViableAltException(LT(1), getFilename());
8171                    }
8172                    }
8173                    }
8174                    match(COLON);
8175                    nls();
8176                    aCase_AST = (AST)currentAST.root;
8177                    returnAST = aCase_AST;
8178            }
8179            
8180            public final void caseSList() throws RecognitionException, TokenStreamException {
8181                    
8182                    returnAST = null;
8183                    ASTPair currentAST = new ASTPair();
8184                    AST caseSList_AST = null;
8185                    Token first = LT(1);
8186                    
8187                    statement(COLON);
8188                    astFactory.addASTChild(currentAST, returnAST);
8189                    {
8190                    _loop299:
8191                    do {
8192                            if ((LA(1)==SEMI||LA(1)==NLS)) {
8193                                    sep();
8194                                    {
8195                                    switch ( LA(1)) {
8196                                    case FINAL:
8197                                    case ABSTRACT:
8198                                    case STRICTFP:
8199                                    case LITERAL_import:
8200                                    case LITERAL_static:
8201                                    case LITERAL_def:
8202                                    case AT:
8203                                    case IDENT:
8204                                    case LBRACK:
8205                                    case LPAREN:
8206                                    case LITERAL_class:
8207                                    case LITERAL_interface:
8208                                    case LITERAL_enum:
8209                                    case LITERAL_super:
8210                                    case LITERAL_void:
8211                                    case LITERAL_boolean:
8212                                    case LITERAL_byte:
8213                                    case LITERAL_char:
8214                                    case LITERAL_short:
8215                                    case LITERAL_int:
8216                                    case LITERAL_float:
8217                                    case LITERAL_long:
8218                                    case LITERAL_double:
8219                                    case LITERAL_any:
8220                                    case STAR:
8221                                    case LITERAL_private:
8222                                    case LITERAL_public:
8223                                    case LITERAL_protected:
8224                                    case LITERAL_transient:
8225                                    case LITERAL_native:
8226                                    case LITERAL_threadsafe:
8227                                    case LITERAL_synchronized:
8228                                    case LITERAL_volatile:
8229                                    case LCURLY:
8230                                    case LITERAL_this:
8231                                    case STRING_LITERAL:
8232                                    case LITERAL_if:
8233                                    case LITERAL_while:
8234                                    case LITERAL_with:
8235                                    case LITERAL_switch:
8236                                    case LITERAL_for:
8237                                    case LITERAL_return:
8238                                    case LITERAL_break:
8239                                    case LITERAL_continue:
8240                                    case LITERAL_throw:
8241                                    case LITERAL_assert:
8242                                    case PLUS:
8243                                    case MINUS:
8244                                    case LITERAL_try:
8245                                    case INC:
8246                                    case DEC:
8247                                    case BNOT:
8248                                    case LNOT:
8249                                    case DOLLAR:
8250                                    case STRING_CTOR_START:
8251                                    case LITERAL_new:
8252                                    case LITERAL_true:
8253                                    case LITERAL_false:
8254                                    case LITERAL_null:
8255                                    case NUM_INT:
8256                                    case NUM_FLOAT:
8257                                    case NUM_LONG:
8258                                    case NUM_DOUBLE:
8259                                    case NUM_BIG_INT:
8260                                    case NUM_BIG_DECIMAL:
8261                                    {
8262                                            statement(sepToken);
8263                                            astFactory.addASTChild(currentAST, returnAST);
8264                                            break;
8265                                    }
8266                                    case RCURLY:
8267                                    case SEMI:
8268                                    case NLS:
8269                                    case LITERAL_default:
8270                                    case LITERAL_case:
8271                                    {
8272                                            break;
8273                                    }
8274                                    default:
8275                                    {
8276                                            throw new NoViableAltException(LT(1), getFilename());
8277                                    }
8278                                    }
8279                                    }
8280                            }
8281                            else {
8282                                    break _loop299;
8283                            }
8284                            
8285                    } while (true);
8286                    }
8287                    if ( inputState.guessing==0 ) {
8288                            caseSList_AST = (AST)currentAST.root;
8289                            caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(SLIST,"SLIST",first,LT(1))).add(caseSList_AST));
8290                            currentAST.root = caseSList_AST;
8291                            currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ?
8292                                    caseSList_AST.getFirstChild() : caseSList_AST;
8293                            currentAST.advanceChildToEnd();
8294                    }
8295                    caseSList_AST = (AST)currentAST.root;
8296                    returnAST = caseSList_AST;
8297            }
8298            
8299            public final void controlExpressionList() throws RecognitionException, TokenStreamException {
8300                    
8301                    returnAST = null;
8302                    ASTPair currentAST = new ASTPair();
8303                    AST controlExpressionList_AST = null;
8304                    Token first = LT(1);
8305                    
8306                    strictContextExpression();
8307                    astFactory.addASTChild(currentAST, returnAST);
8308                    {
8309                    _loop320:
8310                    do {
8311                            if ((LA(1)==COMMA)) {
8312                                    match(COMMA);
8313                                    nls();
8314                                    strictContextExpression();
8315                                    astFactory.addASTChild(currentAST, returnAST);
8316                            }
8317                            else {
8318                                    break _loop320;
8319                            }
8320                            
8321                    } while (true);
8322                    }
8323                    if ( inputState.guessing==0 ) {
8324                            controlExpressionList_AST = (AST)currentAST.root;
8325                            controlExpressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ELIST,"ELIST",first,LT(1))).add(controlExpressionList_AST));
8326                            currentAST.root = controlExpressionList_AST;
8327                            currentAST.child = controlExpressionList_AST!=null &&controlExpressionList_AST.getFirstChild()!=null ?
8328                                    controlExpressionList_AST.getFirstChild() : controlExpressionList_AST;
8329                            currentAST.advanceChildToEnd();
8330                    }
8331                    controlExpressionList_AST = (AST)currentAST.root;
8332                    returnAST = controlExpressionList_AST;
8333            }
8334            
8335            public final void handler() throws RecognitionException, TokenStreamException {
8336                    
8337                    returnAST = null;
8338                    ASTPair currentAST = new ASTPair();
8339                    AST handler_AST = null;
8340                    
8341                    AST tmp192_AST = null;
8342                    tmp192_AST = astFactory.create(LT(1));
8343                    astFactory.makeASTRoot(currentAST, tmp192_AST);
8344                    match(LITERAL_catch);
8345                    match(LPAREN);
8346                    parameterDeclaration();
8347                    astFactory.addASTChild(currentAST, returnAST);
8348                    match(RPAREN);
8349                    nlsWarn();
8350                    compoundStatement();
8351                    astFactory.addASTChild(currentAST, returnAST);
8352                    handler_AST = (AST)currentAST.root;
8353                    returnAST = handler_AST;
8354            }
8355            
8356            public final void finallyClause() throws RecognitionException, TokenStreamException {
8357                    
8358                    returnAST = null;
8359                    ASTPair currentAST = new ASTPair();
8360                    AST finallyClause_AST = null;
8361                    
8362                    AST tmp195_AST = null;
8363                    tmp195_AST = astFactory.create(LT(1));
8364                    astFactory.makeASTRoot(currentAST, tmp195_AST);
8365                    match(LITERAL_finally);
8366                    nlsWarn();
8367                    compoundStatement();
8368                    astFactory.addASTChild(currentAST, returnAST);
8369                    finallyClause_AST = (AST)currentAST.root;
8370                    returnAST = finallyClause_AST;
8371            }
8372            
8373            public final void assignmentExpression(
8374                    int lc_stmt
8375            ) throws RecognitionException, TokenStreamException {
8376                    
8377                    returnAST = null;
8378                    ASTPair currentAST = new ASTPair();
8379                    AST assignmentExpression_AST = null;
8380                    
8381                    conditionalExpression(lc_stmt);
8382                    astFactory.addASTChild(currentAST, returnAST);
8383                    {
8384                    switch ( LA(1)) {
8385                    case ASSIGN:
8386                    case PLUS_ASSIGN:
8387                    case MINUS_ASSIGN:
8388                    case STAR_ASSIGN:
8389                    case DIV_ASSIGN:
8390                    case MOD_ASSIGN:
8391                    case SR_ASSIGN:
8392                    case BSR_ASSIGN:
8393                    case SL_ASSIGN:
8394                    case BAND_ASSIGN:
8395                    case BXOR_ASSIGN:
8396                    case BOR_ASSIGN:
8397                    case STAR_STAR_ASSIGN:
8398                    {
8399                            {
8400                            switch ( LA(1)) {
8401                            case ASSIGN:
8402                            {
8403                                    AST tmp196_AST = null;
8404                                    tmp196_AST = astFactory.create(LT(1));
8405                                    astFactory.makeASTRoot(currentAST, tmp196_AST);
8406                                    match(ASSIGN);
8407                                    break;
8408                            }
8409                            case PLUS_ASSIGN:
8410                            {
8411                                    AST tmp197_AST = null;
8412                                    tmp197_AST = astFactory.create(LT(1));
8413                                    astFactory.makeASTRoot(currentAST, tmp197_AST);
8414                                    match(PLUS_ASSIGN);
8415                                    break;
8416                            }
8417                            case MINUS_ASSIGN:
8418                            {
8419                                    AST tmp198_AST = null;
8420                                    tmp198_AST = astFactory.create(LT(1));
8421                                    astFactory.makeASTRoot(currentAST, tmp198_AST);
8422                                    match(MINUS_ASSIGN);
8423                                    break;
8424                            }
8425                            case STAR_ASSIGN:
8426                            {
8427                                    AST tmp199_AST = null;
8428                                    tmp199_AST = astFactory.create(LT(1));
8429                                    astFactory.makeASTRoot(currentAST, tmp199_AST);
8430                                    match(STAR_ASSIGN);
8431                                    break;
8432                            }
8433                            case DIV_ASSIGN:
8434                            {
8435                                    AST tmp200_AST = null;
8436                                    tmp200_AST = astFactory.create(LT(1));
8437                                    astFactory.makeASTRoot(currentAST, tmp200_AST);
8438                                    match(DIV_ASSIGN);
8439                                    break;
8440                            }
8441                            case MOD_ASSIGN:
8442                            {
8443                                    AST tmp201_AST = null;
8444                                    tmp201_AST = astFactory.create(LT(1));
8445                                    astFactory.makeASTRoot(currentAST, tmp201_AST);
8446                                    match(MOD_ASSIGN);
8447                                    break;
8448                            }
8449                            case SR_ASSIGN:
8450                            {
8451                                    AST tmp202_AST = null;
8452                                    tmp202_AST = astFactory.create(LT(1));
8453                                    astFactory.makeASTRoot(currentAST, tmp202_AST);
8454                                    match(SR_ASSIGN);
8455                                    break;
8456                            }
8457                            case BSR_ASSIGN:
8458                            {
8459                                    AST tmp203_AST = null;
8460                                    tmp203_AST = astFactory.create(LT(1));
8461                                    astFactory.makeASTRoot(currentAST, tmp203_AST);
8462                                    match(BSR_ASSIGN);
8463                                    break;
8464                            }
8465                            case SL_ASSIGN:
8466                            {
8467                                    AST tmp204_AST = null;
8468                                    tmp204_AST = astFactory.create(LT(1));
8469                                    astFactory.makeASTRoot(currentAST, tmp204_AST);
8470                                    match(SL_ASSIGN);
8471                                    break;
8472                            }
8473                            case BAND_ASSIGN:
8474                            {
8475                                    AST tmp205_AST = null;
8476                                    tmp205_AST = astFactory.create(LT(1));
8477                                    astFactory.makeASTRoot(currentAST, tmp205_AST);
8478                                    match(BAND_ASSIGN);
8479                                    break;
8480                            }
8481                            case BXOR_ASSIGN:
8482                            {
8483                                    AST tmp206_AST = null;
8484                                    tmp206_AST = astFactory.create(LT(1));
8485                                    astFactory.makeASTRoot(currentAST, tmp206_AST);
8486                                    match(BXOR_ASSIGN);
8487                                    break;
8488                            }
8489                            case BOR_ASSIGN:
8490                            {
8491                                    AST tmp207_AST = null;
8492                                    tmp207_AST = astFactory.create(LT(1));
8493                                    astFactory.makeASTRoot(currentAST, tmp207_AST);
8494                                    match(BOR_ASSIGN);
8495                                    break;
8496                            }
8497                            case STAR_STAR_ASSIGN:
8498                            {
8499                                    AST tmp208_AST = null;
8500                                    tmp208_AST = astFactory.create(LT(1));
8501                                    astFactory.makeASTRoot(currentAST, tmp208_AST);
8502                                    match(STAR_STAR_ASSIGN);
8503                                    break;
8504                            }
8505                            default:
8506                            {
8507                                    throw new NoViableAltException(LT(1), getFilename());
8508                            }
8509                            }
8510                            }
8511                            nls();
8512                            assignmentExpression(lc_stmt == LC_STMT? LC_INIT: 0);
8513                            astFactory.addASTChild(currentAST, returnAST);
8514                            break;
8515                    }
8516                    case EOF:
8517                    case IDENT:
8518                    case LBRACK:
8519                    case RBRACK:
8520                    case LPAREN:
8521                    case LITERAL_super:
8522                    case COMMA:
8523                    case LITERAL_void:
8524                    case LITERAL_boolean:
8525                    case LITERAL_byte:
8526                    case LITERAL_char:
8527                    case LITERAL_short:
8528                    case LITERAL_int:
8529                    case LITERAL_float:
8530                    case LITERAL_long:
8531                    case LITERAL_double:
8532                    case LITERAL_any:
8533                    case RPAREN:
8534                    case LCURLY:
8535                    case RCURLY:
8536                    case SEMI:
8537                    case NLS:
8538                    case LITERAL_default:
8539                    case LITERAL_this:
8540                    case STRING_LITERAL:
8541                    case CLOSABLE_BLOCK_OP:
8542                    case COLON:
8543                    case LITERAL_else:
8544                    case PLUS:
8545                    case MINUS:
8546                    case LITERAL_case:
8547                    case INC:
8548                    case DEC:
8549                    case BNOT:
8550                    case LNOT:
8551                    case DOLLAR:
8552                    case STRING_CTOR_START:
8553                    case LITERAL_new:
8554                    case LITERAL_true:
8555                    case LITERAL_false:
8556                    case LITERAL_null:
8557                    case NUM_INT:
8558                    case NUM_FLOAT:
8559                    case NUM_LONG:
8560                    case NUM_DOUBLE:
8561                    case NUM_BIG_INT:
8562                    case NUM_BIG_DECIMAL:
8563                    {
8564                            break;
8565                    }
8566                    default:
8567                    {
8568                            throw new NoViableAltException(LT(1), getFilename());
8569                    }
8570                    }
8571                    }
8572                    assignmentExpression_AST = (AST)currentAST.root;
8573                    returnAST = assignmentExpression_AST;
8574            }
8575            
8576    /** A "path expression" is a name or other primary, possibly qualified by various
8577     *  forms of dot, and/or followed by various kinds of brackets.
8578     *  It can be used for value or assigned to, or else further qualified, indexed, or called.
8579     *  It is called a "path" because it looks like a linear path through a data structure.
8580     *  Examples:  x.y, x?.y, x*.y, x.@y; x[], x[y], x[y,z]; x(), x(y), x(y,z); x{s}; a.b[n].c(x).d{s}
8581     *  (Compare to a C lvalue, or LeftHandSide in the JLS section 15.26.)
8582     *  General expressions are built up from path expressions, using operators like '+' and '='.
8583     */
8584            public final void pathExpression(
8585                    int lc_stmt
8586            ) throws RecognitionException, TokenStreamException {
8587                    
8588                    returnAST = null;
8589                    ASTPair currentAST = new ASTPair();
8590                    AST pathExpression_AST = null;
8591                    AST pre_AST = null;
8592                    AST pe_AST = null;
8593                    AST apb_AST = null;
8594                    AST prefix = null;
8595                    
8596                    primaryExpression();
8597                    pre_AST = (AST)returnAST;
8598                    if ( inputState.guessing==0 ) {
8599                            prefix = pre_AST;
8600                    }
8601                    {
8602                    _loop327:
8603                    do {
8604                            boolean synPredMatched324 = false;
8605                            if (((_tokenSet_100.member(LA(1))) && (_tokenSet_101.member(LA(2))) && (_tokenSet_95.member(LA(3))))) {
8606                                    int _m324 = mark();
8607                                    synPredMatched324 = true;
8608                                    inputState.guessing++;
8609                                    try {
8610                                            {
8611                                            pathElementStart();
8612                                            }
8613                                    }
8614                                    catch (RecognitionException pe) {
8615                                            synPredMatched324 = false;
8616                                    }
8617                                    rewind(_m324);
8618    inputState.guessing--;
8619                            }
8620                            if ( synPredMatched324 ) {
8621                                    nls();
8622                                    pathElement(prefix);
8623                                    pe_AST = (AST)returnAST;
8624                                    if ( inputState.guessing==0 ) {
8625                                            prefix = pe_AST;
8626                                    }
8627                            }
8628                            else {
8629                                    boolean synPredMatched326 = false;
8630                                    if ((((LA(1)==LCURLY||LA(1)==NLS) && (_tokenSet_16.member(LA(2))) && (_tokenSet_95.member(LA(3))))&&(lc_stmt == LC_STMT || lc_stmt == LC_INIT))) {
8631                                            int _m326 = mark();
8632                                            synPredMatched326 = true;
8633                                            inputState.guessing++;
8634                                            try {
8635                                                    {
8636                                                    nls();
8637                                                    match(LCURLY);
8638                                                    }
8639                                            }
8640                                            catch (RecognitionException pe) {
8641                                                    synPredMatched326 = false;
8642                                            }
8643                                            rewind(_m326);
8644    inputState.guessing--;
8645                                    }
8646                                    if ( synPredMatched326 ) {
8647                                            nlsWarn();
8648                                            appendedBlock(prefix);
8649                                            apb_AST = (AST)returnAST;
8650                                            if ( inputState.guessing==0 ) {
8651                                                    prefix = apb_AST;
8652                                            }
8653                                    }
8654                                    else {
8655                                            break _loop327;
8656                                    }
8657                                    }
8658                            } while (true);
8659                            }
8660                            if ( inputState.guessing==0 ) {
8661                                    pathExpression_AST = (AST)currentAST.root;
8662                                    
8663                                    pathExpression_AST = prefix;
8664                                    lastPathExpression = pathExpression_AST;
8665                                    
8666                                    currentAST.root = pathExpression_AST;
8667                                    currentAST.child = pathExpression_AST!=null &&pathExpression_AST.getFirstChild()!=null ?
8668                                            pathExpression_AST.getFirstChild() : pathExpression_AST;
8669                                    currentAST.advanceChildToEnd();
8670                            }
8671                            pathExpression_AST = (AST)currentAST.root;
8672                            returnAST = pathExpression_AST;
8673                    }
8674                    
8675            public final void primaryExpression() throws RecognitionException, TokenStreamException {
8676                    
8677                    returnAST = null;
8678                    ASTPair currentAST = new ASTPair();
8679                    AST primaryExpression_AST = null;
8680                    
8681                    switch ( LA(1)) {
8682                    case IDENT:
8683                    {
8684                            AST tmp209_AST = null;
8685                            tmp209_AST = astFactory.create(LT(1));
8686                            astFactory.addASTChild(currentAST, tmp209_AST);
8687                            match(IDENT);
8688                            primaryExpression_AST = (AST)currentAST.root;
8689                            break;
8690                    }
8691                    case STRING_LITERAL:
8692                    case LITERAL_true:
8693                    case LITERAL_false:
8694                    case LITERAL_null:
8695                    case NUM_INT:
8696                    case NUM_FLOAT:
8697                    case NUM_LONG:
8698                    case NUM_DOUBLE:
8699                    case NUM_BIG_INT:
8700                    case NUM_BIG_DECIMAL:
8701                    {
8702                            constant();
8703                            astFactory.addASTChild(currentAST, returnAST);
8704                            primaryExpression_AST = (AST)currentAST.root;
8705                            break;
8706                    }
8707                    case LITERAL_new:
8708                    {
8709                            newExpression();
8710                            astFactory.addASTChild(currentAST, returnAST);
8711                            primaryExpression_AST = (AST)currentAST.root;
8712                            break;
8713                    }
8714                    case LITERAL_this:
8715                    {
8716                            AST tmp210_AST = null;
8717                            tmp210_AST = astFactory.create(LT(1));
8718                            astFactory.addASTChild(currentAST, tmp210_AST);
8719                            match(LITERAL_this);
8720                            primaryExpression_AST = (AST)currentAST.root;
8721                            break;
8722                    }
8723                    case LITERAL_super:
8724                    {
8725                            AST tmp211_AST = null;
8726                            tmp211_AST = astFactory.create(LT(1));
8727                            astFactory.addASTChild(currentAST, tmp211_AST);
8728                            match(LITERAL_super);
8729                            primaryExpression_AST = (AST)currentAST.root;
8730                            break;
8731                    }
8732                    case LPAREN:
8733                    {
8734                            parenthesizedExpression();
8735                            astFactory.addASTChild(currentAST, returnAST);
8736                            primaryExpression_AST = (AST)currentAST.root;
8737                            break;
8738                    }
8739                    case LCURLY:
8740                    {
8741                            closableBlockConstructorExpression();
8742                            astFactory.addASTChild(currentAST, returnAST);
8743                            primaryExpression_AST = (AST)currentAST.root;
8744                            break;
8745                    }
8746                    case LBRACK:
8747                    {
8748                            listOrMapConstructorExpression();
8749                            astFactory.addASTChild(currentAST, returnAST);
8750                            primaryExpression_AST = (AST)currentAST.root;
8751                            break;
8752                    }
8753                    case STRING_CTOR_START:
8754                    {
8755                            stringConstructorExpression();
8756                            astFactory.addASTChild(currentAST, returnAST);
8757                            primaryExpression_AST = (AST)currentAST.root;
8758                            break;
8759                    }
8760                    case DOLLAR:
8761                    {
8762                            scopeEscapeExpression();
8763                            astFactory.addASTChild(currentAST, returnAST);
8764                            primaryExpression_AST = (AST)currentAST.root;
8765                            break;
8766                    }
8767                    case LITERAL_void:
8768                    case LITERAL_boolean:
8769                    case LITERAL_byte:
8770                    case LITERAL_char:
8771                    case LITERAL_short:
8772                    case LITERAL_int:
8773                    case LITERAL_float:
8774                    case LITERAL_long:
8775                    case LITERAL_double:
8776                    case LITERAL_any:
8777                    {
8778                            builtInType();
8779                            astFactory.addASTChild(currentAST, returnAST);
8780                            primaryExpression_AST = (AST)currentAST.root;
8781                            break;
8782                    }
8783                    default:
8784                    {
8785                            throw new NoViableAltException(LT(1), getFilename());
8786                    }
8787                    }
8788                    returnAST = primaryExpression_AST;
8789            }
8790            
8791            public final void pathElementStart() throws RecognitionException, TokenStreamException {
8792                    
8793                    returnAST = null;
8794                    ASTPair currentAST = new ASTPair();
8795                    AST pathElementStart_AST = null;
8796                    
8797                    switch ( LA(1)) {
8798                    case DOT:
8799                    case NLS:
8800                    {
8801                            {
8802                            nls();
8803                            AST tmp212_AST = null;
8804                            tmp212_AST = astFactory.create(LT(1));
8805                            match(DOT);
8806                            }
8807                            break;
8808                    }
8809                    case SPREAD_DOT:
8810                    {
8811                            AST tmp213_AST = null;
8812                            tmp213_AST = astFactory.create(LT(1));
8813                            match(SPREAD_DOT);
8814                            break;
8815                    }
8816                    case OPTIONAL_DOT:
8817                    {
8818                            AST tmp214_AST = null;
8819                            tmp214_AST = astFactory.create(LT(1));
8820                            match(OPTIONAL_DOT);
8821                            break;
8822                    }
8823                    case MEMBER_POINTER:
8824                    {
8825                            AST tmp215_AST = null;
8826                            tmp215_AST = astFactory.create(LT(1));
8827                            match(MEMBER_POINTER);
8828                            break;
8829                    }
8830                    case LBRACK:
8831                    {
8832                            AST tmp216_AST = null;
8833                            tmp216_AST = astFactory.create(LT(1));
8834                            match(LBRACK);
8835                            break;
8836                    }
8837                    case LPAREN:
8838                    {
8839                            AST tmp217_AST = null;
8840                            tmp217_AST = astFactory.create(LT(1));
8841                            match(LPAREN);
8842                            break;
8843                    }
8844                    case LCURLY:
8845                    {
8846                            AST tmp218_AST = null;
8847                            tmp218_AST = astFactory.create(LT(1));
8848                            match(LCURLY);
8849                            break;
8850                    }
8851                    default:
8852                    {
8853                            throw new NoViableAltException(LT(1), getFilename());
8854                    }
8855                    }
8856                    returnAST = pathElementStart_AST;
8857            }
8858            
8859            public final void pathElement(
8860                    AST prefix
8861            ) throws RecognitionException, TokenStreamException {
8862                    
8863                    returnAST = null;
8864                    ASTPair currentAST = new ASTPair();
8865                    AST pathElement_AST = null;
8866                    AST mca_AST = null;
8867                    AST apb_AST = null;
8868                    AST ipa_AST = null;
8869                    
8870                    switch ( LA(1)) {
8871                    case DOT:
8872                    case NLS:
8873                    case SPREAD_DOT:
8874                    case OPTIONAL_DOT:
8875                    case MEMBER_POINTER:
8876                    {
8877                            if ( inputState.guessing==0 ) {
8878                                    pathElement_AST = (AST)currentAST.root;
8879                                    pathElement_AST = prefix;
8880                                    currentAST.root = pathElement_AST;
8881                                    currentAST.child = pathElement_AST!=null &&pathElement_AST.getFirstChild()!=null ?
8882                                            pathElement_AST.getFirstChild() : pathElement_AST;
8883                                    currentAST.advanceChildToEnd();
8884                            }
8885                            {
8886                            switch ( LA(1)) {
8887                            case SPREAD_DOT:
8888                            {
8889                                    AST tmp219_AST = null;
8890                                    tmp219_AST = astFactory.create(LT(1));
8891                                    astFactory.makeASTRoot(currentAST, tmp219_AST);
8892                                    match(SPREAD_DOT);
8893                                    break;
8894                            }
8895                            case OPTIONAL_DOT:
8896                            {
8897                                    AST tmp220_AST = null;
8898                                    tmp220_AST = astFactory.create(LT(1));
8899                                    astFactory.makeASTRoot(currentAST, tmp220_AST);
8900                                    match(OPTIONAL_DOT);
8901                                    break;
8902                            }
8903                            case MEMBER_POINTER:
8904                            {
8905                                    AST tmp221_AST = null;
8906                                    tmp221_AST = astFactory.create(LT(1));
8907                                    astFactory.makeASTRoot(currentAST, tmp221_AST);
8908                                    match(MEMBER_POINTER);
8909                                    break;
8910                            }
8911                            case DOT:
8912                            case NLS:
8913                            {
8914                                    {
8915                                    nls();
8916                                    AST tmp222_AST = null;
8917                                    tmp222_AST = astFactory.create(LT(1));
8918                                    astFactory.makeASTRoot(currentAST, tmp222_AST);
8919                                    match(DOT);
8920                                    }
8921                                    break;
8922                            }
8923                            default:
8924                            {
8925                                    throw new NoViableAltException(LT(1), getFilename());
8926                            }
8927                            }
8928                            }
8929                            nls();
8930                            {
8931                            switch ( LA(1)) {
8932                            case LT:
8933                            {
8934                                    typeArguments();
8935                                    astFactory.addASTChild(currentAST, returnAST);
8936                                    break;
8937                            }
8938                            case UNUSED_DO:
8939                            case LITERAL_def:
8940                            case AT:
8941                            case IDENT:
8942                            case LPAREN:
8943                            case LITERAL_class:
8944                            case LITERAL_void:
8945                            case LITERAL_boolean:
8946                            case LITERAL_byte:
8947                            case LITERAL_char:
8948                            case LITERAL_short:
8949                            case LITERAL_int:
8950                            case LITERAL_float:
8951                            case LITERAL_long:
8952                            case LITERAL_double:
8953                            case LITERAL_any:
8954                            case LITERAL_as:
8955                            case LCURLY:
8956                            case STRING_LITERAL:
8957                            case LITERAL_if:
8958                            case LITERAL_else:
8959                            case LITERAL_while:
8960                            case LITERAL_switch:
8961                            case LITERAL_for:
8962                            case LITERAL_in:
8963                            case LITERAL_try:
8964                            case LITERAL_finally:
8965                            case LITERAL_catch:
8966                            case STRING_CTOR_START:
8967                            {
8968                                    break;
8969                            }
8970                            default:
8971                            {
8972                                    throw new NoViableAltException(LT(1), getFilename());
8973                            }
8974                            }
8975                            }
8976                            namePart();
8977                            astFactory.addASTChild(currentAST, returnAST);
8978                            pathElement_AST = (AST)currentAST.root;
8979                            break;
8980                    }
8981                    case LPAREN:
8982                    {
8983                            methodCallArgs(prefix);
8984                            mca_AST = (AST)returnAST;
8985                            if ( inputState.guessing==0 ) {
8986                                    pathElement_AST = (AST)currentAST.root;
8987                                    pathElement_AST = mca_AST;
8988                                    currentAST.root = pathElement_AST;
8989                                    currentAST.child = pathElement_AST!=null &&pathElement_AST.getFirstChild()!=null ?
8990                                            pathElement_AST.getFirstChild() : pathElement_AST;
8991                                    currentAST.advanceChildToEnd();
8992                            }
8993                            pathElement_AST = (AST)currentAST.root;
8994                            break;
8995                    }
8996                    case LCURLY:
8997                    {
8998                            appendedBlock(prefix);
8999                            apb_AST = (AST)returnAST;
9000                            if ( inputState.guessing==0 ) {
9001                                    pathElement_AST = (AST)currentAST.root;
9002                                    pathElement_AST = apb_AST;
9003                                    currentAST.root = pathElement_AST;
9004                                    currentAST.child = pathElement_AST!=null &&pathElement_AST.getFirstChild()!=null ?
9005                                            pathElement_AST.getFirstChild() : pathElement_AST;
9006                                    currentAST.advanceChildToEnd();
9007                            }
9008                            pathElement_AST = (AST)currentAST.root;
9009                            break;
9010                    }
9011                    case LBRACK:
9012                    {
9013                            indexPropertyArgs(prefix);
9014                            ipa_AST = (AST)returnAST;
9015                            if ( inputState.guessing==0 ) {
9016                                    pathElement_AST = (AST)currentAST.root;
9017                                    pathElement_AST = ipa_AST;
9018                                    currentAST.root = pathElement_AST;
9019                                    currentAST.child = pathElement_AST!=null &&pathElement_AST.getFirstChild()!=null ?
9020                                            pathElement_AST.getFirstChild() : pathElement_AST;
9021                                    currentAST.advanceChildToEnd();
9022                            }
9023                            pathElement_AST = (AST)currentAST.root;
9024                            break;
9025                    }
9026                    default:
9027                    {
9028                            throw new NoViableAltException(LT(1), getFilename());
9029                    }
9030                    }
9031                    returnAST = pathElement_AST;
9032            }
9033            
9034    /** An appended block follows any expression.
9035     *  If the expression is not a method call, it is given an empty argument list.
9036     */
9037            public final void appendedBlock(
9038                    AST callee
9039            ) throws RecognitionException, TokenStreamException {
9040                    
9041                    returnAST = null;
9042                    ASTPair currentAST = new ASTPair();
9043                    AST appendedBlock_AST = null;
9044                    
9045                    if ( inputState.guessing==0 ) {
9046                            appendedBlock_AST = (AST)currentAST.root;
9047                            
9048                            // If the callee is itself a call, flatten the AST.
9049                            if (callee != null && callee.getType() == METHOD_CALL) {
9050                            appendedBlock_AST = callee;
9051                            } else {
9052                            AST lbrace = getASTFactory().create(LT(1));
9053                            lbrace.setType(METHOD_CALL);
9054                            if (callee != null)  lbrace.addChild(callee);
9055                            appendedBlock_AST = lbrace;
9056                            }
9057                            
9058                            currentAST.root = appendedBlock_AST;
9059                            currentAST.child = appendedBlock_AST!=null &&appendedBlock_AST.getFirstChild()!=null ?
9060                                    appendedBlock_AST.getFirstChild() : appendedBlock_AST;
9061                            currentAST.advanceChildToEnd();
9062                    }
9063                    closableBlock();
9064                    astFactory.addASTChild(currentAST, returnAST);
9065                    appendedBlock_AST = (AST)currentAST.root;
9066                    returnAST = appendedBlock_AST;
9067            }
9068            
9069    /** This is the grammar for what can follow a dot:  x.a, x.@a, x.&a, x.'a', etc.
9070     *  Note: <code>typeArguments</code> is handled by the caller of <code>namePart</code>.
9071     */
9072            public final void namePart() throws RecognitionException, TokenStreamException {
9073                    
9074                    returnAST = null;
9075                    ASTPair currentAST = new ASTPair();
9076                    AST namePart_AST = null;
9077                    Token  ats = null;
9078                    AST ats_AST = null;
9079                    Token  sl = null;
9080                    AST sl_AST = null;
9081                    Token first = LT(1);
9082                    
9083                    {
9084                    switch ( LA(1)) {
9085                    case AT:
9086                    {
9087                            ats = LT(1);
9088                            ats_AST = astFactory.create(ats);
9089                            astFactory.makeASTRoot(currentAST, ats_AST);
9090                            match(AT);
9091                            if ( inputState.guessing==0 ) {
9092                                    ats_AST.setType(SELECT_SLOT);
9093                            }
9094                            break;
9095                    }
9096                    case UNUSED_DO:
9097                    case LITERAL_def:
9098                    case IDENT:
9099                    case LPAREN:
9100                    case LITERAL_class:
9101                    case LITERAL_void:
9102                    case LITERAL_boolean:
9103                    case LITERAL_byte:
9104                    case LITERAL_char:
9105                    case LITERAL_short:
9106                    case LITERAL_int:
9107                    case LITERAL_float:
9108                    case LITERAL_long:
9109                    case LITERAL_double:
9110                    case LITERAL_any:
9111                    case LITERAL_as:
9112                    case LCURLY:
9113                    case STRING_LITERAL:
9114                    case LITERAL_if:
9115                    case LITERAL_else:
9116                    case LITERAL_while:
9117                    case LITERAL_switch:
9118                    case LITERAL_for:
9119                    case LITERAL_in:
9120                    case LITERAL_try:
9121                    case LITERAL_finally:
9122                    case LITERAL_catch:
9123                    case STRING_CTOR_START:
9124                    {
9125                            break;
9126                    }
9127                    default:
9128                    {
9129                            throw new NoViableAltException(LT(1), getFilename());
9130                    }
9131                    }
9132                    }
9133                    {
9134                    switch ( LA(1)) {
9135                    case IDENT:
9136                    {
9137                            AST tmp223_AST = null;
9138                            tmp223_AST = astFactory.create(LT(1));
9139                            astFactory.addASTChild(currentAST, tmp223_AST);
9140                            match(IDENT);
9141                            break;
9142                    }
9143                    case STRING_LITERAL:
9144                    {
9145                            sl = LT(1);
9146                            sl_AST = astFactory.create(sl);
9147                            astFactory.addASTChild(currentAST, sl_AST);
9148                            match(STRING_LITERAL);
9149                            if ( inputState.guessing==0 ) {
9150                                    sl_AST.setType(IDENT);
9151                            }
9152                            break;
9153                    }
9154                    case LPAREN:
9155                    case STRING_CTOR_START:
9156                    {
9157                            dynamicMemberName();
9158                            astFactory.addASTChild(currentAST, returnAST);
9159                            break;
9160                    }
9161                    case LCURLY:
9162                    {
9163                            openBlock();
9164                            astFactory.addASTChild(currentAST, returnAST);
9165                            break;
9166                    }
9167                    case UNUSED_DO:
9168                    case LITERAL_def:
9169                    case LITERAL_class:
9170                    case LITERAL_void:
9171                    case LITERAL_boolean:
9172                    case LITERAL_byte:
9173                    case LITERAL_char:
9174                    case LITERAL_short:
9175                    case LITERAL_int:
9176                    case LITERAL_float:
9177                    case LITERAL_long:
9178                    case LITERAL_double:
9179                    case LITERAL_any:
9180                    case LITERAL_as:
9181                    case LITERAL_if:
9182                    case LITERAL_else:
9183                    case LITERAL_while:
9184                    case LITERAL_switch:
9185                    case LITERAL_for:
9186                    case LITERAL_in:
9187                    case LITERAL_try:
9188                    case LITERAL_finally:
9189                    case LITERAL_catch:
9190                    {
9191                            keywordPropertyNames();
9192                            astFactory.addASTChild(currentAST, returnAST);
9193                            break;
9194                    }
9195                    default:
9196                    {
9197                            throw new NoViableAltException(LT(1), getFilename());
9198                    }
9199                    }
9200                    }
9201                    namePart_AST = (AST)currentAST.root;
9202                    returnAST = namePart_AST;
9203            }
9204            
9205    /** An expression may be followed by one or both of (...) and {...}.
9206     *  Note: If either is (...) or {...} present, it is a method call.
9207     *  The {...} is appended to the argument list, and matches a formal of type Closure.
9208     *  If there is no method member, a property (or field) is used instead, and must itself be callable.
9209     *  <p>
9210     *  If the methodCallArgs are absent, it is a property reference.
9211     *  If there is no property, it is treated as a field reference, but never a method reference.
9212     *  <p>
9213     *  Arguments in the (...) can be labeled, and the appended block can be labeled also.
9214     *  If there is a mix of unlabeled and labeled arguments,
9215     *  all the labeled arguments must follow the unlabeled arguments,
9216     *  except that the closure (labeled or not) is always a separate final argument.
9217     *  Labeled arguments are collected up and passed as a single argument to a formal of type Map.
9218     *  <p>
9219     *  Therefore, f(x,y, a:p, b:q) {s} is equivalent in all ways to f(x,y, [a:p,b:q], {s}).
9220     *  Spread arguments of sequence type count as unlabeled arguments,
9221     *  while spread arguments of map type count as labeled arguments.
9222     *  (This distinction must sometimes be checked dynamically.)
9223     *
9224     *  A plain unlabeled argument is allowed to match a trailing Map or Closure argument:
9225     *  f(x, a:p) {s}  ===  f(*[ x, [a:p], {s} ])
9226     */
9227            public final void methodCallArgs(
9228                    AST callee
9229            ) throws RecognitionException, TokenStreamException {
9230                    
9231                    returnAST = null;
9232                    ASTPair currentAST = new ASTPair();
9233                    AST methodCallArgs_AST = null;
9234                    Token  lp = null;
9235                    AST lp_AST = null;
9236                    
9237                    if ( inputState.guessing==0 ) {
9238                            methodCallArgs_AST = (AST)currentAST.root;
9239                            methodCallArgs_AST = callee;
9240                            currentAST.root = methodCallArgs_AST;
9241                            currentAST.child = methodCallArgs_AST!=null &&methodCallArgs_AST.getFirstChild()!=null ?
9242                                    methodCallArgs_AST.getFirstChild() : methodCallArgs_AST;
9243                            currentAST.advanceChildToEnd();
9244                    }
9245                    lp = LT(1);
9246                    lp_AST = astFactory.create(lp);
9247                    astFactory.makeASTRoot(currentAST, lp_AST);
9248                    match(LPAREN);
9249                    if ( inputState.guessing==0 ) {
9250                            lp_AST.setType(METHOD_CALL);
9251                    }
9252                    argList();
9253                    astFactory.addASTChild(currentAST, returnAST);
9254                    match(RPAREN);
9255                    methodCallArgs_AST = (AST)currentAST.root;
9256                    returnAST = methodCallArgs_AST;
9257            }
9258            
9259    /** An expression may be followed by [...].
9260     *  Unlike Java, these brackets may contain a general argument list,
9261     *  which is passed to the array element operator, which can make of it what it wants.
9262     *  The brackets may also be empty, as in T[].  This is how Groovy names array types.
9263     *  <p>Returned AST is [INDEX_OP, indexee, ELIST].
9264     */
9265            public final void indexPropertyArgs(
9266                    AST indexee
9267            ) throws RecognitionException, TokenStreamException {
9268                    
9269                    returnAST = null;
9270                    ASTPair currentAST = new ASTPair();
9271                    AST indexPropertyArgs_AST = null;
9272                    Token  lb = null;
9273                    AST lb_AST = null;
9274                    
9275                    if ( inputState.guessing==0 ) {
9276                            indexPropertyArgs_AST = (AST)currentAST.root;
9277                            indexPropertyArgs_AST = indexee;
9278                            currentAST.root = indexPropertyArgs_AST;
9279                            currentAST.child = indexPropertyArgs_AST!=null &&indexPropertyArgs_AST.getFirstChild()!=null ?
9280                                    indexPropertyArgs_AST.getFirstChild() : indexPropertyArgs_AST;
9281                            currentAST.advanceChildToEnd();
9282                    }
9283                    lb = LT(1);
9284                    lb_AST = astFactory.create(lb);
9285                    astFactory.makeASTRoot(currentAST, lb_AST);
9286                    match(LBRACK);
9287                    if ( inputState.guessing==0 ) {
9288                            lb_AST.setType(INDEX_OP);
9289                    }
9290                    argList();
9291                    astFactory.addASTChild(currentAST, returnAST);
9292                    match(RBRACK);
9293                    indexPropertyArgs_AST = (AST)currentAST.root;
9294                    returnAST = indexPropertyArgs_AST;
9295            }
9296            
9297    /** If a dot is followed by a parenthesized or quoted expression, the member is computed dynamically,
9298     *  and the member selection is done only at runtime.  This forces a statically unchecked member access.
9299     */
9300            public final void dynamicMemberName() throws RecognitionException, TokenStreamException {
9301                    
9302                    returnAST = null;
9303                    ASTPair currentAST = new ASTPair();
9304                    AST dynamicMemberName_AST = null;
9305                    Token first = LT(1);
9306                    
9307                    {
9308                    switch ( LA(1)) {
9309                    case LPAREN:
9310                    {
9311                            parenthesizedExpression();
9312                            astFactory.addASTChild(currentAST, returnAST);
9313                            break;
9314                    }
9315                    case STRING_CTOR_START:
9316                    {
9317                            stringConstructorExpression();
9318                            astFactory.addASTChild(currentAST, returnAST);
9319                            break;
9320                    }
9321                    default:
9322                    {
9323                            throw new NoViableAltException(LT(1), getFilename());
9324                    }
9325                    }
9326                    }
9327                    if ( inputState.guessing==0 ) {
9328                            dynamicMemberName_AST = (AST)currentAST.root;
9329                            dynamicMemberName_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(DYNAMIC_MEMBER,"DYNAMIC_MEMBER",first,LT(1))).add(dynamicMemberName_AST));
9330                            currentAST.root = dynamicMemberName_AST;
9331                            currentAST.child = dynamicMemberName_AST!=null &&dynamicMemberName_AST.getFirstChild()!=null ?
9332                                    dynamicMemberName_AST.getFirstChild() : dynamicMemberName_AST;
9333                            currentAST.advanceChildToEnd();
9334                    }
9335                    dynamicMemberName_AST = (AST)currentAST.root;
9336                    returnAST = dynamicMemberName_AST;
9337            }
9338            
9339    /** Allowed keywords after dot (as a member name) and before colon (as a label).
9340     *  TODO: What's the rationale for these?
9341     */
9342            public final void keywordPropertyNames() throws RecognitionException, TokenStreamException {
9343                    
9344                    returnAST = null;
9345                    ASTPair currentAST = new ASTPair();
9346                    AST keywordPropertyNames_AST = null;
9347                    
9348                    {
9349                    switch ( LA(1)) {
9350                    case LITERAL_class:
9351                    {
9352                            AST tmp226_AST = null;
9353                            tmp226_AST = astFactory.create(LT(1));
9354                            astFactory.addASTChild(currentAST, tmp226_AST);
9355                            match(LITERAL_class);
9356                            break;
9357                    }
9358                    case LITERAL_in:
9359                    {
9360                            AST tmp227_AST = null;
9361                            tmp227_AST = astFactory.create(LT(1));
9362                            astFactory.addASTChild(currentAST, tmp227_AST);
9363                            match(LITERAL_in);
9364                            break;
9365                    }
9366                    case LITERAL_as:
9367                    {
9368                            AST tmp228_AST = null;
9369                            tmp228_AST = astFactory.create(LT(1));
9370                            astFactory.addASTChild(currentAST, tmp228_AST);
9371                            match(LITERAL_as);
9372                            break;
9373                    }
9374                    case LITERAL_def:
9375                    {
9376                            AST tmp229_AST = null;
9377                            tmp229_AST = astFactory.create(LT(1));
9378                            astFactory.addASTChild(currentAST, tmp229_AST);
9379                            match(LITERAL_def);
9380                            break;
9381                    }
9382                    case LITERAL_if:
9383                    {
9384                            AST tmp230_AST = null;
9385                            tmp230_AST = astFactory.create(LT(1));
9386                            astFactory.addASTChild(currentAST, tmp230_AST);
9387                            match(LITERAL_if);
9388                            break;
9389                    }
9390                    case LITERAL_else:
9391                    {
9392                            AST tmp231_AST = null;
9393                            tmp231_AST = astFactory.create(LT(1));
9394                            astFactory.addASTChild(currentAST, tmp231_AST);
9395                            match(LITERAL_else);
9396                            break;
9397                    }
9398                    case LITERAL_for:
9399                    {
9400                            AST tmp232_AST = null;
9401                            tmp232_AST = astFactory.create(LT(1));
9402                            astFactory.addASTChild(currentAST, tmp232_AST);
9403                            match(LITERAL_for);
9404                            break;
9405                    }
9406                    case LITERAL_while:
9407                    {
9408                            AST tmp233_AST = null;
9409                            tmp233_AST = astFactory.create(LT(1));
9410                            astFactory.addASTChild(currentAST, tmp233_AST);
9411                            match(LITERAL_while);
9412                            break;
9413                    }
9414                    case UNUSED_DO:
9415                    {
9416                            AST tmp234_AST = null;
9417                            tmp234_AST = astFactory.create(LT(1));
9418                            astFactory.addASTChild(currentAST, tmp234_AST);
9419                            match(UNUSED_DO);
9420                            break;
9421                    }
9422                    case LITERAL_switch:
9423                    {
9424                            AST tmp235_AST = null;
9425                            tmp235_AST = astFactory.create(LT(1));
9426                            astFactory.addASTChild(currentAST, tmp235_AST);
9427                            match(LITERAL_switch);
9428                            break;
9429                    }
9430                    case LITERAL_try:
9431                    {
9432                            AST tmp236_AST = null;
9433                            tmp236_AST = astFactory.create(LT(1));
9434                            astFactory.addASTChild(currentAST, tmp236_AST);
9435                            match(LITERAL_try);
9436                            break;
9437                    }
9438                    case LITERAL_catch:
9439                    {
9440                            AST tmp237_AST = null;
9441                            tmp237_AST = astFactory.create(LT(1));
9442                            astFactory.addASTChild(currentAST, tmp237_AST);
9443                            match(LITERAL_catch);
9444                            break;
9445                    }
9446                    case LITERAL_finally:
9447                    {
9448                            AST tmp238_AST = null;
9449                            tmp238_AST = astFactory.create(LT(1));
9450                            astFactory.addASTChild(currentAST, tmp238_AST);
9451                            match(LITERAL_finally);
9452                            break;
9453                    }
9454                    case LITERAL_void:
9455                    case LITERAL_boolean:
9456                    case LITERAL_byte:
9457                    case LITERAL_char:
9458                    case LITERAL_short:
9459                    case LITERAL_int:
9460                    case LITERAL_float:
9461                    case LITERAL_long:
9462                    case LITERAL_double:
9463                    case LITERAL_any:
9464                    {
9465                            builtInType();
9466                            astFactory.addASTChild(currentAST, returnAST);
9467                            break;
9468                    }
9469                    default:
9470                    {
9471                            throw new NoViableAltException(LT(1), getFilename());
9472                    }
9473                    }
9474                    }
9475                    if ( inputState.guessing==0 ) {
9476                            keywordPropertyNames_AST = (AST)currentAST.root;
9477                            keywordPropertyNames_AST.setType(IDENT);
9478                    }
9479                    keywordPropertyNames_AST = (AST)currentAST.root;
9480                    returnAST = keywordPropertyNames_AST;
9481            }
9482            
9483            public final void parenthesizedExpression() throws RecognitionException, TokenStreamException {
9484                    
9485                    returnAST = null;
9486                    ASTPair currentAST = new ASTPair();
9487                    AST parenthesizedExpression_AST = null;
9488                    
9489                    match(LPAREN);
9490                    strictContextExpression();
9491                    astFactory.addASTChild(currentAST, returnAST);
9492                    match(RPAREN);
9493                    parenthesizedExpression_AST = (AST)currentAST.root;
9494                    returnAST = parenthesizedExpression_AST;
9495            }
9496            
9497            public final void stringConstructorExpression() throws RecognitionException, TokenStreamException {
9498                    
9499                    returnAST = null;
9500                    ASTPair currentAST = new ASTPair();
9501                    AST stringConstructorExpression_AST = null;
9502                    Token  cs = null;
9503                    AST cs_AST = null;
9504                    Token  cm = null;
9505                    AST cm_AST = null;
9506                    Token  ce = null;
9507                    AST ce_AST = null;
9508                    Token first = LT(1);
9509                    
9510                    cs = LT(1);
9511                    cs_AST = astFactory.create(cs);
9512                    astFactory.addASTChild(currentAST, cs_AST);
9513                    match(STRING_CTOR_START);
9514                    if ( inputState.guessing==0 ) {
9515                            cs_AST.setType(STRING_LITERAL);
9516                    }
9517                    stringConstructorValuePart();
9518                    astFactory.addASTChild(currentAST, returnAST);
9519                    {
9520                    _loop434:
9521                    do {
9522                            if ((LA(1)==STRING_CTOR_MIDDLE)) {
9523                                    cm = LT(1);
9524                                    cm_AST = astFactory.create(cm);
9525                                    astFactory.addASTChild(currentAST, cm_AST);
9526                                    match(STRING_CTOR_MIDDLE);
9527                                    if ( inputState.guessing==0 ) {
9528                                            cm_AST.setType(STRING_LITERAL);
9529                                    }
9530                                    stringConstructorValuePart();
9531                                    astFactory.addASTChild(currentAST, returnAST);
9532                            }
9533                            else {
9534                                    break _loop434;
9535                            }
9536                            
9537                    } while (true);
9538                    }
9539                    ce = LT(1);
9540                    ce_AST = astFactory.create(ce);
9541                    astFactory.addASTChild(currentAST, ce_AST);
9542                    match(STRING_CTOR_END);
9543                    if ( inputState.guessing==0 ) {
9544                            stringConstructorExpression_AST = (AST)currentAST.root;
9545                            ce_AST.setType(STRING_LITERAL);
9546                            stringConstructorExpression_AST =
9547                            (AST)astFactory.make( (new ASTArray(2)).add(create(STRING_CONSTRUCTOR,"STRING_CONSTRUCTOR",first,LT(1))).add(stringConstructorExpression_AST));
9548                            
9549                            currentAST.root = stringConstructorExpression_AST;
9550                            currentAST.child = stringConstructorExpression_AST!=null &&stringConstructorExpression_AST.getFirstChild()!=null ?
9551                                    stringConstructorExpression_AST.getFirstChild() : stringConstructorExpression_AST;
9552                            currentAST.advanceChildToEnd();
9553                    }
9554                    stringConstructorExpression_AST = (AST)currentAST.root;
9555                    returnAST = stringConstructorExpression_AST;
9556            }
9557            
9558            public final void logicalOrExpression(
9559                    int lc_stmt
9560            ) throws RecognitionException, TokenStreamException {
9561                    
9562                    returnAST = null;
9563                    ASTPair currentAST = new ASTPair();
9564                    AST logicalOrExpression_AST = null;
9565                    
9566                    logicalAndExpression(lc_stmt);
9567                    astFactory.addASTChild(currentAST, returnAST);
9568                    {
9569                    _loop351:
9570                    do {
9571                            if ((LA(1)==LOR)) {
9572                                    AST tmp241_AST = null;
9573                                    tmp241_AST = astFactory.create(LT(1));
9574                                    astFactory.makeASTRoot(currentAST, tmp241_AST);
9575                                    match(LOR);
9576                                    nls();
9577                                    logicalAndExpression(0);
9578                                    astFactory.addASTChild(currentAST, returnAST);
9579                            }
9580                            else {
9581                                    break _loop351;
9582                            }
9583                            
9584                    } while (true);
9585                    }
9586                    logicalOrExpression_AST = (AST)currentAST.root;
9587                    returnAST = logicalOrExpression_AST;
9588            }
9589            
9590            public final void logicalAndExpression(
9591                    int lc_stmt
9592            ) throws RecognitionException, TokenStreamException {
9593                    
9594                    returnAST = null;
9595                    ASTPair currentAST = new ASTPair();
9596                    AST logicalAndExpression_AST = null;
9597                    
9598                    inclusiveOrExpression(lc_stmt);
9599                    astFactory.addASTChild(currentAST, returnAST);
9600                    {
9601                    _loop354:
9602                    do {
9603                            if ((LA(1)==LAND)) {
9604                                    AST tmp242_AST = null;
9605                                    tmp242_AST = astFactory.create(LT(1));
9606                                    astFactory.makeASTRoot(currentAST, tmp242_AST);
9607                                    match(LAND);
9608                                    nls();
9609                                    inclusiveOrExpression(0);
9610                                    astFactory.addASTChild(currentAST, returnAST);
9611                            }
9612                            else {
9613                                    break _loop354;
9614                            }
9615                            
9616                    } while (true);
9617                    }
9618                    logicalAndExpression_AST = (AST)currentAST.root;
9619                    returnAST = logicalAndExpression_AST;
9620            }
9621            
9622            public final void inclusiveOrExpression(
9623                    int lc_stmt
9624            ) throws RecognitionException, TokenStreamException {
9625                    
9626                    returnAST = null;
9627                    ASTPair currentAST = new ASTPair();
9628                    AST inclusiveOrExpression_AST = null;
9629                    
9630                    exclusiveOrExpression(lc_stmt);
9631                    astFactory.addASTChild(currentAST, returnAST);
9632                    {
9633                    _loop357:
9634                    do {
9635                            if ((LA(1)==BOR)) {
9636                                    AST tmp243_AST = null;
9637                                    tmp243_AST = astFactory.create(LT(1));
9638                                    astFactory.makeASTRoot(currentAST, tmp243_AST);
9639                                    match(BOR);
9640                                    nls();
9641                                    exclusiveOrExpression(0);
9642                                    astFactory.addASTChild(currentAST, returnAST);
9643                            }
9644                            else {
9645                                    break _loop357;
9646                            }
9647                            
9648                    } while (true);
9649                    }
9650                    inclusiveOrExpression_AST = (AST)currentAST.root;
9651                    returnAST = inclusiveOrExpression_AST;
9652            }
9653            
9654            public final void exclusiveOrExpression(
9655                    int lc_stmt
9656            ) throws RecognitionException, TokenStreamException {
9657                    
9658                    returnAST = null;
9659                    ASTPair currentAST = new ASTPair();
9660                    AST exclusiveOrExpression_AST = null;
9661                    
9662                    andExpression(lc_stmt);
9663                    astFactory.addASTChild(currentAST, returnAST);
9664                    {
9665                    _loop360:
9666                    do {
9667                            if ((LA(1)==BXOR)) {
9668                                    AST tmp244_AST = null;
9669                                    tmp244_AST = astFactory.create(LT(1));
9670                                    astFactory.makeASTRoot(currentAST, tmp244_AST);
9671                                    match(BXOR);
9672                                    nls();
9673                                    andExpression(0);
9674                                    astFactory.addASTChild(currentAST, returnAST);
9675                            }
9676                            else {
9677                                    break _loop360;
9678                            }
9679                            
9680                    } while (true);
9681                    }
9682                    exclusiveOrExpression_AST = (AST)currentAST.root;
9683                    returnAST = exclusiveOrExpression_AST;
9684            }
9685            
9686            public final void andExpression(
9687                    int lc_stmt
9688            ) throws RecognitionException, TokenStreamException {
9689                    
9690                    returnAST = null;
9691                    ASTPair currentAST = new ASTPair();
9692                    AST andExpression_AST = null;
9693                    
9694                    regexExpression(lc_stmt);
9695                    astFactory.addASTChild(currentAST, returnAST);
9696                    {
9697                    _loop363:
9698                    do {
9699                            if ((LA(1)==BAND)) {
9700                                    AST tmp245_AST = null;
9701                                    tmp245_AST = astFactory.create(LT(1));
9702                                    astFactory.makeASTRoot(currentAST, tmp245_AST);
9703                                    match(BAND);
9704                                    nls();
9705                                    regexExpression(0);
9706                                    astFactory.addASTChild(currentAST, returnAST);
9707                            }
9708                            else {
9709                                    break _loop363;
9710                            }
9711                            
9712                    } while (true);
9713                    }
9714                    andExpression_AST = (AST)currentAST.root;
9715                    returnAST = andExpression_AST;
9716            }
9717            
9718            public final void regexExpression(
9719                    int lc_stmt
9720            ) throws RecognitionException, TokenStreamException {
9721                    
9722                    returnAST = null;
9723                    ASTPair currentAST = new ASTPair();
9724                    AST regexExpression_AST = null;
9725                    
9726                    equalityExpression(lc_stmt);
9727                    astFactory.addASTChild(currentAST, returnAST);
9728                    {
9729                    _loop367:
9730                    do {
9731                            if ((LA(1)==REGEX_FIND||LA(1)==REGEX_MATCH)) {
9732                                    {
9733                                    switch ( LA(1)) {
9734                                    case REGEX_FIND:
9735                                    {
9736                                            AST tmp246_AST = null;
9737                                            tmp246_AST = astFactory.create(LT(1));
9738                                            astFactory.makeASTRoot(currentAST, tmp246_AST);
9739                                            match(REGEX_FIND);
9740                                            break;
9741                                    }
9742                                    case REGEX_MATCH:
9743                                    {
9744                                            AST tmp247_AST = null;
9745                                            tmp247_AST = astFactory.create(LT(1));
9746                                            astFactory.makeASTRoot(currentAST, tmp247_AST);
9747                                            match(REGEX_MATCH);
9748                                            break;
9749                                    }
9750                                    default:
9751                                    {
9752                                            throw new NoViableAltException(LT(1), getFilename());
9753                                    }
9754                                    }
9755                                    }
9756                                    nls();
9757                                    equalityExpression(0);
9758                                    astFactory.addASTChild(currentAST, returnAST);
9759                            }
9760                            else {
9761                                    break _loop367;
9762                            }
9763                            
9764                    } while (true);
9765                    }
9766                    regexExpression_AST = (AST)currentAST.root;
9767                    returnAST = regexExpression_AST;
9768            }
9769            
9770            public final void equalityExpression(
9771                    int lc_stmt
9772            ) throws RecognitionException, TokenStreamException {
9773                    
9774                    returnAST = null;
9775                    ASTPair currentAST = new ASTPair();
9776                    AST equalityExpression_AST = null;
9777                    
9778                    relationalExpression(lc_stmt);
9779                    astFactory.addASTChild(currentAST, returnAST);
9780                    {
9781                    _loop371:
9782                    do {
9783                            if (((LA(1) >= NOT_EQUAL && LA(1) <= COMPARE_TO))) {
9784                                    {
9785                                    switch ( LA(1)) {
9786                                    case NOT_EQUAL:
9787                                    {
9788                                            AST tmp248_AST = null;
9789                                            tmp248_AST = astFactory.create(LT(1));
9790                                            astFactory.makeASTRoot(currentAST, tmp248_AST);
9791                                            match(NOT_EQUAL);
9792                                            break;
9793                                    }
9794                                    case EQUAL:
9795                                    {
9796                                            AST tmp249_AST = null;
9797                                            tmp249_AST = astFactory.create(LT(1));
9798                                            astFactory.makeASTRoot(currentAST, tmp249_AST);
9799                                            match(EQUAL);
9800                                            break;
9801                                    }
9802                                    case COMPARE_TO:
9803                                    {
9804                                            AST tmp250_AST = null;
9805                                            tmp250_AST = astFactory.create(LT(1));
9806                                            astFactory.makeASTRoot(currentAST, tmp250_AST);
9807                                            match(COMPARE_TO);
9808                                            break;
9809                                    }
9810                                    default:
9811                                    {
9812                                            throw new NoViableAltException(LT(1), getFilename());
9813                                    }
9814                                    }
9815                                    }
9816                                    nls();
9817                                    relationalExpression(0);
9818                                    astFactory.addASTChild(currentAST, returnAST);
9819                            }
9820                            else {
9821                                    break _loop371;
9822                            }
9823                            
9824                    } while (true);
9825                    }
9826                    equalityExpression_AST = (AST)currentAST.root;
9827                    returnAST = equalityExpression_AST;
9828            }
9829            
9830            public final void relationalExpression(
9831                    int lc_stmt
9832            ) throws RecognitionException, TokenStreamException {
9833                    
9834                    returnAST = null;
9835                    ASTPair currentAST = new ASTPair();
9836                    AST relationalExpression_AST = null;
9837                    
9838                    shiftExpression(lc_stmt);
9839                    astFactory.addASTChild(currentAST, returnAST);
9840                    {
9841                    switch ( LA(1)) {
9842                    case EOF:
9843                    case IDENT:
9844                    case LBRACK:
9845                    case RBRACK:
9846                    case LPAREN:
9847                    case QUESTION:
9848                    case LITERAL_super:
9849                    case LT:
9850                    case COMMA:
9851                    case GT:
9852                    case LITERAL_void:
9853                    case LITERAL_boolean:
9854                    case LITERAL_byte:
9855                    case LITERAL_char:
9856                    case LITERAL_short:
9857                    case LITERAL_int:
9858                    case LITERAL_float:
9859                    case LITERAL_long:
9860                    case LITERAL_double:
9861                    case LITERAL_any:
9862                    case RPAREN:
9863                    case ASSIGN:
9864                    case BAND:
9865                    case LCURLY:
9866                    case RCURLY:
9867                    case SEMI:
9868                    case NLS:
9869                    case LITERAL_default:
9870                    case LITERAL_this:
9871                    case STRING_LITERAL:
9872                    case CLOSABLE_BLOCK_OP:
9873                    case COLON:
9874                    case LITERAL_else:
9875                    case LITERAL_in:
9876                    case PLUS:
9877                    case MINUS:
9878                    case LITERAL_case:
9879                    case PLUS_ASSIGN:
9880                    case MINUS_ASSIGN:
9881                    case STAR_ASSIGN:
9882                    case DIV_ASSIGN:
9883                    case MOD_ASSIGN:
9884                    case SR_ASSIGN:
9885                    case BSR_ASSIGN:
9886                    case SL_ASSIGN:
9887                    case BAND_ASSIGN:
9888                    case BXOR_ASSIGN:
9889                    case BOR_ASSIGN:
9890                    case STAR_STAR_ASSIGN:
9891                    case LOR:
9892                    case LAND:
9893                    case BOR:
9894                    case BXOR:
9895                    case REGEX_FIND:
9896                    case REGEX_MATCH:
9897                    case NOT_EQUAL:
9898                    case EQUAL:
9899                    case COMPARE_TO:
9900                    case LE:
9901                    case GE:
9902                    case INC:
9903                    case DEC:
9904                    case BNOT:
9905                    case LNOT:
9906                    case DOLLAR:
9907                    case STRING_CTOR_START:
9908                    case LITERAL_new:
9909                    case LITERAL_true:
9910                    case LITERAL_false:
9911                    case LITERAL_null:
9912                    case NUM_INT:
9913                    case NUM_FLOAT:
9914                    case NUM_LONG:
9915                    case NUM_DOUBLE:
9916                    case NUM_BIG_INT:
9917                    case NUM_BIG_DECIMAL:
9918                    {
9919                            {
9920                            switch ( LA(1)) {
9921                            case LT:
9922                            case GT:
9923                            case LITERAL_in:
9924                            case LE:
9925                            case GE:
9926                            {
9927                                    {
9928                                    switch ( LA(1)) {
9929                                    case LT:
9930                                    {
9931                                            AST tmp251_AST = null;
9932                                            tmp251_AST = astFactory.create(LT(1));
9933                                            astFactory.makeASTRoot(currentAST, tmp251_AST);
9934                                            match(LT);
9935                                            break;
9936                                    }
9937                                    case GT:
9938                                    {
9939                                            AST tmp252_AST = null;
9940                                            tmp252_AST = astFactory.create(LT(1));
9941                                            astFactory.makeASTRoot(currentAST, tmp252_AST);
9942                                            match(GT);
9943                                            break;
9944                                    }
9945                                    case LE:
9946                                    {
9947                                            AST tmp253_AST = null;
9948                                            tmp253_AST = astFactory.create(LT(1));
9949                                            astFactory.makeASTRoot(currentAST, tmp253_AST);
9950                                            match(LE);
9951                                            break;
9952                                    }
9953                                    case GE:
9954                                    {
9955                                            AST tmp254_AST = null;
9956                                            tmp254_AST = astFactory.create(LT(1));
9957                                            astFactory.makeASTRoot(currentAST, tmp254_AST);
9958                                            match(GE);
9959                                            break;
9960                                    }
9961                                    case LITERAL_in:
9962                                    {
9963                                            AST tmp255_AST = null;
9964                                            tmp255_AST = astFactory.create(LT(1));
9965                                            astFactory.makeASTRoot(currentAST, tmp255_AST);
9966                                            match(LITERAL_in);
9967                                            break;
9968                                    }
9969                                    default:
9970                                    {
9971                                            throw new NoViableAltException(LT(1), getFilename());
9972                                    }
9973                                    }
9974                                    }
9975                                    nls();
9976                                    shiftExpression(0);
9977                                    astFactory.addASTChild(currentAST, returnAST);
9978                                    break;
9979                            }
9980                            case EOF:
9981                            case IDENT:
9982                            case LBRACK:
9983                            case RBRACK:
9984                            case LPAREN:
9985                            case QUESTION:
9986                            case LITERAL_super:
9987                            case COMMA:
9988                            case LITERAL_void:
9989                            case LITERAL_boolean:
9990                            case LITERAL_byte:
9991                            case LITERAL_char:
9992                            case LITERAL_short:
9993                            case LITERAL_int:
9994                            case LITERAL_float:
9995                            case LITERAL_long:
9996                            case LITERAL_double:
9997                            case LITERAL_any:
9998                            case RPAREN:
9999                            case ASSIGN:
10000                            case BAND:
10001                            case LCURLY:
10002                            case RCURLY:
10003                            case SEMI:
10004                            case NLS:
10005                            case LITERAL_default:
10006                            case LITERAL_this:
10007                            case STRING_LITERAL:
10008                            case CLOSABLE_BLOCK_OP:
10009                            case COLON:
10010                            case LITERAL_else:
10011                            case PLUS:
10012                            case MINUS:
10013                            case LITERAL_case:
10014                            case PLUS_ASSIGN:
10015                            case MINUS_ASSIGN:
10016                            case STAR_ASSIGN:
10017                            case DIV_ASSIGN:
10018                            case MOD_ASSIGN:
10019                            case SR_ASSIGN:
10020                            case BSR_ASSIGN:
10021                            case SL_ASSIGN:
10022                            case BAND_ASSIGN:
10023                            case BXOR_ASSIGN:
10024                            case BOR_ASSIGN:
10025                            case STAR_STAR_ASSIGN:
10026                            case LOR:
10027                            case LAND:
10028                            case BOR:
10029                            case BXOR:
10030                            case REGEX_FIND:
10031                            case REGEX_MATCH:
10032                            case NOT_EQUAL:
10033                            case EQUAL:
10034                            case COMPARE_TO:
10035                            case INC:
10036                            case DEC:
10037                            case BNOT:
10038                            case LNOT:
10039                            case DOLLAR:
10040                            case STRING_CTOR_START:
10041                            case LITERAL_new:
10042                            case LITERAL_true:
10043                            case LITERAL_false:
10044                            case LITERAL_null:
10045                            case NUM_INT:
10046                            case NUM_FLOAT:
10047                            case NUM_LONG:
10048                            case NUM_DOUBLE:
10049                            case NUM_BIG_INT:
10050                            case NUM_BIG_DECIMAL:
10051                            {
10052                                    break;
10053                            }
10054                            default:
10055                            {
10056                                    throw new NoViableAltException(LT(1), getFilename());
10057                            }
10058                            }
10059                            }
10060                            break;
10061                    }
10062                    case LITERAL_instanceof:
10063                    {
10064                            AST tmp256_AST = null;
10065                            tmp256_AST = astFactory.create(LT(1));
10066                            astFactory.makeASTRoot(currentAST, tmp256_AST);
10067                            match(LITERAL_instanceof);
10068                            nls();
10069                            typeSpec(true);
10070                            astFactory.addASTChild(currentAST, returnAST);
10071                            break;
10072                    }
10073                    case LITERAL_as:
10074                    {
10075                            AST tmp257_AST = null;
10076                            tmp257_AST = astFactory.create(LT(1));
10077                            astFactory.makeASTRoot(currentAST, tmp257_AST);
10078                            match(LITERAL_as);
10079                            nls();
10080                            typeSpec(true);
10081                            astFactory.addASTChild(currentAST, returnAST);
10082                            break;
10083                    }
10084                    default:
10085                    {
10086                            throw new NoViableAltException(LT(1), getFilename());
10087                    }
10088                    }
10089                    }
10090                    relationalExpression_AST = (AST)currentAST.root;
10091                    returnAST = relationalExpression_AST;
10092            }
10093            
10094            public final void additiveExpression(
10095                    int lc_stmt
10096            ) throws RecognitionException, TokenStreamException {
10097                    
10098                    returnAST = null;
10099                    ASTPair currentAST = new ASTPair();
10100                    AST additiveExpression_AST = null;
10101                    
10102                    multiplicativeExpression(lc_stmt);
10103                    astFactory.addASTChild(currentAST, returnAST);
10104                    {
10105                    _loop384:
10106                    do {
10107                            if ((LA(1)==PLUS||LA(1)==MINUS) && (_tokenSet_102.member(LA(2))) && (_tokenSet_95.member(LA(3)))) {
10108                                    {
10109                                    switch ( LA(1)) {
10110                                    case PLUS:
10111                                    {
10112                                            AST tmp258_AST = null;
10113                                            tmp258_AST = astFactory.create(LT(1));
10114                                            astFactory.makeASTRoot(currentAST, tmp258_AST);
10115                                            match(PLUS);
10116                                            break;
10117                                    }
10118                                    case MINUS:
10119                                    {
10120                                            AST tmp259_AST = null;
10121                                            tmp259_AST = astFactory.create(LT(1));
10122                                            astFactory.makeASTRoot(currentAST, tmp259_AST);
10123                                            match(MINUS);
10124                                            break;
10125                                    }
10126                                    default:
10127                                    {
10128                                            throw new NoViableAltException(LT(1), getFilename());
10129                                    }
10130                                    }
10131                                    }
10132                                    nls();
10133                                    multiplicativeExpression(0);
10134                                    astFactory.addASTChild(currentAST, returnAST);
10135                            }
10136                            else {
10137                                    break _loop384;
10138                            }
10139                            
10140                    } while (true);
10141                    }
10142                    additiveExpression_AST = (AST)currentAST.root;
10143                    returnAST = additiveExpression_AST;
10144            }
10145            
10146            public final void multiplicativeExpression(
10147                    int lc_stmt
10148            ) throws RecognitionException, TokenStreamException {
10149                    
10150                    returnAST = null;
10151                    ASTPair currentAST = new ASTPair();
10152                    AST multiplicativeExpression_AST = null;
10153                    
10154                    switch ( LA(1)) {
10155                    case INC:
10156                    {
10157                            {
10158                            AST tmp260_AST = null;
10159                            tmp260_AST = astFactory.create(LT(1));
10160                            astFactory.makeASTRoot(currentAST, tmp260_AST);
10161                            match(INC);
10162                            nls();
10163                            powerExpressionNotPlusMinus(0);
10164                            astFactory.addASTChild(currentAST, returnAST);
10165                            {
10166                            _loop389:
10167                            do {
10168                                    if ((_tokenSet_103.member(LA(1)))) {
10169                                            {
10170                                            switch ( LA(1)) {
10171                                            case STAR:
10172                                            {
10173                                                    AST tmp261_AST = null;
10174                                                    tmp261_AST = astFactory.create(LT(1));
10175                                                    astFactory.makeASTRoot(currentAST, tmp261_AST);
10176                                                    match(STAR);
10177                                                    break;
10178                                            }
10179                                            case DIV:
10180                                            {
10181                                                    AST tmp262_AST = null;
10182                                                    tmp262_AST = astFactory.create(LT(1));
10183                                                    astFactory.makeASTRoot(currentAST, tmp262_AST);
10184                                                    match(DIV);
10185                                                    break;
10186                                            }
10187                                            case MOD:
10188                                            {
10189                                                    AST tmp263_AST = null;
10190                                                    tmp263_AST = astFactory.create(LT(1));
10191                                                    astFactory.makeASTRoot(currentAST, tmp263_AST);
10192                                                    match(MOD);
10193                                                    break;
10194                                            }
10195                                            default:
10196                                            {
10197                                                    throw new NoViableAltException(LT(1), getFilename());
10198                                            }
10199                                            }
10200                                            }
10201                                            nls();
10202                                            powerExpression(0);
10203                                            astFactory.addASTChild(currentAST, returnAST);
10204                                    }
10205                                    else {
10206                                            break _loop389;
10207                                    }
10208                                    
10209                            } while (true);
10210                            }
10211                            }
10212                            multiplicativeExpression_AST = (AST)currentAST.root;
10213                            break;
10214                    }
10215                    case DEC:
10216                    {
10217                            {
10218                            AST tmp264_AST = null;
10219                            tmp264_AST = astFactory.create(LT(1));
10220                            astFactory.makeASTRoot(currentAST, tmp264_AST);
10221                            match(DEC);
10222                            nls();
10223                            powerExpressionNotPlusMinus(0);
10224                            astFactory.addASTChild(currentAST, returnAST);
10225                            {
10226                            _loop393:
10227                            do {
10228                                    if ((_tokenSet_103.member(LA(1)))) {
10229                                            {
10230                                            switch ( LA(1)) {
10231                                            case STAR:
10232                                            {
10233                                                    AST tmp265_AST = null;
10234                                                    tmp265_AST = astFactory.create(LT(1));
10235                                                    astFactory.makeASTRoot(currentAST, tmp265_AST);
10236                                                    match(STAR);
10237                                                    break;
10238                                            }
10239                                            case DIV:
10240                                            {
10241                                                    AST tmp266_AST = null;
10242                                                    tmp266_AST = astFactory.create(LT(1));
10243                                                    astFactory.makeASTRoot(currentAST, tmp266_AST);
10244                                                    match(DIV);
10245                                                    break;
10246                                            }
10247                                            case MOD:
10248                                            {
10249                                                    AST tmp267_AST = null;
10250                                                    tmp267_AST = astFactory.create(LT(1));
10251                                                    astFactory.makeASTRoot(currentAST, tmp267_AST);
10252                                                    match(MOD);
10253                                                    break;
10254                                            }
10255                                            default:
10256                                            {
10257                                                    throw new NoViableAltException(LT(1), getFilename());
10258                                            }
10259                                            }
10260                                            }
10261                                            nls();
10262                                            powerExpression(0);
10263                                            astFactory.addASTChild(currentAST, returnAST);
10264                                    }
10265                                    else {
10266                                            break _loop393;
10267                                    }
10268                                    
10269                            } while (true);
10270                            }
10271                            }
10272                            multiplicativeExpression_AST = (AST)currentAST.root;
10273                            break;
10274                    }
10275                    case MINUS:
10276                    {
10277                            {
10278                            AST tmp268_AST = null;
10279                            tmp268_AST = astFactory.create(LT(1));
10280                            astFactory.makeASTRoot(currentAST, tmp268_AST);
10281                            match(MINUS);
10282                            if ( inputState.guessing==0 ) {
10283                                    tmp268_AST.setType(UNARY_MINUS);
10284                            }
10285                            nls();
10286                            powerExpressionNotPlusMinus(0);
10287                            astFactory.addASTChild(currentAST, returnAST);
10288                            {
10289                            _loop397:
10290                            do {
10291                                    if ((_tokenSet_103.member(LA(1)))) {
10292                                            {
10293                                            switch ( LA(1)) {
10294                                            case STAR:
10295                                            {
10296                                                    AST tmp269_AST = null;
10297                                                    tmp269_AST = astFactory.create(LT(1));
10298                                                    astFactory.makeASTRoot(currentAST, tmp269_AST);
10299                                                    match(STAR);
10300                                                    break;
10301                                            }
10302                                            case DIV:
10303                                            {
10304                                                    AST tmp270_AST = null;
10305                                                    tmp270_AST = astFactory.create(LT(1));
10306                                                    astFactory.makeASTRoot(currentAST, tmp270_AST);
10307                                                    match(DIV);
10308                                                    break;
10309                                            }
10310                                            case MOD:
10311                                            {
10312                                                    AST tmp271_AST = null;
10313                                                    tmp271_AST = astFactory.create(LT(1));
10314                                                    astFactory.makeASTRoot(currentAST, tmp271_AST);
10315                                                    match(MOD);
10316                                                    break;
10317                                            }
10318                                            default:
10319                                            {
10320                                                    throw new NoViableAltException(LT(1), getFilename());
10321                                            }
10322                                            }
10323                                            }
10324                                            nls();
10325                                            powerExpression(0);
10326                                            astFactory.addASTChild(currentAST, returnAST);
10327                                    }
10328                                    else {
10329                                            break _loop397;
10330                                    }
10331                                    
10332                            } while (true);
10333                            }
10334                            }
10335                            multiplicativeExpression_AST = (AST)currentAST.root;
10336                            break;
10337                    }
10338                    case PLUS:
10339                    {
10340                            {
10341                            AST tmp272_AST = null;
10342                            tmp272_AST = astFactory.create(LT(1));
10343                            astFactory.makeASTRoot(currentAST, tmp272_AST);
10344                            match(PLUS);
10345                            if ( inputState.guessing==0 ) {
10346                                    tmp272_AST.setType(UNARY_PLUS);
10347                            }
10348                            nls();
10349                            powerExpressionNotPlusMinus(0);
10350                            astFactory.addASTChild(currentAST, returnAST);
10351                            {
10352                            _loop401:
10353                            do {
10354                                    if ((_tokenSet_103.member(LA(1)))) {
10355                                            {
10356                                            switch ( LA(1)) {
10357                                            case STAR:
10358                                            {
10359                                                    AST tmp273_AST = null;
10360                                                    tmp273_AST = astFactory.create(LT(1));
10361                                                    astFactory.makeASTRoot(currentAST, tmp273_AST);
10362                                                    match(STAR);
10363                                                    break;
10364                                            }
10365                                            case DIV:
10366                                            {
10367                                                    AST tmp274_AST = null;
10368                                                    tmp274_AST = astFactory.create(LT(1));
10369                                                    astFactory.makeASTRoot(currentAST, tmp274_AST);
10370                                                    match(DIV);
10371                                                    break;
10372                                            }
10373                                            case MOD:
10374                                            {
10375                                                    AST tmp275_AST = null;
10376                                                    tmp275_AST = astFactory.create(LT(1));
10377                                                    astFactory.makeASTRoot(currentAST, tmp275_AST);
10378                                                    match(MOD);
10379                                                    break;
10380                                            }
10381                                            default:
10382                                            {
10383                                                    throw new NoViableAltException(LT(1), getFilename());
10384                                            }
10385                                            }
10386                                            }
10387                                            nls();
10388                                            powerExpression(0);
10389                                            astFactory.addASTChild(currentAST, returnAST);
10390                                    }
10391                                    else {
10392                                            break _loop401;
10393                                    }
10394                                    
10395                            } while (true);
10396                            }
10397                            }
10398                            multiplicativeExpression_AST = (AST)currentAST.root;
10399                            break;
10400                    }
10401                    case IDENT:
10402                    case LBRACK:
10403                    case LPAREN:
10404                    case LITERAL_super:
10405                    case LITERAL_void:
10406                    case LITERAL_boolean:
10407                    case LITERAL_byte:
10408                    case LITERAL_char:
10409                    case LITERAL_short:
10410                    case LITERAL_int:
10411                    case LITERAL_float:
10412                    case LITERAL_long:
10413                    case LITERAL_double:
10414                    case LITERAL_any:
10415                    case LCURLY:
10416                    case LITERAL_this:
10417                    case STRING_LITERAL:
10418                    case BNOT:
10419                    case LNOT:
10420                    case DOLLAR:
10421                    case STRING_CTOR_START:
10422                    case LITERAL_new:
10423                    case LITERAL_true:
10424                    case LITERAL_false:
10425                    case LITERAL_null:
10426                    case NUM_INT:
10427                    case NUM_FLOAT:
10428                    case NUM_LONG:
10429                    case NUM_DOUBLE:
10430                    case NUM_BIG_INT:
10431                    case NUM_BIG_DECIMAL:
10432                    {
10433                            {
10434                            powerExpressionNotPlusMinus(lc_stmt);
10435                            astFactory.addASTChild(currentAST, returnAST);
10436                            {
10437                            _loop405:
10438                            do {
10439                                    if ((_tokenSet_103.member(LA(1)))) {
10440                                            {
10441                                            switch ( LA(1)) {
10442                                            case STAR:
10443                                            {
10444                                                    AST tmp276_AST = null;
10445                                                    tmp276_AST = astFactory.create(LT(1));
10446                                                    astFactory.makeASTRoot(currentAST, tmp276_AST);
10447                                                    match(STAR);
10448                                                    break;
10449                                            }
10450                                            case DIV:
10451                                            {
10452                                                    AST tmp277_AST = null;
10453                                                    tmp277_AST = astFactory.create(LT(1));
10454                                                    astFactory.makeASTRoot(currentAST, tmp277_AST);
10455                                                    match(DIV);
10456                                                    break;
10457                                            }
10458                                            case MOD:
10459                                            {
10460                                                    AST tmp278_AST = null;
10461                                                    tmp278_AST = astFactory.create(LT(1));
10462                                                    astFactory.makeASTRoot(currentAST, tmp278_AST);
10463                                                    match(MOD);
10464                                                    break;
10465                                            }
10466                                            default:
10467                                            {
10468                                                    throw new NoViableAltException(LT(1), getFilename());
10469                                            }
10470                                            }
10471                                            }
10472                                            nls();
10473                                            powerExpression(0);
10474                                            astFactory.addASTChild(currentAST, returnAST);
10475                                    }
10476                                    else {
10477                                            break _loop405;
10478                                    }
10479                                    
10480                            } while (true);
10481                            }
10482                            }
10483                            multiplicativeExpression_AST = (AST)currentAST.root;
10484                            break;
10485                    }
10486                    default:
10487                    {
10488                            throw new NoViableAltException(LT(1), getFilename());
10489                    }
10490                    }
10491                    returnAST = multiplicativeExpression_AST;
10492            }
10493            
10494            public final void powerExpressionNotPlusMinus(
10495                    int lc_stmt
10496            ) throws RecognitionException, TokenStreamException {
10497                    
10498                    returnAST = null;
10499                    ASTPair currentAST = new ASTPair();
10500                    AST powerExpressionNotPlusMinus_AST = null;
10501                    
10502                    unaryExpressionNotPlusMinus(lc_stmt);
10503                    astFactory.addASTChild(currentAST, returnAST);
10504                    {
10505                    _loop411:
10506                    do {
10507                            if ((LA(1)==STAR_STAR)) {
10508                                    AST tmp279_AST = null;
10509                                    tmp279_AST = astFactory.create(LT(1));
10510                                    astFactory.makeASTRoot(currentAST, tmp279_AST);
10511                                    match(STAR_STAR);
10512                                    nls();
10513                                    unaryExpression(0);
10514                                    astFactory.addASTChild(currentAST, returnAST);
10515                            }
10516                            else {
10517                                    break _loop411;
10518                            }
10519                            
10520                    } while (true);
10521                    }
10522                    powerExpressionNotPlusMinus_AST = (AST)currentAST.root;
10523                    returnAST = powerExpressionNotPlusMinus_AST;
10524            }
10525            
10526            public final void powerExpression(
10527                    int lc_stmt
10528            ) throws RecognitionException, TokenStreamException {
10529                    
10530                    returnAST = null;
10531                    ASTPair currentAST = new ASTPair();
10532                    AST powerExpression_AST = null;
10533                    
10534                    unaryExpression(lc_stmt);
10535                    astFactory.addASTChild(currentAST, returnAST);
10536                    {
10537                    _loop408:
10538                    do {
10539                            if ((LA(1)==STAR_STAR)) {
10540                                    AST tmp280_AST = null;
10541                                    tmp280_AST = astFactory.create(LT(1));
10542                                    astFactory.makeASTRoot(currentAST, tmp280_AST);
10543                                    match(STAR_STAR);
10544                                    nls();
10545                                    unaryExpression(0);
10546                                    astFactory.addASTChild(currentAST, returnAST);
10547                            }
10548                            else {
10549                                    break _loop408;
10550                            }
10551                            
10552                    } while (true);
10553                    }
10554                    powerExpression_AST = (AST)currentAST.root;
10555                    returnAST = powerExpression_AST;
10556            }
10557            
10558            public final void unaryExpression(
10559                    int lc_stmt
10560            ) throws RecognitionException, TokenStreamException {
10561                    
10562                    returnAST = null;
10563                    ASTPair currentAST = new ASTPair();
10564                    AST unaryExpression_AST = null;
10565                    
10566                    switch ( LA(1)) {
10567                    case INC:
10568                    {
10569                            AST tmp281_AST = null;
10570                            tmp281_AST = astFactory.create(LT(1));
10571                            astFactory.makeASTRoot(currentAST, tmp281_AST);
10572                            match(INC);
10573                            nls();
10574                            unaryExpression(0);
10575                            astFactory.addASTChild(currentAST, returnAST);
10576                            unaryExpression_AST = (AST)currentAST.root;
10577                            break;
10578                    }
10579                    case DEC:
10580                    {
10581                            AST tmp282_AST = null;
10582                            tmp282_AST = astFactory.create(LT(1));
10583                            astFactory.makeASTRoot(currentAST, tmp282_AST);
10584                            match(DEC);
10585                            nls();
10586                            unaryExpression(0);
10587                            astFactory.addASTChild(currentAST, returnAST);
10588                            unaryExpression_AST = (AST)currentAST.root;
10589                            break;
10590                    }
10591                    case MINUS:
10592                    {
10593                            AST tmp283_AST = null;
10594                            tmp283_AST = astFactory.create(LT(1));
10595                            astFactory.makeASTRoot(currentAST, tmp283_AST);
10596                            match(MINUS);
10597                            if ( inputState.guessing==0 ) {
10598                                    tmp283_AST.setType(UNARY_MINUS);
10599                            }
10600                            nls();
10601                            unaryExpression(0);
10602                            astFactory.addASTChild(currentAST, returnAST);
10603                            unaryExpression_AST = (AST)currentAST.root;
10604                            break;
10605                    }
10606                    case PLUS:
10607                    {
10608                            AST tmp284_AST = null;
10609                            tmp284_AST = astFactory.create(LT(1));
10610                            astFactory.makeASTRoot(currentAST, tmp284_AST);
10611                            match(PLUS);
10612                            if ( inputState.guessing==0 ) {
10613                                    tmp284_AST.setType(UNARY_PLUS);
10614                            }
10615                            nls();
10616                            unaryExpression(0);
10617                            astFactory.addASTChild(currentAST, returnAST);
10618                            unaryExpression_AST = (AST)currentAST.root;
10619                            break;
10620                    }
10621                    case IDENT:
10622                    case LBRACK:
10623                    case LPAREN:
10624                    case LITERAL_super:
10625                    case LITERAL_void:
10626                    case LITERAL_boolean:
10627                    case LITERAL_byte:
10628                    case LITERAL_char:
10629                    case LITERAL_short:
10630                    case LITERAL_int:
10631                    case LITERAL_float:
10632                    case LITERAL_long:
10633                    case LITERAL_double:
10634                    case LITERAL_any:
10635                    case LCURLY:
10636                    case LITERAL_this:
10637                    case STRING_LITERAL:
10638                    case BNOT:
10639                    case LNOT:
10640                    case DOLLAR:
10641                    case STRING_CTOR_START:
10642                    case LITERAL_new:
10643                    case LITERAL_true:
10644                    case LITERAL_false:
10645                    case LITERAL_null:
10646                    case NUM_INT:
10647                    case NUM_FLOAT:
10648                    case NUM_LONG:
10649                    case NUM_DOUBLE:
10650                    case NUM_BIG_INT:
10651                    case NUM_BIG_DECIMAL:
10652                    {
10653                            unaryExpressionNotPlusMinus(lc_stmt);
10654                            astFactory.addASTChild(currentAST, returnAST);
10655                            unaryExpression_AST = (AST)currentAST.root;
10656                            break;
10657                    }
10658                    default:
10659                    {
10660                            throw new NoViableAltException(LT(1), getFilename());
10661                    }
10662                    }
10663                    returnAST = unaryExpression_AST;
10664            }
10665            
10666            public final void unaryExpressionNotPlusMinus(
10667                    int lc_stmt
10668            ) throws RecognitionException, TokenStreamException {
10669                    
10670                    returnAST = null;
10671                    ASTPair currentAST = new ASTPair();
10672                    AST unaryExpressionNotPlusMinus_AST = null;
10673                    Token  lpb = null;
10674                    AST lpb_AST = null;
10675                    Token  lp = null;
10676                    AST lp_AST = null;
10677                    
10678                    switch ( LA(1)) {
10679                    case BNOT:
10680                    {
10681                            AST tmp285_AST = null;
10682                            tmp285_AST = astFactory.create(LT(1));
10683                            astFactory.makeASTRoot(currentAST, tmp285_AST);
10684                            match(BNOT);
10685                            nls();
10686                            unaryExpression(0);
10687                            astFactory.addASTChild(currentAST, returnAST);
10688                            unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
10689                            break;
10690                    }
10691                    case LNOT:
10692                    {
10693                            AST tmp286_AST = null;
10694                            tmp286_AST = astFactory.create(LT(1));
10695                            astFactory.makeASTRoot(currentAST, tmp286_AST);
10696                            match(LNOT);
10697                            nls();
10698                            unaryExpression(0);
10699                            astFactory.addASTChild(currentAST, returnAST);
10700                            unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
10701                            break;
10702                    }
10703                    case IDENT:
10704                    case LBRACK:
10705                    case LPAREN:
10706                    case LITERAL_super:
10707                    case LITERAL_void:
10708                    case LITERAL_boolean:
10709                    case LITERAL_byte:
10710                    case LITERAL_char:
10711                    case LITERAL_short:
10712                    case LITERAL_int:
10713                    case LITERAL_float:
10714                    case LITERAL_long:
10715                    case LITERAL_double:
10716                    case LITERAL_any:
10717                    case LCURLY:
10718                    case LITERAL_this:
10719                    case STRING_LITERAL:
10720                    case DOLLAR:
10721                    case STRING_CTOR_START:
10722                    case LITERAL_new:
10723                    case LITERAL_true:
10724                    case LITERAL_false:
10725                    case LITERAL_null:
10726                    case NUM_INT:
10727                    case NUM_FLOAT:
10728                    case NUM_LONG:
10729                    case NUM_DOUBLE:
10730                    case NUM_BIG_INT:
10731                    case NUM_BIG_DECIMAL:
10732                    {
10733                            {
10734                            boolean synPredMatched416 = false;
10735                            if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_any)) && (LA(3)==LBRACK||LA(3)==RPAREN))) {
10736                                    int _m416 = mark();
10737                                    synPredMatched416 = true;
10738                                    inputState.guessing++;
10739                                    try {
10740                                            {
10741                                            match(LPAREN);
10742                                            builtInTypeSpec(true);
10743                                            match(RPAREN);
10744                                            unaryExpression(0);
10745                                            }
10746                                    }
10747                                    catch (RecognitionException pe) {
10748                                            synPredMatched416 = false;
10749                                    }
10750                                    rewind(_m416);
10751    inputState.guessing--;
10752                            }
10753                            if ( synPredMatched416 ) {
10754                                    lpb = LT(1);
10755                                    lpb_AST = astFactory.create(lpb);
10756                                    astFactory.makeASTRoot(currentAST, lpb_AST);
10757                                    match(LPAREN);
10758                                    if ( inputState.guessing==0 ) {
10759                                            lpb_AST.setType(TYPECAST);
10760                                    }
10761                                    builtInTypeSpec(true);
10762                                    astFactory.addASTChild(currentAST, returnAST);
10763                                    match(RPAREN);
10764                                    unaryExpression(0);
10765                                    astFactory.addASTChild(currentAST, returnAST);
10766                            }
10767                            else {
10768                                    boolean synPredMatched418 = false;
10769                                    if (((LA(1)==LPAREN) && (LA(2)==IDENT) && (_tokenSet_104.member(LA(3))))) {
10770                                            int _m418 = mark();
10771                                            synPredMatched418 = true;
10772                                            inputState.guessing++;
10773                                            try {
10774                                                    {
10775                                                    match(LPAREN);
10776                                                    classTypeSpec(true);
10777                                                    match(RPAREN);
10778                                                    unaryExpressionNotPlusMinus(0);
10779                                                    }
10780                                            }
10781                                            catch (RecognitionException pe) {
10782                                                    synPredMatched418 = false;
10783                                            }
10784                                            rewind(_m418);
10785    inputState.guessing--;
10786                                    }
10787                                    if ( synPredMatched418 ) {
10788                                            lp = LT(1);
10789                                            lp_AST = astFactory.create(lp);
10790                                            astFactory.makeASTRoot(currentAST, lp_AST);
10791                                            match(LPAREN);
10792                                            if ( inputState.guessing==0 ) {
10793                                                    lp_AST.setType(TYPECAST);
10794                                            }
10795                                            classTypeSpec(true);
10796                                            astFactory.addASTChild(currentAST, returnAST);
10797                                            match(RPAREN);
10798                                            unaryExpressionNotPlusMinus(0);
10799                                            astFactory.addASTChild(currentAST, returnAST);
10800                                    }
10801                                    else if ((_tokenSet_105.member(LA(1))) && (_tokenSet_95.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
10802                                            postfixExpression(lc_stmt);
10803                                            astFactory.addASTChild(currentAST, returnAST);
10804                                    }
10805                                    else {
10806                                            throw new NoViableAltException(LT(1), getFilename());
10807                                    }
10808                                    }
10809                                    }
10810                                    unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
10811                                    break;
10812                            }
10813                            default:
10814                            {
10815                                    throw new NoViableAltException(LT(1), getFilename());
10816                            }
10817                            }
10818                            returnAST = unaryExpressionNotPlusMinus_AST;
10819                    }
10820                    
10821            public final void postfixExpression(
10822                    int lc_stmt
10823            ) throws RecognitionException, TokenStreamException {
10824                    
10825                    returnAST = null;
10826                    ASTPair currentAST = new ASTPair();
10827                    AST postfixExpression_AST = null;
10828                    Token  in = null;
10829                    AST in_AST = null;
10830                    Token  de = null;
10831                    AST de_AST = null;
10832                    
10833                    pathExpression(lc_stmt);
10834                    astFactory.addASTChild(currentAST, returnAST);
10835                    {
10836                    if ((LA(1)==INC) && (_tokenSet_106.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
10837                            in = LT(1);
10838                            in_AST = astFactory.create(in);
10839                            astFactory.makeASTRoot(currentAST, in_AST);
10840                            match(INC);
10841                            if ( inputState.guessing==0 ) {
10842                                    in_AST.setType(POST_INC);
10843                            }
10844                    }
10845                    else if ((LA(1)==DEC) && (_tokenSet_106.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
10846                            de = LT(1);
10847                            de_AST = astFactory.create(de);
10848                            astFactory.makeASTRoot(currentAST, de_AST);
10849                            match(DEC);
10850                            if ( inputState.guessing==0 ) {
10851                                    de_AST.setType(POST_DEC);
10852                            }
10853                    }
10854                    else if ((_tokenSet_106.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
10855                    }
10856                    else {
10857                            throw new NoViableAltException(LT(1), getFilename());
10858                    }
10859                    
10860                    }
10861                    postfixExpression_AST = (AST)currentAST.root;
10862                    returnAST = postfixExpression_AST;
10863            }
10864            
10865    /** Numeric, string, regexp, boolean, or null constant. */
10866            public final void constant() throws RecognitionException, TokenStreamException {
10867                    
10868                    returnAST = null;
10869                    ASTPair currentAST = new ASTPair();
10870                    AST constant_AST = null;
10871                    
10872                    switch ( LA(1)) {
10873                    case NUM_INT:
10874                    case NUM_FLOAT:
10875                    case NUM_LONG:
10876                    case NUM_DOUBLE:
10877                    case NUM_BIG_INT:
10878                    case NUM_BIG_DECIMAL:
10879                    {
10880                            constantNumber();
10881                            astFactory.addASTChild(currentAST, returnAST);
10882                            constant_AST = (AST)currentAST.root;
10883                            break;
10884                    }
10885                    case STRING_LITERAL:
10886                    {
10887                            AST tmp289_AST = null;
10888                            tmp289_AST = astFactory.create(LT(1));
10889                            astFactory.addASTChild(currentAST, tmp289_AST);
10890                            match(STRING_LITERAL);
10891                            constant_AST = (AST)currentAST.root;
10892                            break;
10893                    }
10894                    case LITERAL_true:
10895                    {
10896                            AST tmp290_AST = null;
10897                            tmp290_AST = astFactory.create(LT(1));
10898                            astFactory.addASTChild(currentAST, tmp290_AST);
10899                            match(LITERAL_true);
10900                            constant_AST = (AST)currentAST.root;
10901                            break;
10902                    }
10903                    case LITERAL_false:
10904                    {
10905                            AST tmp291_AST = null;
10906                            tmp291_AST = astFactory.create(LT(1));
10907                            astFactory.addASTChild(currentAST, tmp291_AST);
10908                            match(LITERAL_false);
10909                            constant_AST = (AST)currentAST.root;
10910                            break;
10911                    }
10912                    case LITERAL_null:
10913                    {
10914                            AST tmp292_AST = null;
10915                            tmp292_AST = astFactory.create(LT(1));
10916                            astFactory.addASTChild(currentAST, tmp292_AST);
10917                            match(LITERAL_null);
10918                            constant_AST = (AST)currentAST.root;
10919                            break;
10920                    }
10921                    default:
10922                    {
10923                            throw new NoViableAltException(LT(1), getFilename());
10924                    }
10925                    }
10926                    returnAST = constant_AST;
10927            }
10928            
10929    /** object instantiation.
10930     *  Trees are built as illustrated by the following input/tree pairs:
10931     *
10932     *  new T()
10933     *
10934     *  new
10935     *   |
10936     *   T --  ELIST
10937     *                 |
10938     *                arg1 -- arg2 -- .. -- argn
10939     *
10940     *  new int[]
10941     *
10942     *  new
10943     *   |
10944     *  int -- ARRAY_DECLARATOR
10945     *
10946     *  new int[] {1,2}
10947     *
10948     *  new
10949     *   |
10950     *  int -- ARRAY_DECLARATOR -- ARRAY_INIT
10951     *                                                                |
10952     *                                                              EXPR -- EXPR
10953     *                                                                |   |
10954     *                                                                1       2
10955     *
10956     *  new int[3]
10957     *  new
10958     *   |
10959     *  int -- ARRAY_DECLARATOR
10960     *                              |
10961     *                        EXPR
10962     *                              |
10963     *                              3
10964     *
10965     *  new int[1][2]
10966     *
10967     *  new
10968     *   |
10969     *  int -- ARRAY_DECLARATOR
10970     *                         |
10971     *               ARRAY_DECLARATOR -- EXPR
10972     *                         |                  |
10973     *                       EXPR                    1
10974     *                         |
10975     *                         2
10976     *
10977     */
10978            public final void newExpression() throws RecognitionException, TokenStreamException {
10979                    
10980                    returnAST = null;
10981                    ASTPair currentAST = new ASTPair();
10982                    AST newExpression_AST = null;
10983                    AST mca_AST = null;
10984                    AST apb1_AST = null;
10985                    
10986                    AST tmp293_AST = null;
10987                    tmp293_AST = astFactory.create(LT(1));
10988                    astFactory.makeASTRoot(currentAST, tmp293_AST);
10989                    match(LITERAL_new);
10990                    nls();
10991                    {
10992                    switch ( LA(1)) {
10993                    case LT:
10994                    {
10995                            typeArguments();
10996                            astFactory.addASTChild(currentAST, returnAST);
10997                            break;
10998                    }
10999                    case IDENT:
11000                    case LITERAL_void:
11001                    case LITERAL_boolean:
11002                    case LITERAL_byte:
11003                    case LITERAL_char:
11004                    case LITERAL_short:
11005                    case LITERAL_int:
11006                    case LITERAL_float:
11007                    case LITERAL_long:
11008                    case LITERAL_double:
11009                    case LITERAL_any:
11010                    {
11011                            break;
11012                    }
11013                    default:
11014                    {
11015                            throw new NoViableAltException(LT(1), getFilename());
11016                    }
11017                    }
11018                    }
11019                    type();
11020                    astFactory.addASTChild(currentAST, returnAST);
11021                    {
11022                    switch ( LA(1)) {
11023                    case LPAREN:
11024                    case NLS:
11025                    {
11026                            nls();
11027                            methodCallArgs(null);
11028                            mca_AST = (AST)returnAST;
11029                            {
11030                            if ((LA(1)==LCURLY) && (_tokenSet_16.member(LA(2))) && (_tokenSet_95.member(LA(3)))) {
11031                                    appendedBlock(mca_AST);
11032                                    apb1_AST = (AST)returnAST;
11033                                    if ( inputState.guessing==0 ) {
11034                                            mca_AST = apb1_AST;
11035                                    }
11036                            }
11037                            else if ((_tokenSet_107.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
11038                            }
11039                            else {
11040                                    throw new NoViableAltException(LT(1), getFilename());
11041                            }
11042                            
11043                            }
11044                            if ( inputState.guessing==0 ) {
11045                                    newExpression_AST = (AST)currentAST.root;
11046                                    newExpression_AST.addChild(mca_AST.getFirstChild());
11047                            }
11048                            break;
11049                    }
11050                    case LBRACK:
11051                    {
11052                            newArrayDeclarator();
11053                            astFactory.addASTChild(currentAST, returnAST);
11054                            break;
11055                    }
11056                    default:
11057                    {
11058                            throw new NoViableAltException(LT(1), getFilename());
11059                    }
11060                    }
11061                    }
11062                    newExpression_AST = (AST)currentAST.root;
11063                    returnAST = newExpression_AST;
11064            }
11065            
11066            public final void closableBlockConstructorExpression() throws RecognitionException, TokenStreamException {
11067                    
11068                    returnAST = null;
11069                    ASTPair currentAST = new ASTPair();
11070                    AST closableBlockConstructorExpression_AST = null;
11071                    
11072                    closableBlock();
11073                    astFactory.addASTChild(currentAST, returnAST);
11074                    closableBlockConstructorExpression_AST = (AST)currentAST.root;
11075                    returnAST = closableBlockConstructorExpression_AST;
11076            }
11077            
11078    /**
11079     * A list constructor is a argument list enclosed in square brackets, without labels.
11080     * Any argument can be decorated with a spread operator (*x), but not a label (a:x).
11081     * Examples:  [], [1], [1,2], [1,*l1,2], [*l1,*l2].
11082     * (The l1, l2 must be a sequence or null.)
11083     * <p>
11084     * A map constructor is an argument list enclosed in square brackets, with labels everywhere,
11085     * except on spread arguments, which stand for whole maps spliced in.
11086     * A colon alone between the brackets also forces the expression to be an empty map constructor.
11087     * Examples: [:], [a:1], [a:1,b:2], [a:1,*:m1,b:2], [*:m1,*:m2]
11088     * (The m1, m2 must be a map or null.)
11089     * Values associated with identical keys overwrite from left to right:
11090     * [a:1,a:2]  ===  [a:2]
11091     * <p>
11092     * Some malformed constructor expressions are not detected in the parser, but in a post-pass.
11093     * Bad examples: [1,b:2], [a:1,2], [:1].
11094     * (Note that method call arguments, by contrast, can be a mix of keyworded and non-keyworded arguments.)
11095     */
11096            public final void listOrMapConstructorExpression() throws RecognitionException, TokenStreamException {
11097                    
11098                    returnAST = null;
11099                    ASTPair currentAST = new ASTPair();
11100                    AST listOrMapConstructorExpression_AST = null;
11101                    Token  lcon = null;
11102                    AST lcon_AST = null;
11103                    Token  emcon = null;
11104                    AST emcon_AST = null;
11105                    boolean hasLabels = false;
11106                    
11107                    if ((LA(1)==LBRACK) && (_tokenSet_108.member(LA(2)))) {
11108                            lcon = LT(1);
11109                            lcon_AST = astFactory.create(lcon);
11110                            astFactory.makeASTRoot(currentAST, lcon_AST);
11111                            match(LBRACK);
11112                            argList();
11113                            astFactory.addASTChild(currentAST, returnAST);
11114                            if ( inputState.guessing==0 ) {
11115                                    hasLabels |= argListHasLabels;
11116                            }
11117                            match(RBRACK);
11118                            if ( inputState.guessing==0 ) {
11119                                    lcon_AST.setType(hasLabels ? MAP_CONSTRUCTOR : LIST_CONSTRUCTOR);
11120                            }
11121                            listOrMapConstructorExpression_AST = (AST)currentAST.root;
11122                    }
11123                    else if ((LA(1)==LBRACK) && (LA(2)==COLON)) {
11124                            emcon = LT(1);
11125                            emcon_AST = astFactory.create(emcon);
11126                            astFactory.makeASTRoot(currentAST, emcon_AST);
11127                            match(LBRACK);
11128                            match(COLON);
11129                            match(RBRACK);
11130                            if ( inputState.guessing==0 ) {
11131                                    emcon_AST.setType(MAP_CONSTRUCTOR);
11132                            }
11133                            listOrMapConstructorExpression_AST = (AST)currentAST.root;
11134                    }
11135                    else {
11136                            throw new NoViableAltException(LT(1), getFilename());
11137                    }
11138                    
11139                    returnAST = listOrMapConstructorExpression_AST;
11140            }
11141            
11142            public final void scopeEscapeExpression() throws RecognitionException, TokenStreamException {
11143                    
11144                    returnAST = null;
11145                    ASTPair currentAST = new ASTPair();
11146                    AST scopeEscapeExpression_AST = null;
11147                    
11148                    AST tmp297_AST = null;
11149                    tmp297_AST = astFactory.create(LT(1));
11150                    astFactory.makeASTRoot(currentAST, tmp297_AST);
11151                    match(DOLLAR);
11152                    if ( inputState.guessing==0 ) {
11153                            tmp297_AST.setType(SCOPE_ESCAPE);
11154                    }
11155                    {
11156                    switch ( LA(1)) {
11157                    case IDENT:
11158                    {
11159                            AST tmp298_AST = null;
11160                            tmp298_AST = astFactory.create(LT(1));
11161                            astFactory.addASTChild(currentAST, tmp298_AST);
11162                            match(IDENT);
11163                            break;
11164                    }
11165                    case DOLLAR:
11166                    {
11167                            scopeEscapeExpression();
11168                            astFactory.addASTChild(currentAST, returnAST);
11169                            break;
11170                    }
11171                    default:
11172                    {
11173                            throw new NoViableAltException(LT(1), getFilename());
11174                    }
11175                    }
11176                    }
11177                    scopeEscapeExpression_AST = (AST)currentAST.root;
11178                    returnAST = scopeEscapeExpression_AST;
11179            }
11180            
11181            public final void stringConstructorValuePart() throws RecognitionException, TokenStreamException {
11182                    
11183                    returnAST = null;
11184                    ASTPair currentAST = new ASTPair();
11185                    AST stringConstructorValuePart_AST = null;
11186                    Token  sp = null;
11187                    AST sp_AST = null;
11188                    
11189                    {
11190                    switch ( LA(1)) {
11191                    case STAR:
11192                    {
11193                            sp = LT(1);
11194                            sp_AST = astFactory.create(sp);
11195                            astFactory.makeASTRoot(currentAST, sp_AST);
11196                            match(STAR);
11197                            if ( inputState.guessing==0 ) {
11198                                    sp_AST.setType(SPREAD_ARG);
11199                            }
11200                            break;
11201                    }
11202                    case IDENT:
11203                    case LCURLY:
11204                    {
11205                            break;
11206                    }
11207                    default:
11208                    {
11209                            throw new NoViableAltException(LT(1), getFilename());
11210                    }
11211                    }
11212                    }
11213                    {
11214                    switch ( LA(1)) {
11215                    case IDENT:
11216                    {
11217                            identifier();
11218                            astFactory.addASTChild(currentAST, returnAST);
11219                            break;
11220                    }
11221                    case LCURLY:
11222                    {
11223                            openOrClosableBlock();
11224                            astFactory.addASTChild(currentAST, returnAST);
11225                            break;
11226                    }
11227                    default:
11228                    {
11229                            throw new NoViableAltException(LT(1), getFilename());
11230                    }
11231                    }
11232                    }
11233                    stringConstructorValuePart_AST = (AST)currentAST.root;
11234                    returnAST = stringConstructorValuePart_AST;
11235            }
11236            
11237            public final void newArrayDeclarator() throws RecognitionException, TokenStreamException {
11238                    
11239                    returnAST = null;
11240                    ASTPair currentAST = new ASTPair();
11241                    AST newArrayDeclarator_AST = null;
11242                    Token  lb = null;
11243                    AST lb_AST = null;
11244                    
11245                    {
11246                    int _cnt465=0;
11247                    _loop465:
11248                    do {
11249                            if ((LA(1)==LBRACK) && (_tokenSet_109.member(LA(2))) && (_tokenSet_95.member(LA(3)))) {
11250                                    lb = LT(1);
11251                                    lb_AST = astFactory.create(lb);
11252                                    astFactory.makeASTRoot(currentAST, lb_AST);
11253                                    match(LBRACK);
11254                                    if ( inputState.guessing==0 ) {
11255                                            lb_AST.setType(ARRAY_DECLARATOR);
11256                                    }
11257                                    {
11258                                    switch ( LA(1)) {
11259                                    case IDENT:
11260                                    case LBRACK:
11261                                    case LPAREN:
11262                                    case LITERAL_super:
11263                                    case LITERAL_void:
11264                                    case LITERAL_boolean:
11265                                    case LITERAL_byte:
11266                                    case LITERAL_char:
11267                                    case LITERAL_short:
11268                                    case LITERAL_int:
11269                                    case LITERAL_float:
11270                                    case LITERAL_long:
11271                                    case LITERAL_double:
11272                                    case LITERAL_any:
11273                                    case LCURLY:
11274                                    case LITERAL_this:
11275                                    case STRING_LITERAL:
11276                                    case PLUS:
11277                                    case MINUS:
11278                                    case INC:
11279                                    case DEC:
11280                                    case BNOT:
11281                                    case LNOT:
11282                                    case DOLLAR:
11283                                    case STRING_CTOR_START:
11284                                    case LITERAL_new:
11285                                    case LITERAL_true:
11286                                    case LITERAL_false:
11287                                    case LITERAL_null:
11288                                    case NUM_INT:
11289                                    case NUM_FLOAT:
11290                                    case NUM_LONG:
11291                                    case NUM_DOUBLE:
11292                                    case NUM_BIG_INT:
11293                                    case NUM_BIG_DECIMAL:
11294                                    {
11295                                            expression(0);
11296                                            astFactory.addASTChild(currentAST, returnAST);
11297                                            break;
11298                                    }
11299                                    case RBRACK:
11300                                    {
11301                                            break;
11302                                    }
11303                                    default:
11304                                    {
11305                                            throw new NoViableAltException(LT(1), getFilename());
11306                                    }
11307                                    }
11308                                    }
11309                                    match(RBRACK);
11310                            }
11311                            else {
11312                                    if ( _cnt465>=1 ) { break _loop465; } else {throw new NoViableAltException(LT(1), getFilename());}
11313                            }
11314                            
11315                            _cnt465++;
11316                    } while (true);
11317                    }
11318                    newArrayDeclarator_AST = (AST)currentAST.root;
11319                    returnAST = newArrayDeclarator_AST;
11320            }
11321            
11322    /** A single argument in (...) or [...].  Corresponds to to a method or closure parameter.
11323     *  May be labeled.  May be modified by the spread operator '*' ('*:' for keywords).
11324     */
11325            public final boolean  argument() throws RecognitionException, TokenStreamException {
11326                    boolean hasLabel = false;
11327                    
11328                    returnAST = null;
11329                    ASTPair currentAST = new ASTPair();
11330                    AST argument_AST = null;
11331                    Token  c = null;
11332                    AST c_AST = null;
11333                    Token  sp = null;
11334                    AST sp_AST = null;
11335                    
11336                    {
11337                    boolean synPredMatched451 = false;
11338                    if (((_tokenSet_110.member(LA(1))) && (_tokenSet_111.member(LA(2))) && (_tokenSet_86.member(LA(3))))) {
11339                            int _m451 = mark();
11340                            synPredMatched451 = true;
11341                            inputState.guessing++;
11342                            try {
11343                                    {
11344                                    argumentLabelStart();
11345                                    }
11346                            }
11347                            catch (RecognitionException pe) {
11348                                    synPredMatched451 = false;
11349                            }
11350                            rewind(_m451);
11351    inputState.guessing--;
11352                    }
11353                    if ( synPredMatched451 ) {
11354                            argumentLabel();
11355                            astFactory.addASTChild(currentAST, returnAST);
11356                            c = LT(1);
11357                            c_AST = astFactory.create(c);
11358                            astFactory.makeASTRoot(currentAST, c_AST);
11359                            match(COLON);
11360                            if ( inputState.guessing==0 ) {
11361                                    c_AST.setType(LABELED_ARG);
11362                            }
11363                            if ( inputState.guessing==0 ) {
11364                                    hasLabel = true;
11365                            }
11366                    }
11367                    else if ((LA(1)==STAR)) {
11368                            sp = LT(1);
11369                            sp_AST = astFactory.create(sp);
11370                            astFactory.makeASTRoot(currentAST, sp_AST);
11371                            match(STAR);
11372                            if ( inputState.guessing==0 ) {
11373                                    sp_AST.setType(SPREAD_ARG);
11374                            }
11375                            {
11376                            switch ( LA(1)) {
11377                            case COLON:
11378                            {
11379                                    match(COLON);
11380                                    if ( inputState.guessing==0 ) {
11381                                            sp_AST.setType(SPREAD_MAP_ARG);
11382                                    }
11383                                    if ( inputState.guessing==0 ) {
11384                                            hasLabel = true;
11385                                    }
11386                                    break;
11387                            }
11388                            case FINAL:
11389                            case ABSTRACT:
11390                            case STRICTFP:
11391                            case LITERAL_static:
11392                            case LITERAL_def:
11393                            case AT:
11394                            case IDENT:
11395                            case LBRACK:
11396                            case LPAREN:
11397                            case LITERAL_super:
11398                            case LITERAL_void:
11399                            case LITERAL_boolean:
11400                            case LITERAL_byte:
11401                            case LITERAL_char:
11402                            case LITERAL_short:
11403                            case LITERAL_int:
11404                            case LITERAL_float:
11405                            case LITERAL_long:
11406                            case LITERAL_double:
11407                            case LITERAL_any:
11408                            case LITERAL_private:
11409                            case LITERAL_public:
11410                            case LITERAL_protected:
11411                            case LITERAL_transient:
11412                            case LITERAL_native:
11413                            case LITERAL_threadsafe:
11414                            case LITERAL_synchronized:
11415                            case LITERAL_volatile:
11416                            case LCURLY:
11417                            case LITERAL_this:
11418                            case STRING_LITERAL:
11419                            case LITERAL_return:
11420                            case LITERAL_break:
11421                            case LITERAL_continue:
11422                            case LITERAL_throw:
11423                            case LITERAL_assert:
11424                            case PLUS:
11425                            case MINUS:
11426                            case INC:
11427                            case DEC:
11428                            case BNOT:
11429                            case LNOT:
11430                            case DOLLAR:
11431                            case STRING_CTOR_START:
11432                            case LITERAL_new:
11433                            case LITERAL_true:
11434                            case LITERAL_false:
11435                            case LITERAL_null:
11436                            case NUM_INT:
11437                            case NUM_FLOAT:
11438                            case NUM_LONG:
11439                            case NUM_DOUBLE:
11440                            case NUM_BIG_INT:
11441                            case NUM_BIG_DECIMAL:
11442                            {
11443                                    break;
11444                            }
11445                            default:
11446                            {
11447                                    throw new NoViableAltException(LT(1), getFilename());
11448                            }
11449                            }
11450                            }
11451                    }
11452                    else if ((_tokenSet_112.member(LA(1))) && (_tokenSet_68.member(LA(2))) && (_tokenSet_20.member(LA(3)))) {
11453                    }
11454                    else {
11455                            throw new NoViableAltException(LT(1), getFilename());
11456                    }
11457                    
11458                    }
11459                    strictContextExpression();
11460                    astFactory.addASTChild(currentAST, returnAST);
11461                    if ( inputState.guessing==0 ) {
11462                            
11463                            require(LA(1) != COLON,
11464                            "illegal colon after argument expression",
11465                            "a complex label expression before a colon must be parenthesized");
11466                            
11467                    }
11468                    argument_AST = (AST)currentAST.root;
11469                    returnAST = argument_AST;
11470                    return hasLabel;
11471            }
11472            
11473    /** For lookahead only.  Fast approximate parse of an argumentLabel followed by a colon. */
11474            public final void argumentLabelStart() throws RecognitionException, TokenStreamException {
11475                    
11476                    returnAST = null;
11477                    ASTPair currentAST = new ASTPair();
11478                    AST argumentLabelStart_AST = null;
11479                    
11480                    {
11481                    switch ( LA(1)) {
11482                    case IDENT:
11483                    {
11484                            AST tmp301_AST = null;
11485                            tmp301_AST = astFactory.create(LT(1));
11486                            match(IDENT);
11487                            break;
11488                    }
11489                    case UNUSED_DO:
11490                    case LITERAL_def:
11491                    case LITERAL_class:
11492                    case LITERAL_void:
11493                    case LITERAL_boolean:
11494                    case LITERAL_byte:
11495                    case LITERAL_char:
11496                    case LITERAL_short:
11497                    case LITERAL_int:
11498                    case LITERAL_float:
11499                    case LITERAL_long:
11500                    case LITERAL_double:
11501                    case LITERAL_any:
11502                    case LITERAL_as:
11503                    case LITERAL_if:
11504                    case LITERAL_else:
11505                    case LITERAL_while:
11506                    case LITERAL_switch:
11507                    case LITERAL_for:
11508                    case LITERAL_in:
11509                    case LITERAL_try:
11510                    case LITERAL_finally:
11511                    case LITERAL_catch:
11512                    {
11513                            keywordPropertyNames();
11514                            break;
11515                    }
11516                    case NUM_INT:
11517                    case NUM_FLOAT:
11518                    case NUM_LONG:
11519                    case NUM_DOUBLE:
11520                    case NUM_BIG_INT:
11521                    case NUM_BIG_DECIMAL:
11522                    {
11523                            constantNumber();
11524                            break;
11525                    }
11526                    case STRING_LITERAL:
11527                    {
11528                            AST tmp302_AST = null;
11529                            tmp302_AST = astFactory.create(LT(1));
11530                            match(STRING_LITERAL);
11531                            break;
11532                    }
11533                    case LBRACK:
11534                    case LPAREN:
11535                    case LCURLY:
11536                    case STRING_CTOR_START:
11537                    {
11538                            balancedBrackets();
11539                            break;
11540                    }
11541                    default:
11542                    {
11543                            throw new NoViableAltException(LT(1), getFilename());
11544                    }
11545                    }
11546                    }
11547                    AST tmp303_AST = null;
11548                    tmp303_AST = astFactory.create(LT(1));
11549                    match(COLON);
11550                    returnAST = argumentLabelStart_AST;
11551            }
11552            
11553    /** A label for an argument is of the form a:b, 'a':b, "a":b, (a):b, etc..
11554     *      The labels in (a:b), ('a':b), and ("a":b) are in all ways equivalent,
11555     *      except that the quotes allow more spellings.
11556     *  Equivalent dynamically computed labels are (('a'):b) and ("${'a'}":b)
11557     *  but not ((a):b) or "$a":b, since the latter cases evaluate (a) as a normal identifier.
11558     *      Bottom line:  If you want a truly variable label, use parens and say ((a):b).
11559     */
11560            public final void argumentLabel() throws RecognitionException, TokenStreamException {
11561                    
11562                    returnAST = null;
11563                    ASTPair currentAST = new ASTPair();
11564                    AST argumentLabel_AST = null;
11565                    Token  id = null;
11566                    AST id_AST = null;
11567                    AST kw_AST = null;
11568                    
11569                    boolean synPredMatched455 = false;
11570                    if (((LA(1)==IDENT) && (LA(2)==COLON) && (_tokenSet_112.member(LA(3))))) {
11571                            int _m455 = mark();
11572                            synPredMatched455 = true;
11573                            inputState.guessing++;
11574                            try {
11575                                    {
11576                                    match(IDENT);
11577                                    }
11578                            }
11579                            catch (RecognitionException pe) {
11580                                    synPredMatched455 = false;
11581                            }
11582                            rewind(_m455);
11583    inputState.guessing--;
11584                    }
11585                    if ( synPredMatched455 ) {
11586                            id = LT(1);
11587                            id_AST = astFactory.create(id);
11588                            astFactory.addASTChild(currentAST, id_AST);
11589                            match(IDENT);
11590                            if ( inputState.guessing==0 ) {
11591                                    id_AST.setType(STRING_LITERAL);
11592                            }
11593                            argumentLabel_AST = (AST)currentAST.root;
11594                    }
11595                    else {
11596                            boolean synPredMatched457 = false;
11597                            if (((_tokenSet_113.member(LA(1))) && (LA(2)==COLON) && (_tokenSet_112.member(LA(3))))) {
11598                                    int _m457 = mark();
11599                                    synPredMatched457 = true;
11600                                    inputState.guessing++;
11601                                    try {
11602                                            {
11603                                            keywordPropertyNames();
11604                                            }
11605                                    }
11606                                    catch (RecognitionException pe) {
11607                                            synPredMatched457 = false;
11608                                    }
11609                                    rewind(_m457);
11610    inputState.guessing--;
11611                            }
11612                            if ( synPredMatched457 ) {
11613                                    keywordPropertyNames();
11614                                    kw_AST = (AST)returnAST;
11615                                    astFactory.addASTChild(currentAST, returnAST);
11616                                    if ( inputState.guessing==0 ) {
11617                                            kw_AST.setType(STRING_LITERAL);
11618                                    }
11619                                    argumentLabel_AST = (AST)currentAST.root;
11620                            }
11621                            else if ((_tokenSet_105.member(LA(1))) && (_tokenSet_111.member(LA(2))) && (_tokenSet_86.member(LA(3)))) {
11622                                    primaryExpression();
11623                                    astFactory.addASTChild(currentAST, returnAST);
11624                                    argumentLabel_AST = (AST)currentAST.root;
11625                            }
11626                            else {
11627                                    throw new NoViableAltException(LT(1), getFilename());
11628                            }
11629                            }
11630                            returnAST = argumentLabel_AST;
11631                    }
11632                    
11633    /** Numeric constant. */
11634            public final void constantNumber() throws RecognitionException, TokenStreamException {
11635                    
11636                    returnAST = null;
11637                    ASTPair currentAST = new ASTPair();
11638                    AST constantNumber_AST = null;
11639                    
11640                    switch ( LA(1)) {
11641                    case NUM_INT:
11642                    {
11643                            AST tmp304_AST = null;
11644                            tmp304_AST = astFactory.create(LT(1));
11645                            astFactory.addASTChild(currentAST, tmp304_AST);
11646                            match(NUM_INT);
11647                            constantNumber_AST = (AST)currentAST.root;
11648                            break;
11649                    }
11650                    case NUM_FLOAT:
11651                    {
11652                            AST tmp305_AST = null;
11653                            tmp305_AST = astFactory.create(LT(1));
11654                            astFactory.addASTChild(currentAST, tmp305_AST);
11655                            match(NUM_FLOAT);
11656                            constantNumber_AST = (AST)currentAST.root;
11657                            break;
11658                    }
11659                    case NUM_LONG:
11660                    {
11661                            AST tmp306_AST = null;
11662                            tmp306_AST = astFactory.create(LT(1));
11663                            astFactory.addASTChild(currentAST, tmp306_AST);
11664                            match(NUM_LONG);
11665                            constantNumber_AST = (AST)currentAST.root;
11666                            break;
11667                    }
11668                    case NUM_DOUBLE:
11669                    {
11670                            AST tmp307_AST = null;
11671                            tmp307_AST = astFactory.create(LT(1));
11672                            astFactory.addASTChild(currentAST, tmp307_AST);
11673                            match(NUM_DOUBLE);
11674                            constantNumber_AST = (AST)currentAST.root;
11675                            break;
11676                    }
11677                    case NUM_BIG_INT:
11678                    {
11679                            AST tmp308_AST = null;
11680                            tmp308_AST = astFactory.create(LT(1));
11681                            astFactory.addASTChild(currentAST, tmp308_AST);
11682                            match(NUM_BIG_INT);
11683                            constantNumber_AST = (AST)currentAST.root;
11684                            break;
11685                    }
11686                    case NUM_BIG_DECIMAL:
11687                    {
11688                            AST tmp309_AST = null;
11689                            tmp309_AST = astFactory.create(LT(1));
11690                            astFactory.addASTChild(currentAST, tmp309_AST);
11691                            match(NUM_BIG_DECIMAL);
11692                            constantNumber_AST = (AST)currentAST.root;
11693                            break;
11694                    }
11695                    default:
11696                    {
11697                            throw new NoViableAltException(LT(1), getFilename());
11698                    }
11699                    }
11700                    returnAST = constantNumber_AST;
11701            }
11702            
11703    /** Fast lookahead across balanced brackets of all sorts. */
11704            public final void balancedBrackets() throws RecognitionException, TokenStreamException {
11705                    
11706                    returnAST = null;
11707                    ASTPair currentAST = new ASTPair();
11708                    AST balancedBrackets_AST = null;
11709                    
11710                    switch ( LA(1)) {
11711                    case LPAREN:
11712                    {
11713                            AST tmp310_AST = null;
11714                            tmp310_AST = astFactory.create(LT(1));
11715                            match(LPAREN);
11716                            balancedTokens();
11717                            AST tmp311_AST = null;
11718                            tmp311_AST = astFactory.create(LT(1));
11719                            match(RPAREN);
11720                            break;
11721                    }
11722                    case LBRACK:
11723                    {
11724                            AST tmp312_AST = null;
11725                            tmp312_AST = astFactory.create(LT(1));
11726                            match(LBRACK);
11727                            balancedTokens();
11728                            AST tmp313_AST = null;
11729                            tmp313_AST = astFactory.create(LT(1));
11730                            match(RBRACK);
11731                            break;
11732                    }
11733                    case LCURLY:
11734                    {
11735                            AST tmp314_AST = null;
11736                            tmp314_AST = astFactory.create(LT(1));
11737                            match(LCURLY);
11738                            balancedTokens();
11739                            AST tmp315_AST = null;
11740                            tmp315_AST = astFactory.create(LT(1));
11741                            match(RCURLY);
11742                            break;
11743                    }
11744                    case STRING_CTOR_START:
11745                    {
11746                            AST tmp316_AST = null;
11747                            tmp316_AST = astFactory.create(LT(1));
11748                            match(STRING_CTOR_START);
11749                            balancedTokens();
11750                            AST tmp317_AST = null;
11751                            tmp317_AST = astFactory.create(LT(1));
11752                            match(STRING_CTOR_END);
11753                            break;
11754                    }
11755                    default:
11756                    {
11757                            throw new NoViableAltException(LT(1), getFilename());
11758                    }
11759                    }
11760                    returnAST = balancedBrackets_AST;
11761            }
11762            
11763            
11764            public static final String[] _tokenNames = {
11765                    "<0>",
11766                    "EOF",
11767                    "<2>",
11768                    "NULL_TREE_LOOKAHEAD",
11769                    "BLOCK",
11770                    "MODIFIERS",
11771                    "OBJBLOCK",
11772                    "SLIST",
11773                    "METHOD_DEF",
11774                    "VARIABLE_DEF",
11775                    "INSTANCE_INIT",
11776                    "STATIC_INIT",
11777                    "TYPE",
11778                    "CLASS_DEF",
11779                    "INTERFACE_DEF",
11780                    "PACKAGE_DEF",
11781                    "ARRAY_DECLARATOR",
11782                    "EXTENDS_CLAUSE",
11783                    "IMPLEMENTS_CLAUSE",
11784                    "PARAMETERS",
11785                    "PARAMETER_DEF",
11786                    "LABELED_STAT",
11787                    "TYPECAST",
11788                    "INDEX_OP",
11789                    "POST_INC",
11790                    "POST_DEC",
11791                    "METHOD_CALL",
11792                    "EXPR",
11793                    "IMPORT",
11794                    "UNARY_MINUS",
11795                    "UNARY_PLUS",
11796                    "CASE_GROUP",
11797                    "ELIST",
11798                    "FOR_INIT",
11799                    "FOR_CONDITION",
11800                    "FOR_ITERATOR",
11801                    "EMPTY_STAT",
11802                    "\"final\"",
11803                    "\"abstract\"",
11804                    "\"goto\"",
11805                    "\"const\"",
11806                    "\"do\"",
11807                    "\"strictfp\"",
11808                    "SUPER_CTOR_CALL",
11809                    "CTOR_CALL",
11810                    "CTOR_IDENT",
11811                    "VARIABLE_PARAMETER_DEF",
11812                    "STRING_CONSTRUCTOR",
11813                    "STRING_CTOR_MIDDLE",
11814                    "CLOSABLE_BLOCK",
11815                    "IMPLICIT_PARAMETERS",
11816                    "SELECT_SLOT",
11817                    "DYNAMIC_MEMBER",
11818                    "LABELED_ARG",
11819                    "SPREAD_ARG",
11820                    "SPREAD_MAP_ARG",
11821                    "SCOPE_ESCAPE",
11822                    "LIST_CONSTRUCTOR",
11823                    "MAP_CONSTRUCTOR",
11824                    "FOR_IN_ITERABLE",
11825                    "STATIC_IMPORT",
11826                    "ENUM_DEF",
11827                    "ENUM_CONSTANT_DEF",
11828                    "FOR_EACH_CLAUSE",
11829                    "ANNOTATION_DEF",
11830                    "ANNOTATIONS",
11831                    "ANNOTATION",
11832                    "ANNOTATION_MEMBER_VALUE_PAIR",
11833                    "ANNOTATION_FIELD_DEF",
11834                    "ANNOTATION_ARRAY_INIT",
11835                    "TYPE_ARGUMENTS",
11836                    "TYPE_ARGUMENT",
11837                    "TYPE_PARAMETERS",
11838                    "TYPE_PARAMETER",
11839                    "WILDCARD_TYPE",
11840                    "TYPE_UPPER_BOUNDS",
11841                    "TYPE_LOWER_BOUNDS",
11842                    "a script header",
11843                    "\"package\"",
11844                    "\"import\"",
11845                    "\"static\"",
11846                    "\"def\"",
11847                    "'@'",
11848                    "an identifier",
11849                    "'['",
11850                    "']'",
11851                    "'.'",
11852                    "'('",
11853                    "\"class\"",
11854                    "\"interface\"",
11855                    "\"enum\"",
11856                    "'?'",
11857                    "\"extends\"",
11858                    "\"super\"",
11859                    "'<'",
11860                    "','",
11861                    "'>'",
11862                    "'>>'",
11863                    "'>>>'",
11864                    "\"void\"",
11865                    "\"boolean\"",
11866                    "\"byte\"",
11867                    "\"char\"",
11868                    "\"short\"",
11869                    "\"int\"",
11870                    "\"float\"",
11871                    "\"long\"",
11872                    "\"double\"",
11873                    "\"any\"",
11874                    "'*'",
11875                    "\"as\"",
11876                    "\"private\"",
11877                    "\"public\"",
11878                    "\"protected\"",
11879                    "\"transient\"",
11880                    "\"native\"",
11881                    "\"threadsafe\"",
11882                    "\"synchronized\"",
11883                    "\"volatile\"",
11884                    "')'",
11885                    "'='",
11886                    "'&'",
11887                    "'{'",
11888                    "'}'",
11889                    "';'",
11890                    "some newlines, whitespace or comments",
11891                    "\"default\"",
11892                    "\"throws\"",
11893                    "\"implements\"",
11894                    "\"this\"",
11895                    "a string literal",
11896                    "'...'",
11897                    "'->'",
11898                    "':'",
11899                    "\"if\"",
11900                    "\"else\"",
11901                    "\"while\"",
11902                    "\"with\"",
11903                    "\"switch\"",
11904                    "\"for\"",
11905                    "\"in\"",
11906                    "\"return\"",
11907                    "\"break\"",
11908                    "\"continue\"",
11909                    "\"throw\"",
11910                    "\"assert\"",
11911                    "'+'",
11912                    "'-'",
11913                    "\"case\"",
11914                    "\"try\"",
11915                    "\"finally\"",
11916                    "\"catch\"",
11917                    "'*.'",
11918                    "'?.'",
11919                    "'.&'",
11920                    "'+='",
11921                    "'-='",
11922                    "'*='",
11923                    "'/='",
11924                    "'%='",
11925                    "'>>='",
11926                    "'>>>='",
11927                    "'<<='",
11928                    "'&='",
11929                    "'^='",
11930                    "'|='",
11931                    "'**='",
11932                    "'||'",
11933                    "'&&'",
11934                    "'|'",
11935                    "'^'",
11936                    "'=~'",
11937                    "'==~'",
11938                    "'!='",
11939                    "'=='",
11940                    "'<=>'",
11941                    "'<='",
11942                    "'>='",
11943                    "\"instanceof\"",
11944                    "'<<'",
11945                    "'..'",
11946                    "'..<'",
11947                    "'++'",
11948                    "'/'",
11949                    "'%'",
11950                    "'--'",
11951                    "'**'",
11952                    "'~'",
11953                    "'!'",
11954                    "'$'",
11955                    "STRING_CTOR_START",
11956                    "a string literal end",
11957                    "\"new\"",
11958                    "\"true\"",
11959                    "\"false\"",
11960                    "\"null\"",
11961                    "a numeric literal",
11962                    "NUM_FLOAT",
11963                    "NUM_LONG",
11964                    "NUM_DOUBLE",
11965                    "NUM_BIG_INT",
11966                    "NUM_BIG_DECIMAL",
11967                    "whitespace",
11968                    "a newline",
11969                    "a single line comment",
11970                    "a comment",
11971                    "a string character",
11972                    "a regular expression literal",
11973                    "a regular expression literal end",
11974                    "a regular expression character",
11975                    "an escape sequence",
11976                    "a newline inside a string",
11977                    "a hexadecimal digit",
11978                    "a character",
11979                    "a letter",
11980                    "a digit",
11981                    "an exponent",
11982                    "a float or double suffix",
11983                    "a big decimal suffix"
11984            };
11985            
11986            protected void buildTokenTypeASTClassMap() {
11987                    tokenTypeToASTClassMap=null;
11988            };
11989            
11990            private static final long[] mk_tokenSet_0() {
11991                    long[] data = { 2L, 3458764513833402368L, 0L, 0L};
11992                    return data;
11993            }
11994            public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
11995            private static final long[] mk_tokenSet_1() {
11996                    long[] data = new long[8];
11997                    data[0]=4810363371522L;
11998                    data[1]=3782953284552065024L;
11999                    data[2]=8809040871139831622L;
12000                    data[3]=1023L;
12001                    return data;
12002            }
12003            public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
12004            private static final long[] mk_tokenSet_2() {
12005                    long[] data = new long[8];
12006                    data[0]=7009386627074L;
12007                    data[1]=4575657221139955712L;
12008                    data[2]=9223372036853727230L;
12009                    data[3]=1023L;
12010                    return data;
12011            }
12012            public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
12013            private static final long[] mk_tokenSet_3() {
12014                    long[] data = new long[8];
12015                    data[0]=288484363337730L;
12016                    data[1]=4611686018427355136L;
12017                    data[2]=-1048577L;
12018                    data[3]=1023L;
12019                    return data;
12020            }
12021            public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
12022            private static final long[] mk_tokenSet_4() {
12023                    long[] data = new long[8];
12024                    data[0]=7009386627074L;
12025                    data[1]=-16384L;
12026                    data[2]=8809322346113400831L;
12027                    data[3]=1023L;
12028                    return data;
12029            }
12030            public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
12031            private static final long[] mk_tokenSet_5() {
12032                    long[] data = new long[8];
12033                    data[0]=288484363337730L;
12034                    data[1]=-16384L;
12035                    data[2]=-1L;
12036                    data[3]=1023L;
12037                    return data;
12038            }
12039            public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
12040            private static final long[] mk_tokenSet_6() {
12041                    long[] data = { 0L, 3458764513820540928L, 128L, 0L, 0L, 0L};
12042                    return data;
12043            }
12044            public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
12045            private static final long[] mk_tokenSet_7() {
12046                    long[] data = new long[8];
12047                    data[0]=4810363371520L;
12048                    data[1]=3782953284552065024L;
12049                    data[2]=8809040871139831750L;
12050                    data[3]=1023L;
12051                    return data;
12052            }
12053            public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
12054            private static final long[] mk_tokenSet_8() {
12055                    long[] data = new long[8];
12056                    data[0]=7009386627074L;
12057                    data[1]=9187343239567343616L;
12058                    data[2]=9223372036854775806L;
12059                    data[3]=1023L;
12060                    return data;
12061            }
12062            public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
12063            private static final long[] mk_tokenSet_9() {
12064                    long[] data = { 2L, 8646911284551352320L, 1048704L, 0L, 0L, 0L};
12065                    return data;
12066            }
12067            public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
12068            private static final long[] mk_tokenSet_10() {
12069                    long[] data = new long[8];
12070                    data[0]=286285340082178L;
12071                    data[1]=9223372036586307584L;
12072                    data[2]=-2L;
12073                    data[3]=1023L;
12074                    return data;
12075            }
12076            public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
12077            private static final long[] mk_tokenSet_11() {
12078                    long[] data = new long[8];
12079                    data[0]=288484363337730L;
12080                    data[1]=-268451840L;
12081                    data[2]=-2L;
12082                    data[3]=1023L;
12083                    return data;
12084            }
12085            public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
12086            private static final long[] mk_tokenSet_12() {
12087                    long[] data = { 4810363371520L, 35923209543942144L, 0L, 0L};
12088                    return data;
12089            }
12090            public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
12091            private static final long[] mk_tokenSet_13() {
12092                    long[] data = { 4810363371520L, 2341766219836620800L, 4L, 0L, 0L, 0L};
12093                    return data;
12094            }
12095            public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
12096            private static final long[] mk_tokenSet_14() {
12097                    long[] data = { 4810363371522L, 8754892091504394240L, 1048708L, 0L, 0L, 0L};
12098                    return data;
12099            }
12100            public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
12101            private static final long[] mk_tokenSet_15() {
12102                    long[] data = new long[8];
12103                    data[0]=4810363371520L;
12104                    data[1]=2630031779945218048L;
12105                    data[2]=8809040871139831622L;
12106                    data[3]=1023L;
12107                    return data;
12108            }
12109            public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
12110            private static final long[] mk_tokenSet_16() {
12111                    long[] data = new long[8];
12112                    data[0]=4810363371520L;
12113                    data[1]=4359414036855488512L;
12114                    data[2]=8809040871139831646L;
12115                    data[3]=1023L;
12116                    return data;
12117            }
12118            public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
12119            private static final long[] mk_tokenSet_17() {
12120                    long[] data = new long[8];
12121                    data[0]=4810363371520L;
12122                    data[1]=324188770731524096L;
12123                    data[2]=8809040871139831622L;
12124                    data[3]=1023L;
12125                    return data;
12126            }
12127            public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
12128            private static final long[] mk_tokenSet_18() {
12129                    long[] data = new long[8];
12130                    data[0]=288484363337730L;
12131                    data[1]=9223372036854743040L;
12132                    data[2]=-1L;
12133                    data[3]=1023L;
12134                    return data;
12135            }
12136            public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
12137            private static final long[] mk_tokenSet_19() {
12138                    long[] data = new long[8];
12139                    data[1]=288265526710894592L;
12140                    data[2]=8809040871137476614L;
12141                    data[3]=1023L;
12142                    return data;
12143            }
12144            public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
12145            private static final long[] mk_tokenSet_20() {
12146                    long[] data = new long[8];
12147                    data[0]=288484363337730L;
12148                    data[1]=9223372036586307584L;
12149                    data[2]=-2L;
12150                    data[3]=1023L;
12151                    return data;
12152            }
12153            public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
12154            private static final long[] mk_tokenSet_21() {
12155                    long[] data = { 4810363371520L, 35888059648507904L, 0L, 0L};
12156                    return data;
12157            }
12158            public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
12159            private static final long[] mk_tokenSet_22() {
12160                    long[] data = { 4810363371520L, 2341731068862726144L, 0L, 0L};
12161                    return data;
12162            }
12163            public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
12164            private static final long[] mk_tokenSet_23() {
12165                    long[] data = { 4810363371520L, 2629961446369198080L, 1L, 0L, 0L, 0L};
12166                    return data;
12167            }
12168            public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
12169            private static final long[] mk_tokenSet_24() {
12170                    long[] data = new long[8];
12171                    data[0]=4810363371522L;
12172                    data[1]=8971100056356618240L;
12173                    data[2]=8809040871140880326L;
12174                    data[3]=1023L;
12175                    return data;
12176            }
12177            public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
12178            private static final long[] mk_tokenSet_25() {
12179                    long[] data = { 2L, 8646981653300248576L, 1048704L, 0L, 0L, 0L};
12180                    return data;
12181            }
12182            public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
12183            private static final long[] mk_tokenSet_26() {
12184                    long[] data = { 0L, 35150012874752L, 0L, 0L};
12185                    return data;
12186            }
12187            public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
12188            private static final long[] mk_tokenSet_27() {
12189                    long[] data = { 0L, 1079508992L, 4L, 0L, 0L, 0L};
12190                    return data;
12191            }
12192            public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
12193            private static final long[] mk_tokenSet_28() {
12194                    long[] data = { 2L, 8718968880745152512L, 1048704L, 0L, 0L, 0L};
12195                    return data;
12196            }
12197            public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
12198            private static final long[] mk_tokenSet_29() {
12199                    long[] data = { 2L, 8718968880736763904L, 1048704L, 0L, 0L, 0L};
12200                    return data;
12201            }
12202            public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
12203            private static final long[] mk_tokenSet_30() {
12204                    long[] data = { 0L, -6917529027640557568L, 0L, 0L};
12205                    return data;
12206            }
12207            public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
12208            private static final long[] mk_tokenSet_31() {
12209                    long[] data = { 2L, 8935141662855266304L, 1048704L, 0L, 0L, 0L};
12210                    return data;
12211            }
12212            public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
12213            private static final long[] mk_tokenSet_32() {
12214                    long[] data = { 2L, 8935141660703064064L, 1048704L, 0L, 0L, 0L};
12215                    return data;
12216            }
12217            public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
12218            private static final long[] mk_tokenSet_33() {
12219                    long[] data = new long[8];
12220                    data[0]=4810363371520L;
12221                    data[1]=4359414036855488512L;
12222                    data[2]=8809040871139831622L;
12223                    data[3]=1023L;
12224                    return data;
12225            }
12226            public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
12227            private static final long[] mk_tokenSet_34() {
12228                    long[] data = { 0L, 1079508992L, 0L, 0L};
12229                    return data;
12230            }
12231            public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
12232            private static final long[] mk_tokenSet_35() {
12233                    long[] data = { 0L, 1261007897813319680L, 4128L, 0L, 0L, 0L};
12234                    return data;
12235            }
12236            public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
12237            private static final long[] mk_tokenSet_36() {
12238                    long[] data = { 0L, 288230376161148928L, 4611686018427387904L, 0L, 0L, 0L};
12239                    return data;
12240            }
12241            public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
12242            private static final long[] mk_tokenSet_37() {
12243                    long[] data = new long[12];
12244                    data[0]=-16L;
12245                    data[1]=-900719925485633537L;
12246                    data[2]=4611686018427387903L;
12247                    data[3]=134217727L;
12248                    return data;
12249            }
12250            public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
12251            private static final long[] mk_tokenSet_38() {
12252                    long[] data = { 4810363371520L, 35888059531067392L, 0L, 0L};
12253                    return data;
12254            }
12255            public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
12256            private static final long[] mk_tokenSet_39() {
12257                    long[] data = { 4810363371520L, 2341766219948818432L, 0L, 0L};
12258                    return data;
12259            }
12260            public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
12261            private static final long[] mk_tokenSet_40() {
12262                    long[] data = { 4810363371522L, 2341766219962449920L, 4L, 0L, 0L, 0L};
12263                    return data;
12264            }
12265            public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
12266            private static final long[] mk_tokenSet_41() {
12267                    long[] data = { 0L, 35151204319232L, 0L, 0L};
12268                    return data;
12269            }
12270            public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
12271            private static final long[] mk_tokenSet_42() {
12272                    long[] data = { 2L, 2305843010335145984L, 4L, 0L, 0L, 0L};
12273                    return data;
12274            }
12275            public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
12276            private static final long[] mk_tokenSet_43() {
12277                    long[] data = { 137438953474L, 4431577217044971520L, 9L, 0L, 0L, 0L};
12278                    return data;
12279            }
12280            public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
12281            private static final long[] mk_tokenSet_44() {
12282                    long[] data = new long[8];
12283                    data[0]=2199023255554L;
12284                    data[1]=9187448792851283968L;
12285                    data[2]=8809322345995705855L;
12286                    data[3]=1023L;
12287                    return data;
12288            }
12289            public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
12290            private static final long[] mk_tokenSet_45() {
12291                    long[] data = new long[8];
12292                    data[0]=2199023255554L;
12293                    data[1]=9187448791777542144L;
12294                    data[2]=8809322345995705855L;
12295                    data[3]=1023L;
12296                    return data;
12297            }
12298            public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
12299            private static final long[] mk_tokenSet_46() {
12300                    long[] data = { 0L, 2305878159360786432L, 0L, 0L};
12301                    return data;
12302            }
12303            public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
12304            private static final long[] mk_tokenSet_47() {
12305                    long[] data = { 4810363371520L, 35888059530674176L, 0L, 0L};
12306                    return data;
12307            }
12308            public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
12309            private static final long[] mk_tokenSet_48() {
12310                    long[] data = { 4810363371520L, 2341766219961401344L, 4L, 0L, 0L, 0L};
12311                    return data;
12312            }
12313            public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
12314            private static final long[] mk_tokenSet_49() {
12315                    long[] data = new long[8];
12316                    data[1]=288265526711156736L;
12317                    data[2]=8809040871137476614L;
12318                    data[3]=1023L;
12319                    return data;
12320            }
12321            public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
12322            private static final long[] mk_tokenSet_50() {
12323                    long[] data = new long[8];
12324                    data[0]=7009386627072L;
12325                    data[1]=4539628424120991744L;
12326                    data[2]=9223371487232131070L;
12327                    data[3]=1023L;
12328                    return data;
12329            }
12330            public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
12331            private static final long[] mk_tokenSet_51() {
12332                    long[] data = { 0L, 4323455644432072704L, 0L, 0L};
12333                    return data;
12334            }
12335            public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
12336            private static final long[] mk_tokenSet_52() {
12337                    long[] data = new long[8];
12338                    data[0]=7009386627074L;
12339                    data[1]=9007199224271405056L;
12340                    data[2]=8809040871153466822L;
12341                    data[3]=1023L;
12342                    return data;
12343            }
12344            public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
12345            private static final long[] mk_tokenSet_53() {
12346                    long[] data = { 4810363371520L, 4359378851937058816L, 0L, 0L};
12347                    return data;
12348            }
12349            public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
12350            private static final long[] mk_tokenSet_54() {
12351                    long[] data = new long[8];
12352                    data[0]=4810363371522L;
12353                    data[1]=8971100056360812544L;
12354                    data[2]=8809040871140880326L;
12355                    data[3]=1023L;
12356                    return data;
12357            }
12358            public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
12359            private static final long[] mk_tokenSet_55() {
12360                    long[] data = { 0L, 2738223757012762624L, 1L, 0L, 0L, 0L};
12361                    return data;
12362            }
12363            public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
12364            private static final long[] mk_tokenSet_56() {
12365                    long[] data = { 0L, 2594108567858970624L, 1L, 0L, 0L, 0L};
12366                    return data;
12367            }
12368            public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
12369            private static final long[] mk_tokenSet_57() {
12370                    long[] data = { 4810363371520L, 4359378883349250048L, 5L, 0L, 0L, 0L};
12371                    return data;
12372            }
12373            public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
12374            private static final long[] mk_tokenSet_58() {
12375                    long[] data = new long[8];
12376                    data[0]=4810363371522L;
12377                    data[1]=9043157683015745536L;
12378                    data[2]=8809040871140880327L;
12379                    data[3]=1023L;
12380                    return data;
12381            }
12382            public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
12383            private static final long[] mk_tokenSet_59() {
12384                    long[] data = { 4810363371520L, 35888059531591680L, 0L, 0L};
12385                    return data;
12386            }
12387            public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
12388            private static final long[] mk_tokenSet_60() {
12389                    long[] data = { 4810363371520L, 2341731068753674240L, 0L, 0L};
12390                    return data;
12391            }
12392            public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
12393            private static final long[] mk_tokenSet_61() {
12394                    long[] data = { 4810363371520L, 2377795015789182976L, 8L, 0L, 0L, 0L};
12395                    return data;
12396            }
12397            public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
12398            private static final long[] mk_tokenSet_62() {
12399                    long[] data = { 4810363371520L, 4143206073077006336L, 4L, 0L, 0L, 0L};
12400                    return data;
12401            }
12402            public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
12403            private static final long[] mk_tokenSet_63() {
12404                    long[] data = { 0L, 4107282862317764608L, 0L, 0L};
12405                    return data;
12406            }
12407            public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
12408            private static final long[] mk_tokenSet_64() {
12409                    long[] data = new long[8];
12410                    data[0]=4810363371522L;
12411                    data[1]=9007093667929718784L;
12412                    data[2]=8809040871138525326L;
12413                    data[3]=1023L;
12414                    return data;
12415            }
12416            public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
12417            private static final long[] mk_tokenSet_65() {
12418                    long[] data = { 0L, 2305843009214480384L, 0L, 0L};
12419                    return data;
12420            }
12421            public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
12422            private static final long[] mk_tokenSet_66() {
12423                    long[] data = { 0L, 4323455644432334848L, 0L, 0L};
12424                    return data;
12425            }
12426            public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
12427            private static final long[] mk_tokenSet_67() {
12428                    long[] data = new long[8];
12429                    data[0]=7009386627072L;
12430                    data[1]=324259139375005696L;
12431                    data[2]=8809040871152418246L;
12432                    data[3]=1023L;
12433                    return data;
12434            }
12435            public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
12436            private static final long[] mk_tokenSet_68() {
12437                    long[] data = new long[8];
12438                    data[0]=7009386627072L;
12439                    data[1]=4611686018158919680L;
12440                    data[2]=9223372036853727230L;
12441                    data[3]=1023L;
12442                    return data;
12443            }
12444            public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
12445            private static final long[] mk_tokenSet_69() {
12446                    long[] data = { 137438953472L, 36063947032231936L, 8L, 0L, 0L, 0L};
12447                    return data;
12448            }
12449            public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
12450            private static final long[] mk_tokenSet_70() {
12451                    long[] data = { 0L, 4323455644427878400L, 0L, 0L};
12452                    return data;
12453            }
12454            public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
12455            private static final long[] mk_tokenSet_71() {
12456                    long[] data = new long[8];
12457                    data[0]=4810363371520L;
12458                    data[1]=4359414040076713984L;
12459                    data[2]=8809040871139831622L;
12460                    data[3]=1023L;
12461                    return data;
12462            }
12463            public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
12464            private static final long[] mk_tokenSet_72() {
12465                    long[] data = new long[8];
12466                    data[0]=4810363371520L;
12467                    data[1]=4395407652723556352L;
12468                    data[2]=8809040871137476622L;
12469                    data[3]=1023L;
12470                    return data;
12471            }
12472            public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
12473            private static final long[] mk_tokenSet_73() {
12474                    long[] data = { 0L, 2594073387517607936L, 0L, 0L};
12475                    return data;
12476            }
12477            public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
12478            private static final long[] mk_tokenSet_74() {
12479                    long[] data = new long[8];
12480                    data[0]=4810363371520L;
12481                    data[1]=4359414037929230336L;
12482                    data[2]=8809040871139831622L;
12483                    data[3]=1023L;
12484                    return data;
12485            }
12486            public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
12487            private static final long[] mk_tokenSet_75() {
12488                    long[] data = new long[8];
12489                    data[0]=7009386627072L;
12490                    data[1]=4575657221139955712L;
12491                    data[2]=9223372036853727230L;
12492                    data[3]=1023L;
12493                    return data;
12494            }
12495            public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
12496            private static final long[] mk_tokenSet_76() {
12497                    long[] data = { 0L, 1610612736L, 2L, 0L, 0L, 0L};
12498                    return data;
12499            }
12500            public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
12501            private static final long[] mk_tokenSet_77() {
12502                    long[] data = { 0L, 2305878159369175040L, 0L, 0L};
12503                    return data;
12504            }
12505            public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
12506            private static final long[] mk_tokenSet_78() {
12507                    long[] data = new long[8];
12508                    data[0]=7009386627072L;
12509                    data[1]=2666130979300507648L;
12510                    data[2]=8809040871152418246L;
12511                    data[3]=1023L;
12512                    return data;
12513            }
12514            public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
12515            private static final long[] mk_tokenSet_79() {
12516                    long[] data = { 0L, 1079508992L, 8L, 0L, 0L, 0L};
12517                    return data;
12518            }
12519            public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
12520            private static final long[] mk_tokenSet_80() {
12521                    long[] data = { 0L, 2413964552567259136L, 16L, 0L, 0L, 0L};
12522                    return data;
12523            }
12524            public static final BitSet _tokenSet_80 = new BitSet(mk_tokenSet_80());
12525            private static final long[] mk_tokenSet_81() {
12526                    long[] data = { 0L, 2413929402418593792L, 16L, 0L, 0L, 0L};
12527                    return data;
12528            }
12529            public static final BitSet _tokenSet_81 = new BitSet(mk_tokenSet_81());
12530            private static final long[] mk_tokenSet_82() {
12531                    long[] data = new long[8];
12532                    data[0]=4810363371522L;
12533                    data[1]=-144185588367523840L;
12534                    data[2]=8809040871140880350L;
12535                    data[3]=1023L;
12536                    return data;
12537            }
12538            public static final BitSet _tokenSet_82 = new BitSet(mk_tokenSet_82());
12539            private static final long[] mk_tokenSet_83() {
12540                    long[] data = { 137438953472L, 2305878159226961920L, 24L, 0L, 0L, 0L};
12541                    return data;
12542            }
12543            public static final BitSet _tokenSet_83 = new BitSet(mk_tokenSet_83());
12544            private static final long[] mk_tokenSet_84() {
12545                    long[] data = new long[8];
12546                    data[0]=4810363371520L;
12547                    data[1]=4431471634118836224L;
12548                    data[2]=8809040871139831646L;
12549                    data[3]=1023L;
12550                    return data;
12551            }
12552            public static final BitSet _tokenSet_84 = new BitSet(mk_tokenSet_84());
12553            private static final long[] mk_tokenSet_85() {
12554                    long[] data = new long[8];
12555                    data[0]=4810363371520L;
12556                    data[1]=1477075090848808960L;
12557                    data[2]=8809040871137730566L;
12558                    data[3]=1023L;
12559                    return data;
12560            }
12561            public static final BitSet _tokenSet_85 = new BitSet(mk_tokenSet_85());
12562            private static final long[] mk_tokenSet_86() {
12563                    long[] data = new long[8];
12564                    data[0]=288484363337728L;
12565                    data[1]=4611686018158919680L;
12566                    data[2]=-1048578L;
12567                    data[3]=1023L;
12568                    return data;
12569            }
12570            public static final BitSet _tokenSet_86 = new BitSet(mk_tokenSet_86());
12571            private static final long[] mk_tokenSet_87() {
12572                    long[] data = { 4810363371520L, 2341766219836620800L, 4128L, 0L, 0L, 0L};
12573                    return data;
12574            }
12575            public static final BitSet _tokenSet_87 = new BitSet(mk_tokenSet_87());
12576            private static final long[] mk_tokenSet_88() {
12577                    long[] data = new long[8];
12578                    data[0]=4810363371520L;
12579                    data[1]=2629996596669906944L;
12580                    data[2]=8809040871137480742L;
12581                    data[3]=1023L;
12582                    return data;
12583            }
12584            public static final BitSet _tokenSet_88 = new BitSet(mk_tokenSet_88());
12585            private static final long[] mk_tokenSet_89() {
12586                    long[] data = { 4810363371520L, 2341766219836620800L, 0L, 0L};
12587                    return data;
12588            }
12589            public static final BitSet _tokenSet_89 = new BitSet(mk_tokenSet_89());
12590            private static final long[] mk_tokenSet_90() {
12591                    long[] data = { 4810363371520L, 3602774117792546816L, 0L, 0L};
12592                    return data;
12593            }
12594            public static final BitSet _tokenSet_90 = new BitSet(mk_tokenSet_90());
12595            private static final long[] mk_tokenSet_91() {
12596                    long[] data = { 0L, 1188950303787974656L, 0L, 0L};
12597                    return data;
12598            }
12599            public static final BitSet _tokenSet_91 = new BitSet(mk_tokenSet_91());
12600            private static final long[] mk_tokenSet_92() {
12601                    long[] data = { 137438953472L, 35150021656576L, 8L, 0L, 0L, 0L};
12602                    return data;
12603            }
12604            public static final BitSet _tokenSet_92 = new BitSet(mk_tokenSet_92());
12605            private static final long[] mk_tokenSet_93() {
12606                    long[] data = { 0L, 2594073385365405696L, 4194304L, 0L, 0L, 0L};
12607                    return data;
12608            }
12609            public static final BitSet _tokenSet_93 = new BitSet(mk_tokenSet_93());
12610            private static final long[] mk_tokenSet_94() {
12611                    long[] data = new long[8];
12612                    data[0]=2L;
12613                    data[1]=8971205610430791680L;
12614                    data[2]=8809040871138525318L;
12615                    data[3]=1023L;
12616                    return data;
12617            }
12618            public static final BitSet _tokenSet_94 = new BitSet(mk_tokenSet_94());
12619            private static final long[] mk_tokenSet_95() {
12620                    long[] data = new long[8];
12621                    data[0]=7009386627074L;
12622                    data[1]=9223372036586307584L;
12623                    data[2]=9223372036854775806L;
12624                    data[3]=1023L;
12625                    return data;
12626            }
12627            public static final BitSet _tokenSet_95 = new BitSet(mk_tokenSet_95());
12628            private static final long[] mk_tokenSet_96() {
12629                    long[] data = { 2L, 8682940083719897088L, 1048704L, 0L, 0L, 0L};
12630                    return data;
12631            }
12632            public static final BitSet _tokenSet_96 = new BitSet(mk_tokenSet_96());
12633            private static final long[] mk_tokenSet_97() {
12634                    long[] data = { 4810363371520L, 3566745320773582848L, 4L, 0L, 0L, 0L};
12635                    return data;
12636            }
12637            public static final BitSet _tokenSet_97 = new BitSet(mk_tokenSet_97());
12638            private static final long[] mk_tokenSet_98() {
12639                    long[] data = { 0L, 25769803776L, 15762598695796744L, 0L, 0L, 0L};
12640                    return data;
12641            }
12642            public static final BitSet _tokenSet_98 = new BitSet(mk_tokenSet_98());
12643            private static final long[] mk_tokenSet_99() {
12644                    long[] data = new long[8];
12645                    data[0]=-16L;
12646                    data[1]=-288230376151711745L;
12647                    data[2]=-1L;
12648                    data[3]=134217727L;
12649                    return data;
12650            }
12651            public static final BitSet _tokenSet_99 = new BitSet(mk_tokenSet_99());
12652            private static final long[] mk_tokenSet_100() {
12653                    long[] data = { 0L, 2594073385379037184L, 117440512L, 0L, 0L, 0L};
12654                    return data;
12655            }
12656            public static final BitSet _tokenSet_100 = new BitSet(mk_tokenSet_100());
12657            private static final long[] mk_tokenSet_101() {
12658                    long[] data = new long[8];
12659                    data[0]=7009386627072L;
12660                    data[1]=4395513205846147072L;
12661                    data[2]=8809040871269859294L;
12662                    data[3]=1023L;
12663                    return data;
12664            }
12665            public static final BitSet _tokenSet_101 = new BitSet(mk_tokenSet_101());
12666            private static final long[] mk_tokenSet_102() {
12667                    long[] data = new long[8];
12668                    data[1]=2594108535924588544L;
12669                    data[2]=8809040871137476614L;
12670                    data[3]=1023L;
12671                    return data;
12672            }
12673            public static final BitSet _tokenSet_102 = new BitSet(mk_tokenSet_102());
12674            private static final long[] mk_tokenSet_103() {
12675                    long[] data = { 0L, 35184372088832L, 108086391056891904L, 0L, 0L, 0L};
12676                    return data;
12677            }
12678            public static final BitSet _tokenSet_103 = new BitSet(mk_tokenSet_103());
12679            private static final long[] mk_tokenSet_104() {
12680                    long[] data = { 0L, 36028798097948672L, 0L, 0L};
12681                    return data;
12682            }
12683            public static final BitSet _tokenSet_104 = new BitSet(mk_tokenSet_104());
12684            private static final long[] mk_tokenSet_105() {
12685                    long[] data = new long[8];
12686                    data[1]=288265526710894592L;
12687                    data[2]=6917529027641081862L;
12688                    data[3]=1023L;
12689                    return data;
12690            }
12691            public static final BitSet _tokenSet_105 = new BitSet(mk_tokenSet_105());
12692            private static final long[] mk_tokenSet_106() {
12693                    long[] data = new long[8];
12694                    data[0]=2L;
12695                    data[1]=9187483976933572608L;
12696                    data[2]=9223372036722397374L;
12697                    data[3]=1023L;
12698                    return data;
12699            }
12700            public static final BitSet _tokenSet_106 = new BitSet(mk_tokenSet_106());
12701            private static final long[] mk_tokenSet_107() {
12702                    long[] data = new long[8];
12703                    data[0]=2L;
12704                    data[1]=9187483976937766912L;
12705                    data[2]=9223372036839837886L;
12706                    data[3]=1023L;
12707                    return data;
12708            }
12709            public static final BitSet _tokenSet_107 = new BitSet(mk_tokenSet_107());
12710            private static final long[] mk_tokenSet_108() {
12711                    long[] data = new long[8];
12712                    data[0]=7009386627072L;
12713                    data[1]=324259141524586496L;
12714                    data[2]=8809040871152418246L;
12715                    data[3]=1023L;
12716                    return data;
12717            }
12718            public static final BitSet _tokenSet_108 = new BitSet(mk_tokenSet_108());
12719            private static final long[] mk_tokenSet_109() {
12720                    long[] data = new long[8];
12721                    data[1]=288265526712991744L;
12722                    data[2]=8809040871137476614L;
12723                    data[3]=1023L;
12724                    return data;
12725            }
12726            public static final BitSet _tokenSet_109 = new BitSet(mk_tokenSet_109());
12727            private static final long[] mk_tokenSet_110() {
12728                    long[] data = new long[8];
12729                    data[0]=2199023255552L;
12730                    data[1]=288335895471980544L;
12731                    data[2]=6917529027655769542L;
12732                    data[3]=1023L;
12733                    return data;
12734            }
12735            public static final BitSet _tokenSet_110 = new BitSet(mk_tokenSet_110());
12736            private static final long[] mk_tokenSet_111() {
12737                    long[] data = new long[8];
12738                    data[0]=7009386627072L;
12739                    data[1]=4359484408822988800L;
12740                    data[2]=8809040871152418814L;
12741                    data[3]=1023L;
12742                    return data;
12743            }
12744            public static final BitSet _tokenSet_111 = new BitSet(mk_tokenSet_111());
12745            private static final long[] mk_tokenSet_112() {
12746                    long[] data = new long[8];
12747                    data[0]=4810363371520L;
12748                    data[1]=324153586241961984L;
12749                    data[2]=8809040871137730566L;
12750                    data[3]=1023L;
12751                    return data;
12752            }
12753            public static final BitSet _tokenSet_112 = new BitSet(mk_tokenSet_112());
12754            private static final long[] mk_tokenSet_113() {
12755                    long[] data = { 2199023255552L, 105518773436416L, 14687680L, 0L, 0L, 0L};
12756                    return data;
12757            }
12758            public static final BitSet _tokenSet_113 = new BitSet(mk_tokenSet_113());
12759            
12760            }