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