View Javadoc

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